Did I find the right examples for you? yes no      Crawl my project      Python Jobs

All Samples(64)  |  Call(48)  |  Derive(0)  |  Import(16)

src/a/e/aenea-HEAD/grammars_available/multiedit.py   aenea(Download)
  pass
 
from dragonfly import (
    Alternative,
    AppContext,
vim_mapping.update(vim_command_table)
 
format_rule = RuleRef(name="format_rule", rule=FormatRule(name="i"))
alternatives = [
      RuleRef(rule=KeystrokeRule(mapping=mapping, name="c")),
      format_rule,
    ]
 
vim_alternatives = [
      RuleRef(rule=KeystrokeRule(mapping=vim_mapping, name="e")),
                        for (key, value) in raul.ALPHANUMERIC.iteritems())
 
alphabet_rule = Sequence([Literal("letters"), Repetition(RuleRef(name="x", rule=MappingRule(name="t", mapping=alphabet_mapping)), min=1, max=20)])
numbers_rule = Sequence([Literal("digits"), Repetition(RuleRef(name="y", rule=MappingRule(name="u", mapping=numbers_mapping)), min=1, max=20)])
alphanumeric_rule = Sequence([Literal("alphanumeric"), Repetition(RuleRef(name="z", rule=MappingRule(name="v", mapping=alphanumeric_mapping)), min=1, max=20)])

src/d/r/dragonfly-scripts-HEAD/_winctrl.py   dragonfly-scripts(Download)
 
import time
from dragonfly import (Grammar, Alternative, RuleRef, DictListRef,
                       Dictation, Compound, Integer, Rule, CompoundRule,
                       DictList, Window, Rectangle, monitors,
        return Window.get_foreground()
 
win_selector = RuleRef(WinSelectorRule(), name="win_selector")
 
 
        return None
 
mon_selector = RuleRef(MonSelectorRule(), name="mon_selector")
 
 
vert_top     = Compound(config.lang.top,    name="vert", value=0.0)
vert_bottom  = Compound(config.lang.bottom, name="vert", value=1.0)
horz_frac    = RuleRef(fraction_rule, name="horz")
vert_frac    = RuleRef(fraction_rule, name="vert")
 

src/a/e/aenea-HEAD/grammars_available/verbal_emacs/motions.py   aenea(Download)
from dragonfly import Alternative, CompoundRule, MappingRule, RuleRef
from proxy_nicknames import Text, Key
from raul import LETTERS
 
from verbal_emacs.common import (
                                                ("outer", "a")):
      mapping["%s %s" % (spoken_modifier, spoken_object)] = Text(command_modifier + command_object)
rulePrimitiveMotion = RuleRef(PrimitiveMotion(), name="PrimitiveMotion")
 
class UncountedMotion(MappingRule):
  mapping = {
    "tect":Text("%%"),
    "matu":Text("M"),
  }
ruleUncountedMotion = RuleRef(UncountedMotion(), name="UncountedMotion")
    "pre fitton":"T",
  }
ruleMotionParameterMotion = RuleRef(MotionParameterMotion(), name="MotionParameterMotion")
 
class ParameterizedMotion(CompoundRule):
    children = node.children[0].children[0].children
    return Text(children[0].value() + children[1].value())
ruleParameterizedMotion = RuleRef(ParameterizedMotion(), name="ParameterizedMotion")
 
class CountedMotion(NumericDelegateRule):

src/a/e/aenea-HEAD/grammars_available/verbal_emacs/insertions.py   aenea(Download)
from dragonfly import (
    MappingRule,
    CompoundRule,
    Dictation,
    RuleRef,
  extras = [ruleDigitalInteger[3]]
  defaults = {"count":1}
ruleKeyInsertion = RuleRef(KeyInsertion(), name="KeyInsertion")
 
class SymbolInsertion(MappingRule):
    "semi":       Key("semicolon"),
  }
ruleSymbolInsertion = RuleRef(SymbolInsertion(), name="SymbolInsertion")
 
class NestedInsertion(MappingRule):
    "nest smote":       Nested("''"),
  }
ruleNestedInsertion = RuleRef(NestedInsertion(), name="NestedInsertion")
 
class SpellingInsertion(MappingRule):
  def value(self, node):
    return Text(MappingRule.value(self, node))
ruleSpellingInsertion = RuleRef(SpellingInsertion(), name="SpellingInsertion")
 
class CCppInsertion(MappingRule):

src/a/e/aenea-HEAD/grammars_available/verbal_emacs.py   aenea(Download)
  pass
 
from dragonfly import (
    Alternative,
    AppContext,
class VimCommand(CompoundRule):
  spec = ("[<app>] [<literal>]")
  extras = [Repetition(Alternative([verbal_emacs.commands.ruleCommand, RuleRef(verbal_emacs.insertions.Insertion())]), max=10, name="app"),
            RuleRef(verbal_emacs.identifiers.LiteralIdentifierInsertion(), name="literal")]
 

src/a/e/aenea-HEAD/grammars_available/nato.py   aenea(Download)
from dragonfly import (
    AppContext,
    CompoundRule,
    Grammar,
    Key,
  extras = [
      Repetition(RuleRef(
          MappingRule(mapping=modifier_keys, name="modmap"),
          name="modifier_atom"),
          1,
          len(modifier_keys),
          name="modifiers"
        ),
        RuleRef(
            MappingRule(mapping=raul.ALPHANUMERIC_EXTENDED, name="keymap"),

src/a/e/aenea-HEAD/grammars_available/vim.py   aenea(Download)
from dragonfly import (
    AppContext,
    Dictation,
    Grammar,
    IntegerRef,
#      "[<count>] ripple <LetterMapping>":Text("%(count)d@%(LetterMapping)s"),
    }
  extras = [RuleRef(MappingRule(mapping=LETTERS, name="maplet"), name="LetterMapping")]
 
grammar.add_rule(EasyMotion())

src/a/e/aenea-HEAD/grammars_available/verbal_emacs/identifiers.py   aenea(Download)
from dragonfly import CompoundRule, Dictation, MappingRule, RuleRef
from proxy_nicknames import Text, Key
 
from verbal_emacs.common import ruleDigitalInteger
 
    "phyhigh":Key("O"),
  }
ruleInsertModeEntry = RuleRef(InsertModeEntry(), name="InsertModeEntry")
 
def format_snakeword(text):
 
    return Text(formatted)
ruleIdentifierInsertion = RuleRef(IdentifierInsertion(), name="IdentifierInsertion")
 
class LiteralIdentifierInsertion(CompoundRule):
    children = node.children[0].children[0].children
    return [("i", (children[0].value(), children[2].value()))]
ruleLiteralIdentifierInsertion = RuleRef(LiteralIdentifierInsertion(), name="LiteralIdentifierInsertion")
 

src/a/e/aenea-HEAD/grammars_available/verbal_emacs/operators.py   aenea(Download)
from dragonfly import Alternative, CompoundRule, MappingRule, RuleRef
from proxy_nicknames import Text
 
from verbal_emacs.common import NumericDelegateRule, ruleDigitalInteger
from verbal_emacs.motions import ruleMotion
  # tComment
  mapping["comm nop"] = Text("gc")
rulePrimitiveOperator = RuleRef(PrimitiveOperator(), name="PrimitiveOperator")
 
class Operator(NumericDelegateRule):
  spec = "[<count>] <PrimitiveOperator>"
  extras = [ruleDigitalInteger[3],
            rulePrimitiveOperator]
ruleOperator = RuleRef(Operator(), name="Operator")
      return_value = children[0].value() + return_value
    return return_value
ruleOperatorApplicationMotion = RuleRef(OperatorApplicationMotion(), name="OperatorApplicationMotion")
 
class OperatorSelfApplication(MappingRule):
      return value
 
ruleOperatorSelfApplication = RuleRef(OperatorSelfApplication(), name="OperatorSelfApplication")
 
ruleOperatorApplication = Alternative([ruleOperatorApplicationMotion,

src/a/e/aenea-HEAD/grammars_available/verbal_emacs/commands.py   aenea(Download)
from dragonfly import Alternative, CompoundRule, MappingRule, RuleRef
 
from proxy_nicknames import Text, Key, NoAction
 
from verbal_emacs.common import (
    "ripple":"macro",
  }
rulePrimitiveCommand = RuleRef(PrimitiveCommand(), name="PrimitiveCommand")
 
class Command(CompoundRule):
    else:
      return [("c", value)]
ruleCommand = RuleRef(Command(), name="Command")
 

  1 | 2  Next