Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
  • Nov 24 11:03
    daanzu commented #360
  • Nov 24 08:58
    daanzu synchronize #360
  • Nov 21 05:25
    Danesprite labeled #363
  • Nov 21 05:25
    Danesprite labeled #363
  • Nov 21 05:25
    Danesprite labeled #363
  • Nov 21 05:25
    Danesprite opened #363
  • Nov 15 11:08

    Danesprite on minor

    Improve X11 detection by checki… Change accessibility sub-packag… (compare)

  • Nov 15 07:25
    Danesprite commented #361
  • Nov 15 07:08
    Danesprite assigned #362
  • Nov 15 07:08
    Danesprite labeled #362
  • Nov 15 07:08
    Danesprite opened #362
  • Nov 15 06:13
    Danesprite commented #361
  • Nov 15 06:05

    Danesprite on minor

    Cleanup code in some initializa… Give X11 precedence over other … (compare)

  • Nov 14 12:49

    Danesprite on minor

    Cleanup code in some initializa… Give X11 precedence over other … (compare)

  • Nov 14 06:39
    wolfmanstout commented #361
  • Nov 14 05:35
    Danesprite assigned #361
  • Nov 14 05:35
    Danesprite labeled #361
  • Nov 14 05:35
    Danesprite labeled #361
  • Nov 14 05:35
    Danesprite opened #361
  • Nov 10 13:21

    Danesprite on minor

    Clean up the code in actions/mo… Have internal pynput controller… (compare)

Dane Finlay
@Danesprite
No worries. :-)
timoses
@timoses:matrix.org
[m]
Shouldn't it be possible calling Key from a Function Action? It somehow does not seem to execute Key.. It does if I use Key directly in the Mapping..
    def omgzo(**test):
        print('uffi')
        Key('j')

    class TmuxRule(MappingRule):

        mapping = {
            "pane (<dir>|<n>)":
                #Function(lambda **test: Key('j'))
                Function(omgzo)
                #Key('j')
(It does print 'uffi')..
LexiconCode
@LexiconCode
@timoses:matrix.org When utilizing dragonfly within functions add .execute() after the actionKey('j').execute() . You can execute python files with dragonfly without speech engine and it will execute the actions along with any other code. Example below:
from dragonfly import Key

def omgzo():
    print('uffi')
    Key('j').execute()

omgzo()
timoses
@timoses:matrix.org
[m]
Aw ty. I knew there was something in the bushes : )
Dane Finlay
@Danesprite
I have released Dragonfly2 version 0.30.1, which includes fixes for some DNS dictation formatting bugs.
LexiconCode
@LexiconCode
@Danesprite Awesome! Congrats another release!
Dane Finlay
@Danesprite
:)
DanKaplanSES
@DanKaplanSES
image.png
I restarted my computer and now get this error message when I start Dragon:
should I follow those instructions or will that mess things up?
Dane Finlay
@Danesprite

@tieTYT Haven't seen that error before, thanks for mentioning it on here and for the KB solution link :+1:

I don't know about Dragon, but Compatibility Mode shouldn't cause issues with pywin32, Natlink or Dragonfly since these were written to work with older (then new) versions of Windows.

Quintijn Hoogenboom
@quintijn
I have not seen this message before either. Sorry...
Vojtěch Drábek
@comodoro
Is there an easy equivalent to Choice with identical mapping, i.e. 'a': 'a' etc?
Which seems redundant
Vojtěch Drábek
@comodoro
Hmm, looks like List:)
Dane Finlay
@Danesprite
@comodoro List works. You could also use dictionary comprehension:
Choice("choice", {key:key for key in [
    "a", "b", "c"
]})
Vojtěch Drábek
@comodoro
Actually it works with ListRef (List is not instance of ElementBase) which itself works on top of List, so there might be room for an element combining them? Using Choice this way is OK, but I suppose not that Pythonic.
Vojtěch Drábek
@comodoro
By the way Choice could just also accept a list (Sorry if it looks like something important and thanks for the suggestion, it is just semantics)
Stretching it too far, maybe even iterable:-)
David Zurow
@daanzu
Ha, I encountered just this question a couple nights ago. I eventually just used a dictionary comprehension, but I do wonder about adding something to dragonfly. I maybe lean towards adding a ChoiceList, so that Choice keeps its type checking, but I'm not sure.
Dane Finlay
@Danesprite

Yes, right, it would be ListRef not List. I have no objection to a simple ChoiceList element. It would have to be implemented differently to Choice, since the dictionary keys given to Choice elements are in fact used as Compound element specs, so that, for example, the following element's value is logically decoded to "a", "b" or "c":

Choice("letter", {
    "alpha|a": "a",
    "bravo|b": "b",
    "charlie|c": "c",
})

I guess it should work more like this instead:

Compound(spec="a|b|c", name="letter")

# Or

Compound(spec="|".join(["a", "b", "c"]), name="letter")
Dane Finlay
@Danesprite
Choice could probably just accept lists too and handle them as above.
Vojtěch Drábek
@comodoro
That would be my first pick (because there is very few typing or thinking involved), I don't know what the general stance on different types of the same parameter is though.
Dane Finlay
@Danesprite
Yes, changing Choice to accept lists and tuples seems like the best option here. I have no problem with the parameter having different types.
LexiconCode
@LexiconCode
Thinking on this it would be really nice improvement. I assume it wouldn't be mutable if the list is updated.
David Zurow
@daanzu
This would be a nice quality-of-life improvement.
@LexiconCode It would only be mutable if ListRef was used underneath.
Dane Finlay
@Danesprite
Agreed, I'll add this in the next release. No, it would not be mutable since this would use Literal, not ListRef.
Dane Finlay
@Danesprite
@tripfish Yeah, time will tell what this means for Dragon. As Aaron has said in a few other channels, Microsoft and Nuance have had a close working relationship for a while. It seems that this acquisition is more related to Nuance's cloud solutions.
westocl
@westocl
I have been calling the text engine with Popen(["python", "-m", "dragonfly", "test",...]) as a subprocess
and PIPE'ing the std_in and std_out. Is there another other way to do somethin similar without having to use a subprocess?
Dane Finlay
@Danesprite
@westocl Sure. You could initialise a "text" engine instance and use it instead. What is your use case for the test command?
westocl
@westocl

I started a server, and am feeding the recogninzed commands from a client computer over a socket.
From there i was taking the command and piping it into the std_input.

I was trying to see the viablity of just having the text engine on the server and having the client
just have gramamrs that recognize and send teh command over a socket or http.

So if I understand you correctly. I would
1) load the grammars
2) call get_engine(text).mimic(...)

I was strill trying to simulate the on_before(), on_recognize(), and post_recognize(), so somehow i would need to call
engine.do_recognition() ?

does mimic(...) need to have the proper window title and executable or is there a way to bypass the context

LexiconCode
@LexiconCode
The test engine which utilizes mimic should utilize the grammar contexts. I'm not sure about the bypass. This would be an interesting concept for those that work remote support over VM/RDP.
I'm not sure if there's a way to recognize If a spec is valid without at executing it's associated action.
westocl
@westocl

Hmmm... yea i have been thinking about setting this up for a couple of months now and finally got some time to do it.

I plan on getting it set up soon even if the first verion is all hacked together.

Right now i have two applications both with the same grammars. On the client side, I stripped away all the mapping functions and process_recogningion functions.
On sapi5 recognition, client it pings the server. The server runs the text engine and the server replies back with a string that the client uses for its next grammar context function.
Its crude but works pretty well actually.

Right now both the client and server are on the same pc, but looks like its gonna work. When im done i will put the server on a website.

I'll let you guys know when i get something up running.

LexiconCode
@LexiconCode
@westocl what engine are you using?
westocl
@westocl
Windows Sapi5
LexiconCode
@LexiconCode
Have you considered using Kaldi? With it might be possible to transmit audio over the network to the host. That way you don't have to have grammars on both.
westocl
@westocl
@LexiconCode Really? How would I avoid having grammars on both. What is different about Kaldi? I have been hearing about it but didnt know what made it more useful
@LexiconCode just read you message again. 'transmit audio'... never thought of going that way
LexiconCode
@LexiconCode
I spent a lot of time trying to figure out how to do this well Dragon but DNS loves to ignore professional/virtual microphones. Kaldi Would definitely not have this problem and I can't speak to Sapi5. I definitely can say though Kaldi is faster and more accurate than Sapi5 in my experience.
1 reply
So my thought would be to set up a virtual microphone on the remote OS and stream microphone audio from the local OS.
There are some use cases where this is not practical like remote support but it would work when you have control both of the local and remote environments.
westocl
@westocl
@LexiconCode I like this idea also. Its good that there may be a couple of ways to approach it. i will definitly look at Kaldi once i get this setup. Ill let you know how it turns out. Thanks
The text engine approach guarantees they cant ignore the microphones :)
LexiconCode
@LexiconCode
:)
Dane Finlay
@Danesprite

@westocl Ah, okay then, interesting use case!

If you haven't already, I would suggest looking at the source code for the python -m dragonfly test command. It shouldn't be too difficult to do this in your Python process instead.

Regarding window contexts for engine.mimic(), you can pass the remote window context to the method (see TextInputEngine.mimic()). This is specific to the text-input back-end. This is not really good enough for this sort of server-client interaction, however. For that, you would need to have Dragonfly use remote platform implementations of classes like Window and Keyboard.

You may also want to have a look at look at Aenea, which does something similar with Dragonfly. This would be easier IMO. I believe it still needs to be ported to Python 3, however.