def __init__(self, g, func, a, k): self.func = func self.g = g self.a = a self.k = k try: self.name = SName("_" + str(g)) except UnicodeDecodeError: try: self.name = SName("_" + str(g)[:-5]) except UnicodeDecodeError: self.name = SName("_" + str(g)[:-10])
def __init__(self, parent, *args): self.parent = parent if args: self.args = SName(args) for k in self.args: if hasattr(k, 'startswith') and k.startswith('*'): self._simple = False break name = SName(parent.name + self.args) # use self.args because that won't do a multi-roundtrip iteration else: name = parent.name super(EventCallback, self).__init__(name)
def on(self, *args, **kw): doc=kw.pop('doc',None) name=kw.pop('name',None) if len(args) == 1: args = args[0].split('.') args = Name(*args) if name is None: name = SName(args) elif isinstance(name,six.string_types): name = SName(name.split(" ")) def dec(fn): OnEventExec(self.parent, args, name, fn) return fn return dec
def on(self, *args, **kw): doc = kw.pop('doc', None) name = kw.pop('name', None) if len(args) == 1: args = args[0].split('.') args = Name(*args) if name is None: name = SName(args) elif isinstance(name, six.string_types): name = SName(name.split(" ")) def dec(fn): OnEventExec(self.parent, args, name, fn) return fn return dec
def _register(store, io, what): if isinstance(io.typ, six.string_types): io.typ = SName(io.typ) if io.typ in store: raise ValueError("An %sput handler for '%s' is already registered." % \ (what,io.typ)) store[io.typ] = io
def run(self, ctx, **k): event = self.params(self.ctx) if self.new_hc is None: raise SyntaxError( u"‹fs20 switch› without sub-statements does nothing!") if self.hc is None: if self.code is None: raise SyntaxError( u"A new ‹fs20 switch› needs a ‹code› sub-statement!") self.hc = SwitchGroup(self.code, SName(event)) elif self.code is not None: self.hc.code = self.code ## update for s in self.old_sw: if s.parent != self.hc: raise RuntimeError( "The named device has house code %d, not %d" % (to_hc(s.parent.code), to_hc(self.hc.code))) s.delete() for s in self.new_sw: if s.code in self.hc.devs: raise RuntimeError(u"The code ‹%d› is already known in ‹%d›" % (to_dev(s.code), to_hc(self.hc.code))) s.parent = self.hc s.add()
def run(self,ctx,**k): event = self.params(ctx) if not len(event): raise SyntaxError(u'Usage: pwm ‹name…›') if self.pwm is None: raise SyntaxError(u'Usage: pwm ‹name…›: requires ‹type›') self.pwm(self,SName(event), **self.attrs)
def run(self,ctx,**k): event = self.params(ctx) if len(event) < 1: raise SyntaxError(u"Usage: monitor input ‹name…›") self.name = SName(event) self.values["var"] = self.name super(MonitorMaker,self).run(ctx,**k)
def run(self,ctx,**k): event = self.params(self.ctx) if not len(event): raise SyntaxError(u"‹fs20 em› needs a name") if self.code is None: raise SyntaxError(u"‹fs20 em› needs a 'code' sub-statement") EM(SName(event), self.group,self.code,ctx, self.faktor,self.offset, self.slot)
def list(self): yield (six.text_type(self), ) yield ("id", self.id) if hasattr(self, "event"): yield ("event", SName(self.event)) if self.name: yield ("name", SName(self.name)) yield ("call count", str(self.call_count)) if self.last_call: yield ("last call", self.last_call) if self.last_args: for a, b in self.last_args.items(): yield ("last", a, b) for r in self.report(verbose=98): yield ("code", r) s = super(WorkItem, self) if hasattr(s, 'list'): yield s
def run(self,ctx,**k): event = self.params(ctx) if len(event) == 0: raise SyntaxError(u'Usage: update timeslot ‹name…›') if not self.params: raise SyntaxError(u'update timeslot: You did not specify any changes?') timeslot = Timeslots[SName(event)] for p,v in self.params.items(): setattr(timeslot,p,v)
def __init__(self, code, name): self.code = code self.name = SName(name) self.devs = {} self.last_dgram = None if self.code in codes: raise RuntimeError("Device exists (%s)" % (to_hc(self.code), )) super(SwitchGroup, self).__init__() codes[self.code] = self
def start_block(self): event = self.params(self.ctx) if not len(event): raise SyntaxError(u"Usage: fs20 switch ‹name…›") try: self.hc = SwitchGroups[SName(event)] except KeyError: self.new_hc = True else: self.new_hc = False
def run(self, ctx, **k): event = self.params(ctx) if len(event) < 1: raise SyntaxError(u'Usage: listen amqp ‹conn…›') conn = AMQPclients[SName(event)] dest = self.dest if dest is None: global _seq _seq += 1 dest = Name("_amqp", "a" + str(_seq)) AMQPrecv(self, dest, conn)
def run(self, ctx, **k): event = self.params(ctx) if not len(event): raise SyntaxError(u"Usage: forget state ‹name…›") name = SName(event) global Db if Db is None: from moat.database import DbStore Db = DbStore(category="state") Db.delete(name)
def run(self,ctx,**k): event = self.params(ctx) if not len(event): raise SyntaxError(u'Usage: timeslot ‹name…›') m = Timeslot(self, SName(event)) if "interval" not in self.values: raise SyntaxError(u'Usage: timeslot ‹name…›: need to specify an interval') for p,v in self.values.items(): setattr(m,p,v) if not self.stopped: return m.up()
def run(self, ctx, **k): event = self.params(ctx) if len(event) == 0: raise SyntaxError("Usage: scan onewire BUS") else: try: dev = buses[SName(event)] except KeyError: raise RuntimeError("scan onewire: unknown bus ‹%s›" % (event[0], )) else: return dev.run_watcher()
def run(self, ctx, **k): event = self.params(ctx) if not len(event): raise SyntaxError(u"Usage: add ‹name…›") name = SName(event) if self.code is None: raise SyntaxError(u"Usage: “add” needs a “code” sub-statement") try: handler = handler_names[self.handler] except KeyError: handler = None self.parent.add_sw(Switch(self.code, name, handler=handler))
def __new__(cls): self = dict.__new__(cls) name = SName(self.name) if name in collections: return collections[name] self.name = name self._can_do = set() self.does("list") collections[name] = self return self
def __init__(self, code, name, parent=None, handler=None, can_do=None, init=None): self.parent = parent self.code = code self.name = SName(name) self.handler = handler self.does = set(can_do) if can_do is not None else set(("on", "off")) self.state = None self.ext = None super(Switch, self).__init__()
def run(self,ctx,**k): event = self.params(ctx) if len(event) == 0: raise SyntaxError(u'Usage: update monitor ‹name…›') if not self.params: raise SyntaxError(u'update monitor: You did not specify any changes?') monitor = Monitors[SName(event)] active = monitor.job is not None if active: monitor.down() for p,v in self.params.items(): setattr(monitor,p,v) if active: monitor.up() return d
def __init__(self, event, worker): super(WorkSequence, self).__init__() self.work = [] self.event = event self.worker = worker # if hasattr(event,"id"): # self.id = self.event.id if hasattr(event, "ctx"): self.ctx = event.ctx() else: self.ctx = Context() if isinstance(self.event, Event): en = SName(self.event) else: en = six.text_type(self.event) self.info = u"Worker %d for ‹%s›" % (self.id, en)
def __init__(self, *name): if not name: name = self.name if not name: raise RuntimeError("Unnamed object of '%s'" % (self.__class__.__name__, )) if self.storage is None: raise RuntimeError("You didn't declare a storage for '%s'" % (self.__class__.__name__, )) self.name = name = SName(name) if name in self.storage: self.dup_error(name) super(Collected, self).__init__() self.storage[name] = self self._ectx = Context()
def register_statement(self,handler): """\ Register a handler for a token. handler.run() is called with the rest of the words on the line. handler.name is the first word on the line, which is used to find the handler. If the statement is a multi-line section (the stuff after colon-ized lines, above), handler.input_block() line is called instead. It must return something where its words may be looked up in. handler.end_block() will be called when the block is finished, if it exists. """ handler.name = SName(handler.name) if '_words' not in self.__dict__: self._words = {} if handler.name in self._words: raise ValueError("A handler for '%s' is already registered. (%s)" % (handler.name,self._words[handler.name])) self._words[handler.name] = handler return handler
def __init__(self, conn, parent): self.parent = conn self.exchange = parent.exchange self.strip = parent.strip self.prefix = tuple(parent.prefix) self._direct = parent.shunt self.filter = parent.filter if self._direct: try: i = self.filter.index('*') except ValueError: i = 999 try: i = min(self.filter.index('*'), i) except ValueError: pass if i < self.strip or self.strip and not self.filter: raise RuntimeError( "You can't use 'shunt' if you strip elements you can't restore!" ) for k in self.filter: if hasattr(k, 'startswith') and k.startswith('*'): self._simple = False break name = parent.dest if name is None: global _seq _seq += 1 name = SName(conn.name + ("f" + str(_seq), )) self.channel = self.parent.conn.channel() self.channel.exchange_declare(exchange=self.exchange, type='topic', auto_delete=False, passive=False, durable=True) super(EventCallback, self).__init__(name) register_worker(self, self._direct)
def run(self, ctx, **k): event = self.params(ctx) self.parent.dest = SName(event)
def run(self, ctx, **k): event = self.params(ctx) if not len(event): raise SyntaxError(u'Usage: name "‹text›"') self.parent.displayname = SName(event)
def run(self, ctx, **k): event = self.params(ctx) self.avg(self, SName(event), *self.settings)
def run(self, ctx, **k): event = self.params(ctx) if not len(event): raise SyntaxError(u"Usage: del ‹name…›") self.parent.handler = SName(event)
def run(self, ctx, **k): event = self.params(ctx) if not len(event): raise SyntaxError(u"Usage: del ‹name…›") name = SName(event) self.parent.del_sw(Switches[name])
def __init__(self,parent=None, ctx=None): self.name = SName(self.name) self.parent = parent self.ctx = ctx or Context() self.args = None