genocide 191__tar.gz → 201__tar.gz

{genocide-191 → genocide-201}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: genocide
-Version: 191
+Version: 201
 Summary: Since 4 march 2019.
 Author-email: Bart Thate <bthate@dds.nl>
 License: Public Domain

{genocide-191 → genocide-201}/docs/_static/genocide.css

@@ -16,7 +16,7 @@ body {
     background-color: #fff;
     color: #555;
     margin: 30px;
-    padding: 0px 30px 10px 30px;
+    padding: 0px 50px 0px 100px;
 }
 
 

{genocide-191 → genocide-201}/docs/conf.py

@@ -63,6 +63,7 @@ extensions = [
 html_title = "Since 4 March 2019"
 html_style = 'genocide.css'
 html_static_path = ["_static", "_static/genocide.css", "files/sitemap.xml"]
+#html_css_files = ["genocide.css", "alabaster.css"]
 html_css_files = ["genocide.css",]
 html_short_title = "%s %s" % (NAME, VERSION)
 html_theme = "alabaster"
@@ -84,7 +85,7 @@ html_use_index = True
 html_split_index = True
 html_show_sourcelink = False
 html_show_sphinx = False
-html_show_copyright = True
+html_show_copyright = False
 html_copy_source = False
 html_use_opensearch = 'http://%s.rtfd.io/' % NAME
 html_file_suffix = '.html'

{genocide-191 → genocide-201}/docs/manual.rst

@@ -173,9 +173,6 @@
 
     | ``~/.genocide``
     | ``~/.local/bin/genocide``
-    | ``~/.local/bin/genocidec``
-    | ``~/.local/bin/genocided``
-    | ``~/.local/bin/genocides``
     | ``~/.local/pipx/venvs/genocide/*``
 
 **AUTHOR**

genocide-201/genocide/caching.py

@@ -0,0 +1,30 @@
+# This file is placed in the Public Domain.
+
+
+"caching"
+
+
+class Cache:
+
+    objs = {}
+
+    @staticmethod
+    def add(path, obj):
+        Cache.objs[path] = obj
+
+    @staticmethod
+    def get(path):
+        return Cache.objs.get(path, None)
+
+    @staticmethod
+    def typed(matcher):
+        for key in Cache.objs:
+            if matcher not in key:
+                continue
+            yield Cache.objs.get(key)
+
+
+def __dir__():
+    return (
+        'Cache',
+    )

genocide-201/genocide/clients.py

@@ -0,0 +1,110 @@
+# This file is placed in the Public Domain.
+
+
+"clients"
+
+
+import os
+import queue
+import threading
+
+
+from .default import Default
+from .reactor import Fleet, Reactor
+from .threads import launch
+
+
+class Config(Default):
+
+    init = "irc,mdl,rss"
+    name = __file__.rsplit(os.sep, maxsplit=2)[-2]
+    opts = Default()
+
+
+class Client(Reactor):
+
+    def __init__(self):
+        Reactor.__init__(self)
+        Fleet.add(self)
+
+    def raw(self, txt) -> None:
+        raise NotImplementedError("raw")
+
+    def say(self, channel, txt) -> None:
+        self.raw(txt)
+
+
+class Output:
+
+    def __init__(self):
+        self.oqueue   = queue.Queue()
+        self.running = threading.Event()
+
+    def loop(self) -> None:
+        self.running.set()
+        while self.running.is_set():
+            evt = self.oqueue.get()
+            if evt is None:
+                self.oqueue.task_done()
+                break
+            Fleet.display(evt)
+            self.oqueue.task_done()
+
+    def oput(self,evt) -> None:
+        if not self.running.is_set():
+            Fleet.display(evt)
+        self.oqueue.put(evt)
+
+    def start(self) -> None:
+        if not self.running.is_set():
+            self.running.set()
+            launch(self.loop)
+
+    def stop(self) -> None:
+        self.running.clear()
+        self.oqueue.put(None)
+
+    def wait(self) -> None:
+        self.oqueue.join()
+        self.running.wait()
+
+
+class Buffered(Client, Output):
+
+    def __init__(self):
+        Client.__init__(self)
+        Output.__init__(self)
+
+    def raw(self, txt) -> None:
+        raise NotImplementedError("raw")
+
+    def start(self) -> None:
+        Output.start(self)
+        Client.start(self)
+
+    def stop(self) -> None:
+        Output.stop(self)
+        Client.stop(self)
+
+    def wait(self) -> None:
+        Output.wait(self)
+        Client.wait(self)
+
+
+def debug(txt) -> None:
+    if "v" in Config.opts:
+        output(txt)
+
+
+def output(txt) -> None:
+    "output here"
+    # print(txt)
+
+
+def __dir__():
+    return (
+        'Default',
+        'Client',
+        'Fleet',
+        'debug'
+    )

{genocide-191 → genocide-201}/genocide/command.py

@@ -1,28 +1,40 @@
 # This file is placed in the Public Domain.
-# pylint: disable=C0115,C0116,R0912,W0105
 
 
-"user commands"
+"command"
 
 
 import inspect
-import types
+import threading
 
 
-from genocide.objects import Default
-from genocide.runtime import launch
+from .default import Default
+from .package import Table, gettable
 
 
-"commands"
+initlock = threading.RLock()
+loadlock = threading.RLock()
+lock     = threading.RLock()
 
 
 class Commands:
 
     cmds = {}
+    names = gettable()
 
     @staticmethod
-    def add(func):
+    def add(func, mod=None):
         Commands.cmds[func.__name__] = func
+        if mod:
+            Commands.names[func.__name__] = mod.__name__
+
+    @staticmethod
+    def get(cmd):
+        return Commands.cmds.get(cmd, None)
+
+    @staticmethod
+    def getname(cmd):
+        return Commands.names.get(cmd)
 
     @staticmethod
     def scan(mod):
@@ -30,29 +42,23 @@ class Commands:
             if key.startswith("cb"):
                 continue
             if 'event' in cmdz.__code__.co_varnames:
-                Commands.add(cmdz)
+                Commands.add(cmdz, mod)
 
 
-def command(bot, evt):
+def command(evt):
     parse(evt)
-    func = Commands.cmds.get(evt.cmd, None)
-    if func:
-        func(evt)
-    bot.display(evt)
-    evt.ready()
-
-
-"utilities"
-
-
-def modloop(*pkgs, disable=""):
-    for pkg in pkgs:
-        for modname in dir(pkg):
-            if modname in spl(disable):
-                continue
-            if modname.startswith("__"):
-                continue
-            yield getattr(pkg, modname)
+    func = Commands.get(evt.cmd)
+    if not func:
+        mname = Commands.names.get(evt.cmd)
+        if mname:
+            mod = Table.load(mname)
+            Commands.scan(mod)
+            func = Commands.get(evt.cmd)
+    if not func:
+        evt.ready()
+        return
+    func(evt)
+    evt.display()
 
 
 def parse(obj, txt=None):
@@ -68,7 +74,7 @@ def parse(obj, txt=None):
     obj.index   = None
     obj.mod     = ""
     obj.opts    = ""
-    obj.result  = []
+    obj.result  = {}
     obj.sets    = Default()
     obj.txt     = txt or ""
     obj.otxt    = obj.txt
@@ -109,34 +115,10 @@ def parse(obj, txt=None):
     return obj
 
 
-def scan(*pkgs, init=False, disable=""):
-    result = []
-    for mod in modloop(*pkgs, disable=disable):
-        if not isinstance(mod, types.ModuleType):
-            continue
-        Commands.scan(mod)
-        thr = None
-        if init and "init" in dir(mod):
-            thr = launch(mod.init)
-        result.append((mod, thr))
-    return result
-
-
-def spl(txt):
-    try:
-        result = txt.split(',')
-    except (TypeError, ValueError):
-        result = txt
-    return [x for x in result if x]
-
-
-"interface"
-
-
 def __dir__():
     return (
         'Commands',
         'command',
-        'parse',
-        'scan'
+        'cmd',
+        'parse'
     )

genocide-201/genocide/decoder.py

@@ -0,0 +1,46 @@
+# This file is placed in the Public Domain.
+
+
+"decoding"
+
+
+import json
+
+
+from .objects import Object, construct
+
+
+class ObjectDecoder(json.JSONDecoder):
+
+    def __init__(self, *args, **kwargs):
+        json.JSONDecoder.__init__(self, *args, **kwargs)
+
+    def decode(self, s, _w=None):
+        val = json.JSONDecoder.decode(self, s)
+        if isinstance(val, dict):
+            return hook(val)
+        return val
+
+    def raw_decode(self, s, idx=0):
+        return json.JSONDecoder.raw_decode(self, s, idx)
+
+
+def hook(objdict):
+    obj = Object()
+    construct(obj, objdict)
+    return obj
+
+
+def loads(string, *args, **kw):
+    kw["cls"] = ObjectDecoder
+    kw["object_hook"] = hook
+    return json.loads(string, *args, **kw)
+
+
+
+def __dir__():
+    return (
+        'ObjectDecoder',
+        'hook',
+        'loads'
+    )

genocide-201/genocide/default.py

@@ -0,0 +1,28 @@
+# This file is placed in the Public Domain.
+
+
+"default values"
+
+
+class Default:
+
+    def __contains__(self, key):
+        return key in dir(self)
+
+    def __getattr__(self, key):
+        return self.__dict__.get(key, "")
+
+    def __iter__(self):
+        return iter(self.__dict__)
+
+    def __len__(self):
+        return len(self.__dict__)
+
+    def __str__(self):
+        return str(self.__dict__)
+
+
+def __dir__():
+    return (
+        'Default',
+    )

genocide-201/genocide/encoder.py

@@ -0,0 +1,49 @@
+# This file is placed in the Public Domain.
+
+
+"encoder"
+
+
+import json
+
+
+from .objects import Object
+
+
+class ObjectEncoder(json.JSONEncoder):
+
+    def __init__(self, *args, **kwargs):
+        json.JSONEncoder.__init__(self, *args, **kwargs)
+
+    def default(self, o):
+        if isinstance(o, dict):
+            return o.items()
+        if issubclass(type(o), Object):
+            return vars(o)
+        if isinstance(o, list):
+            return iter(o)
+        try:
+            return json.JSONEncoder.default(self, o)
+        except TypeError:
+            try:
+                return vars(o)
+            except TypeError:
+                return repr(o)
+
+    def encode(self, o) -> str:
+        return json.JSONEncoder.encode(self, o)
+
+    def iterencode(self, o, _one_shot=False):
+        return json.JSONEncoder.iterencode(self, o, _one_shot)
+
+
+def dumps(*args, **kw):
+    kw["cls"] = ObjectEncoder
+    return json.dumps(*args, **kw)
+
+
+def __dir__():
+    return (
+        'ObjectEncoder',
+        'dumps'
+    )

genocide-201/genocide/excepts.py

@@ -0,0 +1,59 @@
+# This file is placed in the Public Domain.
+
+
+"exception handling"
+
+
+import traceback
+
+
+DEBUG = True
+
+
+class Errors:
+
+    name = __file__.rsplit(".", maxsplit=2)[-2]
+    errors = []
+
+    @staticmethod
+    def format(exc) -> str:
+        exctype, excvalue, trb = type(exc), exc, exc.__traceback__
+        trace = traceback.extract_tb(trb)
+        result = ""
+        for i in trace:
+            fname = i[0]
+            linenr = i[1]
+            plugfile = fname[:-3].split("/")
+            mod = []
+            for i in plugfile[::-1]:
+                mod.append(i)
+                if Errors.name in i:
+                    break
+            ownname = '.'.join(mod[::-1])
+            if ownname.endswith("__"):
+                continue
+            if ownname.startswith("<"):
+                continue
+            result += f"{ownname}:{linenr} "
+        del trace
+        res = f"{exctype} {result[:-1]} {excvalue}"
+        return res
+
+    @staticmethod
+    def full(exc) -> str:
+        return traceback.format_exception(
+            type(exc),
+            exc,
+            exc.__traceback__
+        )
+
+
+def errors() -> []:
+    return Errors.errors
+
+
+def later(exc) -> None:
+    excp = exc.with_traceback(exc.__traceback__)
+    fmt = Errors.format(excp)
+    if fmt not in Errors.errors:
+        Errors.errors.append(fmt)

genocide-201/genocide/locater.py

@@ -0,0 +1,103 @@
+# This file is placed in the Public Domain.
+
+
+"find objects"
+
+
+import os
+import time
+
+
+from .caching import Cache
+from .objects import Object, fqn, items, update
+from .persist import read
+from .workdir import long, skel, store
+
+
+p = os.path.join
+
+
+def fns(clz):
+    dname = ''
+    pth = store(clz)
+    for rootdir, dirs, _files in os.walk(pth, topdown=False):
+        if dirs:
+            for dname in sorted(dirs):
+                if dname.count('-') == 2:
+                    ddd = p(rootdir, dname)
+                    for fll in os.listdir(ddd):
+                        yield p(ddd, fll)
+
+
+def fntime(daystr):
+    daystr = daystr.replace('_', ':')
+    datestr = ' '.join(daystr.split(os.sep)[-2:])
+    if '.' in datestr:
+        datestr, rest = datestr.rsplit('.', 1)
+    else:
+        rest = ''
+    timed = time.mktime(time.strptime(datestr, '%Y-%m-%d %H:%M:%S'))
+    if rest:
+        timed += float('.' + rest)
+    return timed
+
+
+def find(clz, selector=None, deleted=False, matching=False):
+    skel()
+    pth = long(clz)
+    res = []
+    for fnm in fns(pth):
+        obj = Cache.get(fnm)
+        if not obj:
+            obj = Object()
+            read(obj, fnm)
+            Cache.add(fnm, obj)
+        if not deleted and '__deleted__' in dir(obj) and obj.__deleted__:
+            continue
+        if selector and not search(obj, selector, matching):
+            continue
+        res.append((fnm, obj))
+    return sorted(res, key=lambda x: fntime(x[0]))
+
+
+def last(obj, selector=None):
+    if selector is None:
+        selector = {}
+    result = sorted(
+                    find(fqn(obj), selector),
+                    key=lambda x: fntime(x[0])
+                   )
+    res = None
+    if result:
+        inp = result[-1]
+        update(obj, inp[-1])
+        res = inp[0]
+    return res
+
+
+def search(obj, selector, matching=None):
+    res = False
+    if not selector:
+        return res
+    for key, value in items(selector):
+        val = getattr(obj, key, None)
+        if not val:
+            continue
+        if matching and value == val:
+            res = True
+        elif str(value).lower() in str(val).lower() or value == "match":
+            res = True
+        else:
+            res = False
+            break
+    return res
+
+
+def __dir__():
+    return (
+        'fns',
+        'fntime',
+        'find',
+        'last',
+        'search'
+    )

genocide-201/genocide/lookups.py

@@ -0,0 +1,25 @@
+# This file is placed in the Public Domain.
+
+
+"lookup tables"
+
+
+NAMES = {
+    "cfg": "genocide.modules.irc",
+    "dpl": "genocide.modules.rss",
+    "err": "genocide.modules.err",
+    "exp": "genocide.modules.rss",
+    "flt": "genocide.modules.flt",
+    "imp": "genocide.modules.rss",
+    "mod": "genocide.modules.mod",
+    "mre": "genocide.modules.irc",
+    "nme": "genocide.modules.rss",
+    "pwd": "genocide.modules.irc",
+    "rem": "genocide.modules.rss",
+    "req": "genocide.modules.req",
+    "res": "genocide.modules.rss",
+    "rss": "genocide.modules.rss",
+    "syn": "genocide.modules.rss",
+    "thr": "genocide.modules.thr",
+    "upt": "genocide.modules.upt"
+}

{genocide-191 → genocide-201}/genocide/modules/err.py

@@ -1,18 +1,17 @@
 # This file is placed in the Public Domain.
-# pylint: disable=C0116
+# pylint: disable=C0116,E0402
 
 
 "errors"
 
 
-from genocide.runtime import Errors
+from ..excepts import Errors
 
 
 def err(event):
     nmr = 0
-    for exc in Errors.errors:
-        for line in exc:
-            event.reply(line.strip())
+    for line in Errors.errors:
+        event.reply(line.strip())
         nmr += 1
     if not nmr:
         event.reply("no errors")

genocide-201/genocide/modules/flt.py

@@ -0,0 +1,18 @@
+# This file is placed in the Public Domain.
+# pylint: disable=C0116,E0402
+
+
+"fleet"
+
+
+from ..objects import fmt
+from ..threads import name
+from ..clients import Fleet
+
+
+def flt(event):
+    bots = Fleet.bots.values()
+    try:
+        event.reply(fmt(list(Fleet.bots.values())[int(event.args[0])]))
+    except (KeyError, IndexError, ValueError):
+        event.reply(",".join([name(x).split(".")[-1] for x in bots]))