genocide 230__tar.gz → 232__tar.gz

{genocide-230 → genocide-232}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: genocide
-Version: 230
-Summary: Since 4 march 2019
+Version: 232
+Summary: Since 4 march 2019.
 Author-email: Bart Thate <bthate@dds.nl>
 License-Expression: Unlicense
 Project-URL: home, https://pypi.org/project/genocide

genocide-232/genocide/brokers.py

@@ -0,0 +1,50 @@
+# This file is placed in the Public Domain.
+
+
+"an object for a string"
+
+
+class Broker:
+
+    objects = {}
+
+    @staticmethod
+    def add(obj):
+        "add object to the broker, key is repr(obj)."
+        Broker.objects[repr(obj)] = obj
+
+    @staticmethod
+    def announce(txt):
+        "announce text on all objects with an announce method."
+        for obj in Broker.objs("announce"):
+            obj.announce(txt)
+
+    @staticmethod
+    def get(origin):
+        "object by repr(obj)."
+        return Broker.objects.get(origin)
+
+    @staticmethod
+    def objs(attr):
+        "objects with a certain attribute."
+        for obj in Broker.objects.values():
+            if attr in dir(obj):
+                yield obj
+
+    @staticmethod
+    def has(obj):
+        "whether the Broker has object."
+        return repr(obj) in Broker.objects
+
+    @staticmethod
+    def like(txt):
+        "all keys with a substring in their key."
+        for orig in Broker.objects:
+            if txt in orig.split()[0]:
+                yield orig
+
+
+def __dir__():
+    return (
+        'Broker',
+    )

genocide-232/genocide/command.py

@@ -0,0 +1,61 @@
+# This file is placed in the Public Domain.
+
+
+"write your own commands"
+
+
+import inspect
+
+
+from .brokers import Broker
+from .objects import Methods
+
+
+class Commands:
+
+    cmds = {}
+    names = {}
+
+    @staticmethod
+    def add(*args):
+        "add functions to commands."
+        for func in args:
+            name = func.__name__
+            Commands.cmds[name] = func
+            Commands.names[name] = func.__module__.split(".")[-1]
+
+    @staticmethod
+    def command(evt):
+        "command callback."
+        Methods.parse(evt, evt.text)
+        func = Commands.get(evt.cmd)
+        if func:
+            func(evt)
+            bot = Broker.get(evt.orig)
+            if bot:
+                bot.display(evt)
+        evt.ready()
+
+    @staticmethod
+    def get(cmd):
+        "get function for command."
+        return Commands.cmds.get(cmd, None)
+
+    @staticmethod
+    def has(cmd):
+        "whether cmd is registered."
+        return cmd in Commands.cmds
+
+    @staticmethod
+    def scan(module):
+        "scan a module for functions with event as argument."
+        for key, cmdz in inspect.getmembers(module, inspect.isfunction):
+            if 'event' not in inspect.signature(cmdz).parameters:
+                continue
+            Commands.add(cmdz)
+
+
+def __dir__():
+    return (
+        'Commands',
+    )

genocide-232/genocide/defines.py

@@ -0,0 +1,42 @@
+# This file is placed in the Public Domain.
+
+
+"configurations"
+
+
+from .objects import Data, Dict, Methods
+from .utility import Utils
+
+
+class Configuration(Data):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        if args:
+            Dict.update(self, args[0])
+        if kwargs:
+            Dict.update(self, kwargs)
+
+
+class MainConfig(type):
+
+    def __getattr__(cls, key):
+        if key not in dir(cls):
+            return ""
+        return cls.__getattribute__(key)
+
+    def __str__(cls):
+        return str(Methods.skip(cls.__dict__))
+
+
+class Main(metaclass=MainConfig):
+
+    name = Utils.pkgname(Configuration)
+    wdr = f".{name}"
+
+
+def __dir__():
+    return (
+        'Configuration',
+        'Main'
+    )

genocide-232/genocide/encoder.py

@@ -0,0 +1,57 @@
+# This file is placed in the Public Domain.
+
+
+"encoder/decoder"
+
+
+import json
+import types
+
+
+class Encoder(json.JSONEncoder):
+
+    def default(self, o):
+        if isinstance(o, dict):
+            return o.items()
+        if isinstance(o, list):
+            return iter(o)
+        if isinstance(o, types.MappingProxyType):
+            return dict(o)
+        try:
+            return json.JSONEncoder.default(self, o)
+        except TypeError:
+            try:
+                return vars(o)
+            except TypeError:
+                return repr(o)
+
+
+class Json:
+
+    @staticmethod
+    def dump(*args, **kw):
+        "dump object to disk."
+        kw["cls"] = Encoder
+        return json.dump(*args, **kw)
+
+    @staticmethod
+    def dumps(*args, **kw):
+        "dump object to string."
+        kw["cls"] = Encoder
+        return json.dumps(*args, **kw)
+
+    @staticmethod
+    def load(s, *args, **kw):
+        "load object from disk."
+        return json.load(s, *args, **kw)
+
+    @staticmethod
+    def loads(s, *args, **kw):
+        "load object from string."
+        return json.loads(s, *args, **kw)
+
+
+def __dir__():
+    return (
+        'Json',
+    )

genocide-232/genocide/handler.py

@@ -0,0 +1,201 @@
+# This file is placed in the Public Domain.
+
+
+"callback engine"
+
+
+import logging
+import queue
+import threading
+import time
+import _thread
+
+
+from .brokers import Broker
+from .threads import Thread
+
+
+class Event:
+
+    def __init__(self):
+        self._ready = threading.Event()
+        self._thr = None
+        self.result = {}
+        self.args = []
+        self.index = 0
+        self.kind = "event"
+
+    def __getattr__(self, key):
+        return self.__dict__.get(key, "")
+
+    def __str__(self):
+        return str(self.__dict__)
+
+    def ready(self):
+        "flag message as ready."
+        self._ready.set()
+
+    def reply(self, text):
+        "add text to result."
+        self.result[time.time()] = text
+
+    def wait(self, timeout=0.0):
+        "wait for completion."
+        self._ready.wait(timeout or None)
+        if self._thr:
+            self._thr.join(timeout or None)
+
+
+class Handler:
+
+    def __init__(self):
+        self.cbs = {}
+        self.queue = queue.Queue()
+        self.running = threading.Event()
+
+    def callback(self, event):
+        "run callback function with event."
+        func = self.cbs.get(event.kind, None)
+        if not func:
+            event.ready()
+            return
+        name = event.text and event.text.split()[0]
+        event._thr = Thread.launch(func, event, name=name)
+
+    def loop(self):
+        "event loop."
+        while self.running.is_set():
+            event = self.queue.get()
+            if not event:
+                break
+            event.orig = repr(self)
+            self.callback(event)
+
+    def put(self, event):
+        "put event on queue."
+        self.queue.put(event)
+
+    def register(self, kind, callback):
+        "register callback."
+        self.cbs[kind] = callback
+
+    def start(self):
+        "start event handler loop."
+        self.running.set()
+        Thread.launch(self.loop)
+
+    def stop(self):
+        "stop event handler loop."
+        self.running.clear()
+        self.queue.put(None)
+
+
+class Client(Handler):
+
+    def __init__(self):
+        Handler.__init__(self)
+        self.iqueue = queue.Queue()
+        self.olock = threading.RLock()
+        self.silent = False
+        self.stopped = threading.Event()
+        Broker.add(self)
+
+    def announce(self, text):
+        "announce text to all channels."
+        if not self.silent:
+            self.raw(text)
+
+    def display(self, event):
+        "display event results."
+        with self.olock:
+            for tme in event.result:
+                self.dosay(event.channel, event.result.get(tme))
+
+    def dosay(self, channel, text):
+        "say called by display."
+        self.say(channel, text)
+
+    def loop(self):
+        "input loop."
+        while True:
+            event = self.poll()
+            if not event or self.stopped.is_set():
+                break
+            event.orig = repr(self)
+            self.callback(event)
+
+    def poll(self):
+        "return event."
+        return self.iqueue.get()
+
+    def put(self, event):
+        self.iqueue.put(event)
+
+    def raw(self, text):
+        "raw output."
+
+    def say(self, channel, text):
+        "say text in channel."
+        self.raw(text)
+
+
+class Console(Client):
+
+    def loop(self):
+        "input loop."
+        while True:
+            event = self.poll()
+            if not event or self.stopped.is_set():
+                break
+            event.orig = repr(self)
+            self.callback(event)
+            event.wait()
+
+    def poll(self):
+        "return event."
+        return self.iqueue.get()
+
+
+class Output(Client):
+
+    def __init__(self):
+        super().__init__()
+        self.oqueue = queue.Queue()
+
+    def output(self):
+        "output loop."
+        while True:
+            event = self.oqueue.get()
+            if event is None:
+                self.oqueue.task_done()
+                break
+            self.display(event)
+            self.oqueue.task_done()
+
+    def start(self):
+        "start output loop."
+        super().start()
+        Thread.launch(self.output)
+
+    def stop(self):
+        "stop output loop."
+        super().stop()
+        self.oqueue.put(None)
+
+    def wait(self):
+        "wait for output to finish."
+        try:
+            self.oqueue.join()
+        except Exception as ex:
+            logging.exception(ex)
+            _thread.interrupt_main()
+
+
+def __dir__():
+    return (
+        'Client',
+        'Console',
+        'Event',
+        'Handler',
+        'Output'
+    )

{genocide-230 → genocide-232}/genocide/loggers.py

@@ -1,7 +1,7 @@
 # This file is placed in the Public Domain.
 
 
-"log exceptions."
+"logging"
 
 
 import logging
@@ -19,21 +19,20 @@ class Log:
     datefmt = "%H:%M:%S"
     format = "%(module).3s %(message)s"
 
-
-def level(loglevel):
-    "set log level."
-    formatter = Format(Log.format, Log.datefmt)
-    stream = logging.StreamHandler()
-    stream.setFormatter(formatter)
-    logging.basicConfig(
-        level=loglevel.upper(),
-        handlers=[stream,],
-        force=True
-    )
+    @staticmethod
+    def level(loglevel):
+        "set log level."
+        formatter = Format(Log.format, Log.datefmt)
+        stream = logging.StreamHandler()
+        stream.setFormatter(formatter)
+        logging.basicConfig(
+            level=loglevel.upper(),
+            handlers=[stream,],
+            force=True
+        )
 
 
 def __dir__():
     return (
         'Log',
-        'level'
     )

genocide-232/genocide/modules/__init__.py

@@ -0,0 +1,4 @@
+# This file is placed in the Public Domain.
+
+
+"modules"

{genocide-230 → genocide-232}/genocide/modules/atr.py

@@ -1,22 +1,22 @@
 # This file is placed in the Public Domain.
 
 
-"fields"
+"show attributes"
 
 
-from genocide.defines import attrs, kinds
+from genocide.persist import Locate, Workdir
 
 
 def atr(event):
     if not event.rest:
-        res = sorted({x.split('.')[-1].lower() for x in kinds()})
+        res = sorted({x.split('.')[-1].lower() for x in Workdir.kinds()})
         if res:
             event.reply(",".join(res))
         else:
             event.reply("no types")
         return
-    itms = attrs(event.args[0])
+    itms = Locate.attrs(event.args[0])
     if not itms:
-        event.reply("no fields")
+        event.reply("no attributes")
     else:
         event.reply(",".join(itms))

genocide-232/genocide/modules/flt.py

@@ -0,0 +1,23 @@
+# This file is placed in the Public Domain.
+
+
+"show bot in fleet"
+
+
+from genocide.brokers import Broker
+from genocide.objects import Methods
+
+
+def flt(event):
+    clts = list(Broker.objs("announce"))
+    if not clts:
+        event.reply("no bots")
+        return
+    if event.args:
+        index = int(event.args[0])
+        if index < len(clts):
+            event.reply(str(clts[index]))
+        else:
+            event.reply("no matching client in fleet.")
+        return
+    event.reply(' | '.join([Methods.fqn(o).split(".")[-1] for o in clts]))

genocide-232/genocide/modules/fnd.py

@@ -0,0 +1,29 @@
+# This file is placed in the Public Domain.
+
+
+"locate objects"
+
+
+import time
+
+
+from genocide.objects import Methods
+from genocide.persist import Locate, Workdir
+from genocide.utility import Time
+
+
+def fnd(event):
+    if not event.rest:
+        res = sorted([x.split('.')[-1].lower() for x in Workdir.kinds()])
+        if res:
+            event.reply(",".join(res))
+        else:
+            event.reply("no data yet.")
+        return
+    otype = event.args[0]
+    nmr = 0
+    for fnm, obj in sorted(Locate.find(otype, event.gets), key=lambda x: Time.fntime(x[0])):
+        event.reply(f"{nmr} {Methods.fmt(obj)} {Time.elapsed(time.time()-Time.fntime(fnm))}")
+        nmr += 1
+    if not nmr:
+        event.reply("no result")