示例#1
0
 def _process(self, sequence, producer):
     if self.wrap:
         products = tuple(map(quickdict, sequence))
         yield (("str", json.encode(quickdict(timetag=datetime.datetime.now(),
                                              products=products))), )
     else:
         for operands in sequence:
             yield (("str", json.encode(quickdict(operands))),)
示例#2
0
 def __sourcetuiostate(self, observable, src):
     """Return the record associated to observable."""
     for ref, sources in self._tuiostate.items():
         if ref() is observable:
             rvalue = sources.setdefault(src, quickdict())
             break
     else:
         rvalue = quickdict()
         self._tuiostate[weakref.ref(observable)] = {src:rvalue}
     return rvalue
示例#3
0
 def _process(self, sequence, producer):
     if self.wrap:
         products = tuple(map(quickdict, sequence))
         yield (("data", pickle.encode(quickdict(timetag=datetime.datetime.now(),
                                                 products=products),
                                       self.protocol)), )
     else:
         for operands in sequence:
             yield (("data", pickle.encode(quickdict(operands),
                                           self.protocol)),)
示例#4
0
 def _process(self, sequence, producer):
     for operands in sequence:
         source = timetag = add = update = remove = None
         for key, value in operands:
             if key=="source": source = value
             elif key=="timetag": timetag = value
             elif "added" in key: add = value
             elif "updated" in key: update = value
             else: remove = value
         if source is None: source = id(producer)
         if timetag is None: timetag = datetime.datetime.now()
         record = self._buffer.setdefault(source, {})
         if add is not None:
             for key, value in add.items():
                 record[key] = [(timetag, value)]
         if update is not None:
             for key, value in update.items():
                 stroke = record.setdefault(key, [])
                 stroke.append((timetag, value))
         if remove is not None:
             results = []
             for key in remove.keys():
                 stroke = record.pop(key)
                 # FIXME: this should be done in a separated Node.
                 l = lambda o: quickdict(t=o[0],
                                         x=o[1]['rel_pos'][0]*100,
                                         y=o[1]['rel_pos'][1]*100)
                 stroke = tuple(map(l, stroke))
                 # ---
                 results.append(("gestures.%s"%key, dict(stroke=stroke,
                                                         cls=self.cls)))
             if results: yield results
示例#5
0
 def _draw(self):
     stream = io.StringIO()
     memo = set()
     for node in self._starters:
         self._grapher.draw(node, stream, maxdepth=self.maxdepth, memo=memo)
     graph = stream.getvalue()
     if graph: self.postProduct(quickdict(str=self.separator+graph))
示例#6
0
 def test_encode_decode(self):
     obj = quickdict(a=CustomClass(),
                     timetag=datetime.datetime.now(),
                     data=b"unittest")
     encoded = pickle.encode(obj)
     decoded = pickle.decode(encoded)
     self.assertEqual(obj, decoded)
示例#7
0
 def __produce(self):
     if self._update:
         self._update = False
         data = io.StringIO()
         intro = False
         for ref, record in self.__stat.items():
             if record.partial>0:
                 if not intro:
                     delta = datetime.datetime.now() - self._inittime
                     data.write("Statistics after %s\n"%delta)
                     intro = True
                 record.tot += record.partial
                 data.write(str(ref()))
                 data.write("\n")
                 data.write("  tags: %s\n"%record.tags)
                 if record.lagmax is not None:
                     msecs = record.lagmax.seconds*1000 \
                         +record.lagmax.microseconds/1000
                     record.lagmax = None
                     data.write("  tot=%d, hz=%g, lagmax=%f ms\n"%(
                             record.tot,
                             record.partial*1000/self.__timer.interval(),
                             msecs))
                 else:
                     data.write("  tot=%d, hz=%d\n"%(record.tot, record.partial))
                 record.partial = 0
                 record.tags.clear()
         if intro: data.write("\n")
         self.postProduct(quickdict(str=data.getvalue()))
示例#8
0
 def _consume(self, products, producer):
     for product in products:
         diff = product.get("diff")
         if isinstance(diff, collections.Mapping):
             source = product.get("source")
             record = self._sources.setdefault(
                 source,
                 quickdict({"state": StateMachine(),
                            "color": (QtGui.QColor(*colors[len(self._sources)%12]),
                                      QtGui.QColor(QtCore.Qt.black))}))
             # Update state
             record.state.applyDiff(diff)
             # Update history
             history = record.history
             for key, event in diff.items():
                 if key in ("added", "updated"):
                     for gid, value in event["contacts"].items():
                         track = history.setdefault(gid, [])
                         if track or "rel_pos" in value: track.append(value)
                 elif key=="removed":
                     for key in event.get("contacts", tuple()):
                         history.pop(key, None)
                 else:
                     raise ValueError("Unexpected key for a diff: %s", key)
             self.gui().update()
示例#9
0
 def _postData(self):
     data = self.__input.read()
     attr = "str" if self._textmode else "data"
     if attr in self._activetags and (data or self.postend):
         product = quickdict()
         product[attr] = data
         self.postProduct(product)
示例#10
0
 def append(self, products):
     """Store products as a buffer item."""
     record = quickdict()
     record.timetag = datetime.datetime.now()
     record.products = products
     self._buffer.append(record)
     self._sum += len(products)
     if not self._checkSizeLimit(): self.changed.emit()
示例#11
0
 def __init__(self, request=QRequest("diff.*.contacts|source|timetag"),
              blender=Functor.RESULTONLY, rawsource=False,
              hz=None, parent=None):
     super().__init__(request, Offer(quickdict(osc=osc.Packet)), blender,
                      hz=hz, parent=parent)
     # self._tuiostate[observable-ref][source][profile] = [fseq, {s_id: TuioDescriptor}]
     self._tuiostate = {}
     self.observableRemoved.connect(self.__removeRecord)
     self._rawsource = assertIsInstance(rawsource, bool)
示例#12
0
 def __init__(self, request=Request.ANY, fps=1, parent=None):
     super().__init__(request, Offer(quickdict(str=str())), Functor.RESULTONLY,
                      parent=parent)
     self.__timer = QtCore.QTimer(timeout=self.__produce)
     self.__timer.start(1000/float(fps))
     self._inittime = datetime.datetime.now()
     self.__stat = {}
     self._update = False
     self.observableRemoved.connect(self.__removeRecord)
示例#13
0
 def __init__(self, starters=tuple(), request=Request.ANY, maxdepth=None,
              hz=1, parent=None):
     super().__init__(Offer(quickdict(str=str())), parent=parent)
     self._starters = starters
     self._grapher = SimpleGrapher(request)
     self.__tid = QtCore.QTimer(timeout=self._draw)
     if hz: self.__tid.start(1000/hz)
     if hz<1: QtCore.QTimer.singleShot(100, self._draw)
     self.maxdepth = maxdepth
     self.separator = SimpleGrapherProducer._SEPARATOR
示例#14
0
 def __init__(self, rt=False, blender=Functor.MERGECOPY, parent=None):
     timetag = datetime.datetime.now()
     super().__init__(
         QRequest("data"),
         Offer(quickdict(
                 osc=osc.Bundle(timetag,
                                (osc.Bundle(timetag, (Offer.UNDEFINED, )),
                                 osc.Message(str(), str(), Offer.UNDEFINED),
                                 Offer.UNDEFINED)),
                 timetag=timetag)),
         blender, parent=parent)
     self._receipttime = assertIsInstance(rt, bool)
示例#15
0
 def __init__(self, request=Request.ANY, mode="items", separator="\n",
              src=False, dest=False, depth=None, parent=None):
     super().__init__(request, Offer(quickdict(str=str())), Functor.RESULTONLY,
                      parent=parent)
     self.dumpsrc = assertIsInstance(src, bool)
     self.dumpdest = assertIsInstance(dest, bool)
     self.depth = None if depth is None else int(depth)
     if mode not in ("items", "values", "keys"): raise ValueError(
         "mode must be 'items' or 'values' or 'keys', not '%s'"%mode)
     else:
         self._mode = mode
     self.separator = assertIsInstance(separator, str, None)
     if self.separator is None: self.separator = ""
示例#16
0
 def __init__(self, filename, **kwargs):
     timetag = datetime.datetime.now()
     super().__init__(
         filename,
         OscLogPlayer._Decoder(),
         OscLogPlayer._Sender(),
         offer=Offer(quickdict(
                 osc=osc.Bundle(timetag,
                                (osc.Bundle(timetag, (Offer.UNDEFINED, )),
                                 osc.Message(str(), str(), Offer.UNDEFINED),
                                 Offer.UNDEFINED)),
                 timetag=timetag)),
                      **kwargs)
示例#17
0
    def __init__(self, inputdevice, postend=True, parent=None):
        """:class:`Producer <boing.core.Producer>` node that anytime
        the device *inputdevice* send the signal :attr:`readyRead
        <boing.utils.fileutils.CommunicationDevice.readyRead>` it
        reads the device and it produces a message containing the
        data. The provided products is a dictionary ``{"str": data}``
        if ``data`` is a string, otherwise the product will be a
        dictionary like ``{"data": data}``.  If the argument *postend*
        is set to ``True``, the :class:`DataReader` will never produce
        an empty product, like ``{"str": ""}`` or ``{"data":
        b""}``. *parent* defines the parent of the node.

        """
        self._textmode = inputdevice.isTextModeEnabled()
        if self._textmode:
            offer = Offer(quickdict(str=str()))
            tags = dict(str=QRequest("str"))
        else:
            offer = Offer(quickdict(data=bytearray()))
            tags = dict(data=QRequest("data"))
        super().__init__(offer, tags=tags, parent=parent)
        self.__input = inputdevice
        self.__input.readyRead.connect(self._postData)
        self.postend = assertIsInstance(postend, bool)
示例#18
0
 def getTemplate():
     template = quickdict()
     contact = template.diff.added.contacts[0]
     contact.rel_pos = tuple()
     contact.rel_speed = tuple()
     contact.rel_accel = tuple()
     contact.si_angle = tuple()
     contact.objclass = tuple()
     contact.boundingbox.rel_pos = tuple()
     contact.boundingbox.rel_speed = tuple()
     contact.boundingbox.si_angle = tuple()
     contact.boundingbox.rel_size = tuple()
     template.diff.updated.contacts[0] = contact
     template.diff.removed.contact[0] = None
     template.source = str()
     return template
示例#19
0
 def _process(self, sequence, producer):
     stream = io.StringIO()
     if self.dumpsrc:
         stream.write("from: %s\n"%str(producer))
     if self.dumpdest:
         stream.write("DumpNode(request=%s)\n"%repr(str(self.request())))
     for operands in sequence:
         data = quickdict(operands)
         if self.mode()=="items":
             deepDump(data, stream,
                      None if self.depth is None else self.depth+1)
             stream.write(self.separator)
         elif self.mode()=="values":
             values = tuple(data.values())
             deepDump(values if len(values)>1 else values[0],
                      stream, self.depth)
             stream.write(self.separator)
         elif self.mode()=="keys":
             deepDump(tuple(data.keys()), stream, self.depth)
             stream.write(self.separator)
     yield (("str", stream.getvalue()),)
示例#20
0
 def __handleOsc(self, packet):
     source = fseq = profile = None
     desc = {}
     alive = set()
     for msg in packet.elements:
         if msg.address.startswith("/tuio/"):
             profile = msg.address[6:]
             command = msg.arguments[0]
             if command=="source":
                 source = msg.arguments[1]
             elif command=="fseq":
                 fseq = int(msg.arguments[1])
             elif command=="alive":
                 alive = set(msg.arguments[1:])
             elif command=="set":
                 tobj = tuio.TuioDescriptor(msg.source,
                                            profile, packet.timetag,
                                            source, fseq,
                                            *msg.arguments[1:])
                 desc[tobj.s] = tobj
     if source is None and not self._rawsource:
         source = "Tuio#%d"%id(self)
     # TODO: old bundles rejection based on fseq
     # Update the contacts with the bundle information
     for s_id, tobj in desc.items():
         source_ids = self.__idpairs.setdefault(source, {})
         gid = source_ids.get(s_id)
         if gid is None:
             gid = self.__nextId()
             source_ids[s_id] = gid
         if profile=="2Dcur":
             node = quickdict()
             if tuio.TuioDescriptor.undef_value not in [tobj.x, tobj.y]:
                 node.rel_pos = [tobj.x, tobj.y]
             if tuio.TuioDescriptor.undef_value not in [tobj.X, tobj.Y]:
                 node.rel_speed = [tobj.X, tobj.Y, 0, 0]
             yield "diff.updated.contacts.%s"%gid, node
         elif profile in ("25Dcur", "3Dcur"):
             node = quickdict()
             node.rel_pos = [tobj.x, tobj.y, tobj.z]
             node.rel_speed = [tobj.X, tobj.Y, tobj.Z, 0]
             yield "diff.updated.contacts.%s"%gid, node
         elif profile=="2Dblb":
             node = quickdict()
             if tuio.TuioDescriptor.undef_value not in [tobj.x, tobj.y]:
                 node.rel_pos = [tobj.x, tobj.y]
             if tuio.TuioDescriptor.undef_value not in [tobj.X, tobj.Y]:
                 node.rel_speed = [tobj.X, tobj.Y, 0, 0]
             node.si_angle = [tobj.a, ]
             node.rel_size = [tobj.w, tobj.h]
             yield "diff.updated.contacts.%s.boundingbox"%gid, node
         elif profile=="25Dblb":
             node = quickdict()
             node.rel_pos = [tobj.x, tobj.y, tobj.z]
             node.rel_speed = [tobj.X, tobj.Y, tobj.Z, 0]
             node.si_angle = [tobj.a, ]
             node.rel_size = [tobj.w, tobj.h]
             yield "diff.updated.contacts.%s.boundingbox"%gid, node
         elif profile=="3Dblb":
             node = quickdict()
             node.rel_pos = [tobj.x, tobj.y, tobj.z]
             node.rel_speed = [tobj.X, tobj.Y, tobj.Z, 0]
             node.si_angle = [tobj.a, tobj.b, tobj.c]
             node.rel_size = [tobj.w, tobj.h, tobj.d]
             yield "diff.updated.contacts.%s.boundingbox"%gid, node
         elif profile=="2Dobj":
             node = quickdict()
             if tuio.TuioDescriptor.undef_value not in [tobj.x, tobj.y]:
                 node.rel_pos = [tobj.x, tobj.y]
             if tuio.TuioDescriptor.undef_value not in [tobj.X, tobj.Y]:
                 node.rel_speed = [tobj.X, tobj.Y, 0, 0]
             node.objclass = tobj.i
             node.si_angle = [tobj.a, ]
             yield "diff.updated.contacts.%s"%gid, node
         elif profile=="25Dobj":
             node = quickdict()
             node.rel_pos = [tobj.x, tobj.y, tobj.z]
             node.rel_speed = [tobj.X, tobj.Y, tobj.Z, 0]
             node.objclass = tobj.i
             node.si_angle = [tobj.a, ]
             yield "diff.updated.contacts.%s"%gid, node
         elif profile=="3Dobj":
             node = quickdict()
             node.rel_pos = [tobj.x, tobj.y, tobj.z]
             node.rel_speed = [tobj.X, tobj.Y, tobj.Z, 0]
             node.objclass = tobj.i
             node.si_angle = [tobj.a, tobj.b, tobj.c]
             yield "diff.updated.contacts.%s"%gid, node
     # Remove items that are not alive
     src_profiles = self.__alive.setdefault(source, {})
     alive_old = src_profiles.get(profile, set())
     toRemove = alive_old - alive
     for s_id in toRemove:
         # Check if other profiles has the same session_id still alive
         keep = False
         for p, a in src_profiles.items():
             if p==profile: continue
             elif s_id in a:
                 keep = True
                 break
         if not keep:
             gid = self.__idpairs.get(source, {}).pop(s_id, None)
             if gid is not None:
                 yield "diff.removed.contacts.%s"%gid, None
     src_profiles[profile] = alive
     yield "source", source
示例#21
0
 def __init__(self, wrap=False, protocol=None,
              request=QRequest.ANY, blender=Functor.MERGECOPY, parent=None):
     super().__init__(request, Offer(quickdict(data=bytes())),
                      blender, parent=parent)
     self.wrap = assertIsInstance(wrap, bool)
     self.protocol = assertIsInstance(protocol, None, int)
示例#22
0
 def __init__(self, parent=None):
     # It is forced to be use a RESULTONLY blender because for each
     # received product, it may produce multiple products.
     super().__init__(QRequest("data"), Offer(quickdict(data=bytearray())),
                      Functor.RESULTONLY, parent=parent)
     self._slipbuffer = None
示例#23
0
 def __init__(self, blender=Functor.MERGECOPY, parent=None):
     super().__init__(QRequest("data"), Offer(quickdict(data=bytearray())),
                      blender, parent=parent)
示例#24
0
 def _encodeEvent(self, event, producer):
     # Set of s_id that have been updated.
     # setters[<profile>] = {s_id1, s_id2, ..., s_idn}
     setters = {}
     # Set of profiles for which a s_id have been removed
     removed = set()
     diff = event["diff"]
     source = event.get("source")
     if source is None and not self._rawsource:
         source = "Tuio#%d"%id(self)
     sourcetuiostate = self.__sourcetuiostate(producer, source)
     toupdate = None
     if "added" in diff: toupdate = diff.added.contacts
     if "updated" in diff:
         if toupdate is None:
             toupdate = diff.updated.contacts
         else:
             deepupdate(toupdate, diff.updated.contacts)
     if toupdate is not None:
         for gid, gdiff in toupdate.items():
             # Determine the TUIO profiles for the gesture event
             profiles = set()
             for profile, profilestate in sourcetuiostate.items():
                 if gid in profilestate[1]: profiles.add(profile)
             if not profiles:
                 if "rel_pos" in gdiff:
                     if "objclass" in gdiff:
                         if len(gdiff.rel_pos)==2:
                             profiles.add("2Dobj")
                         elif len(gdiff.rel_pos)==3:
                             profiles.add("3Dobj")
                     elif len(gdiff.rel_pos)==2:
                         profiles.add("2Dcur")
                     elif len(gdiff.rel_pos)==3:
                         profiles.add("3Dcur")
                 if "boundingbox" in gdiff:
                     if "rel_pos" in gdiff.boundingbox:
                         if len(gdiff.boundingbox.rel_pos)==2:
                             profiles.add("2Dblb")
                         elif len(gdiff.boundingbox.rel_pos)==3:
                             profiles.add("3Dblb")
                     elif "rel_pos" in gdiff:
                         if len(gdiff.rel_pos)==2:
                             profiles.add("2Dblb")
                         elif len(gdiff.rel_pos)==3:
                             profiles.add("3Dblb")
             elif len(profiles)==1 and "boundingbox" in gdiff:
                 if "rel_pos" in gdiff.boundingbox:
                     if len(gdiff.boundingbox.rel_pos)==2:
                         profiles.add("2Dblb")
                     elif len(gdiff.boundingbox.rel_pos)==3:
                         profiles.add("3Dblb")
                 else:
                     for other in profiles: break
                     if other.startswith("2D"): profiles.add("2Dblb")
                     elif other.startswith("3D"): profiles.add("3Dblb")
             # Create set descriptors for each updated profile
             for profile in profiles:
                 update = False
                 profilestate = sourcetuiostate.setdefault(
                     profile, [0, {}])
                 if gid in profilestate[1]:
                     prev = profilestate[1][gid]
                 else:
                     len_ = len(tuio.TuioDescriptor.profiles[profile])
                     prev = tuio.TuioDescriptor(
                         None, profile, None, None, None,
                         *([tuio.TuioDescriptor.undef_value]*len_))
                     prev.s = int(gid)
                     profilestate[1][gid] = prev
                     update = True
                 if profile=="2Dcur":
                     if "rel_pos" in gdiff:
                         prev.x, prev.y = gdiff.rel_pos[:2]
                         update = True
                     if "rel_speed" in gdiff:
                         prev.X, prev.Y = gdiff.rel_speed[:2]
                         update = True
                 elif profile in ("25Dcurr", "3Dcur"):
                     if "rel_pos" in gdiff:
                         prev.x, prev.y, prev.z= gdiff.rel_pos[:3]
                         update = True
                     if "rel_speed" in gdiff:
                         prev.X, prev.Y, prev.Z = gdiff.rel_speed[:3]
                         update = True
                 elif profile=="2Dobj":
                     if "rel_pos" in gdiff:
                         prev.x, prev.y = gdiff.rel_pos[:2]
                         update = True
                     if "rel_speed" in gdiff:
                         prev.X, prev.Y = gdiff.rel_speed[:2]
                         update = True
                     if "si_angle" in gdiff:
                         prev.a = gdiff.si_angle[0]
                         update = True
                     if "objclass" in gdiff:
                         prev.i = gdiff.objclass
                         update = True
                 elif profile=="25Dobj":
                     if "rel_pos" in gdiff:
                         prev.x, prev.y, prev.z= gdiff.rel_pos[:3]
                         update = True
                     if "rel_speed" in gdiff:
                         prev.X, prev.Y, prev.Z = gdiff.rel_speed[:3]
                         update = True
                     if "si_angle" in gdiff:
                         prev.a = gdiff.si_angle[0]
                         update = True
                     if "objclass" in gdiff:
                         prev.i = gdiff.objclass
                         update = True
                 elif profile=="3Dobj":
                     if "rel_pos" in gdiff:
                         prev.x, prev.y, prev.z= gdiff.rel_pos[:3]
                         update = True
                     if "rel_speed" in gdiff:
                         prev.X, prev.Y, prev.Z = gdiff.rel_speed[:3]
                         update = True
                     if "si_angle" in gdiff:
                         prev.a, prev.b, prev.c = gdiff.si_angle[:3]
                         update = True
                     if "objclass" in gdiff:
                         prev.i = gdiff.objclass
                         update = True
                 elif profile=="2Dblb":
                     if "boundingbox" in gdiff:
                         bb = gdiff.boundingbox
                         if "rel_pos" in bb:
                             prev.x, prev.y = bb.rel_pos[:2]
                             update = True
                         if "rel_speed" in bb:
                             prev.X, prev.Y = bb.rel_speed[:2]
                             update = True
                         if "si_angle" in bb:
                             prev.a = bb.si_angle[0]
                             update = True
                         if "rel_size" in bb:
                             prev.w, prev.h = bb.rel_size[:2]
                             update = True
                 elif profile=="25Dblb":
                     if "boundingbox" in gdiff:
                         bb = gdiff.boundingbox
                         if "rel_pos" in bb:
                             prev.x, prev.y, prev.z = bb.rel_pos[:3]
                             update = True
                         if "rel_speed" in bb:
                             prev.X, prev.Y, prev.Z = bb.rel_speed[:3]
                             update = True
                         if "si_angle" in bb:
                             prev.a = bb.si_angle[0]
                             update = True
                         if "rel_size" in bb:
                             prev.w, prev.h = bb.rel_size[:2]
                             update = True
                 elif profile=="3Dblb":
                     if "boundingbox" in gdiff:
                         bb = gdiff.boundingbox
                         if "rel_pos" in bb:
                             prev.x, prev.y, prev.z = bb.rel_pos[:3]
                             update = True
                         if "rel_speed" in bb:
                             prev.X, prev.Y, prev.Z = bb.rel_speed[:3]
                             update = True
                         if "si_angle" in bb:
                             prev.a, prev.b, prev.c = bb.si_angle[:3]
                             update = True
                         if "rel_size" in bb:
                             prev.w, prev.h, prev.d = bb.rel_size[:3]
                             update = True
                 if update: setters.setdefault(profile, set()).add(gid)
     if "removed" in diff:
         for gid in diff.removed.contacts.keys():
             for profile, profilestate in sourcetuiostate.items():
                 if gid in profilestate[1]:
                     del profilestate[1][gid]
                     removed.add(profile)
                     if profile in setters:
                         setters[profile].discard(gid)
     # Create an OSC bundle
     packets = []
     for profile in (set(setters.keys()) | removed):
         profilestate = sourcetuiostate[profile]
         sourcemsg = osc.Message("/tuio/%s"%profile, "ss", "source", source)
         alive = list(int(gid) for gid in profilestate[1].keys())
         alivemsg = osc.Message("/tuio/%s"%profile,
                                "s"+"i"*len(alive), "alive", *alive)
         msgs = [sourcemsg, alivemsg]
         profilesetters = setters.get(profile)
         if profilesetters is not None:
             setmsgs = []
             for s_id in profilesetters:
                 desc = profilestate[1][s_id]
                 args = []
                 for name in tuio.TuioDescriptor.profiles[profile]:
                     args.append(getattr(desc, name))
                 setmsgs.append(osc.Message("/tuio/%s"%profile,
                                            None, "set", *args))
             msgs.extend(setmsgs)
         msgs.append(osc.Message("/tuio/%s"%profile, "si", "fseq",
                                 profilestate[0]))
         profilestate[0] += 1
         forward = quickdict()
         forward.osc = osc.Bundle(event.get("timetag"), msgs)
         self.postProduct(forward)
示例#25
0
 def __init__(self, wrap=False,
              request=QRequest.ANY, blender=Functor.MERGECOPY, parent=None):
     super().__init__(request, Offer(quickdict(str=str())),
                      blender, parent=parent)
     self.wrap = assertIsInstance(wrap, bool)
示例#26
0
 def __init__(self, wrap=False, rt=False,
              blender=Functor.RESULTONLY, parent=None):
     super().__init__(QRequest("osc"), Offer(quickdict(data=bytearray())),
                      blender, parent=parent)
     self.wrap = assertIsInstance(wrap, bool)
     self.rt = assertIsInstance(rt, bool)
示例#27
0
 def __init__(self, encoding="utf-8", blender=Functor.MERGECOPY, parent=None):
     super().__init__(QRequest("data"), Offer(quickdict(str=str())),
                      blender, parent=parent)
     self.encoding = assertIsInstance(encoding, str)
     self.errors = "replace"
示例#28
0
 def __init__(self, encoding="utf-8", blender=Functor.MERGECOPY, parent=None):
     super().__init__(QRequest("str"), Offer(quickdict(data=bytearray())),
                      blender, parent=parent)
     self.encoding = assertIsInstance(encoding, str)
示例#29
0
 def send(self, player, obj):
     for packet in obj.elements:
         packet.timetag = player._date if player._date is not None \
             else datetime.datetime.now()
         player.postProduct(quickdict(osc=packet, timetag=packet.timetag))
示例#30
0
 def __init__(self, blender=Functor.MERGECOPY, parent=None):
     super().__init__(QRequest("osc"), Offer(quickdict(str=str())),
                      blender, parent=parent)