genocide 201__tar.gz → 203__tar.gz

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

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

genocide-203/genocide/__init__.py

@@ -0,0 +1,4 @@
+# This file is placed in the Public Domain.
+
+
+__doc__ = __package__.upper()

genocide-201/genocide/runtime.py → genocide-203/genocide/__main__.py

@@ -1,40 +1,37 @@
 # This file is placed in the Public Domain.
-# pylint: disable=C,R0903,W0105,W0212,W0611,W0613,W0718,E0402
 
 
-"main"
+"main program"
 
 
+import hashlib
 import os
 import pathlib
+import signal
 import sys
 import time
-import traceback
+import types
 import _thread
 
 
-from .clients import Client, Config, debug
-from .command import Commands, command, parse
-from .encoder import dumps
-from .excepts import errors, later
-from .package import Table
-from .reactor import Event, Fleet
-from .threads import launch
-from .utility import spl
-from .workdir import Workdir, pidname
+sys.path.insert(0, os.getcwd())
 
 
-from . import clients
-from . import modules as MODS
+from .client  import Client
+from .error   import Errors
+from .event   import Event
+from .modules import Commands, Main, command, load, mods, modules, parse, scan
+from .object  import dumps
+from .thread  import launch
+from .utils   import nodebug, spl
+from .workdir import Workdir, pidname
 
 
-cfg   = Config()
-p     = os.path.join
-pname = f"{Config.name}.modules"
+p = os.path.join
 
 
-Workdir.wdr    = os.path.expanduser(f"~/.{Config.name}")
-clients.output = output = print
+def output(txt):
+    print(txt)
 
 
 class CLI(Client):
@@ -43,9 +40,6 @@ class CLI(Client):
         Client.__init__(self)
         self.register("command", command)
 
-    def announce(self, txt):
-        pass
-
     def raw(self, txt):
         output(txt.encode('utf-8', 'replace').decode("utf-8"))
 
@@ -53,7 +47,7 @@ class CLI(Client):
 class Console(CLI):
 
     def announce(self, txt):
-        pass
+        output(txt)
 
     def callback(self, evt):
         CLI.callback(self, evt)
@@ -66,9 +60,29 @@ class Console(CLI):
         return evt
 
 
+"output"
+
+
+def nil(txt):
+    pass
+
+
+def enable():
+    global output
+    output = print
+
+
+def disable():
+    global output
+    output = nil
+
+
+"utilities"
+
+
 def banner():
     tme = time.ctime(time.time()).replace("  ", " ")
-    output(f"{Config.name.upper()} since {tme}")
+    output(f"{Main.name.upper()} since {tme}")
 
 
 def check(txt):
@@ -110,6 +124,31 @@ def forever():
             _thread.interrupt_main()
 
 
+def inits(names) -> [types.ModuleType]:
+    mods = []
+    for name in spl(names):
+        mod = load(name)
+        if not mod:
+            continue
+        if "init" in dir(mod):
+            thr = launch(mod.init)
+        mods.append((mod, thr))
+    return mods
+
+
+def md5sum(mod):
+    with open(mod.__file__, "r", encoding="utf-8") as file:
+        txt = file.read().encode("utf-8")
+        return str(hashlib.md5(txt).hexdigest())
+
+
+def modnames(path) -> [str]:
+    return [
+            x[:-3] for x in os.listdir(path)
+            if x.endswith(".py") and not x.startswith("__")
+           ]
+
+
 def pidfile(filename):
     if os.path.exists(filename):
         os.unlink(filename)
@@ -127,30 +166,46 @@ def privileges():
     os.setuid(pwnam2.pw_uid)
 
 
+def setwd(name, path=""):
+    Main.name = name
+    path = path or os.path.expanduser(f"~/.{name}")
+    Workdir.wdr = path
+
+
+"handlers"
+
+
+def handler(signum, frame):
+    _thread.interrupt_main()
+
+
 "scripts"
 
 
 def background():
-    daemon(True)
+    daemon("-v" in sys.argv)
+    setwd(Main.name)
     privileges()
-    pidfile(pidname(Config.name))
+    disable()
+    pidfile(pidname(Main.name))
     Commands.add(cmd)
-    Table.inits(Config.init, pname)
+    inits(Main.init or "irc,rss")
     forever()
 
 
 def console():
     import readline # noqa: F401
+    setwd(Main.name)
+    enable()
     Commands.add(cmd)
-    parse(cfg, " ".join(sys.argv[1:]))
-    Config.init = cfg.sets.init or Config.init
-    Config.opts = cfg.opts
-    if "v" in cfg.opts:
+    parse(Main, " ".join(sys.argv[1:]))
+    Main.init = Main.sets.init or Main.init
+    Main.verbose = Main.sets.verbose or Main.verbose
+    if "v" in Main.opts:
         banner()
-    if "i" in cfg.opts or Config.init:
-        for _mod, thr in Table.inits(Config.init, pname):
-            if "w" in cfg.opts:
-                thr.join()
+    for _mod, thr in inits(Main.init):
+        if "w" in Main.opts:
+            thr.join()
     csl = Console()
     csl.start()
     forever()
@@ -159,23 +214,31 @@ def console():
 def control():
     if len(sys.argv) == 1:
         return
+    setwd(Main.name)
+    Workdir.wdr = os.path.expanduser(f"~/.{Main.name}")
+    enable()
     Commands.add(cmd)
+    Commands.add(md5)
     Commands.add(srv)
     Commands.add(tbl)
-    parse(cfg, " ".join(sys.argv[1:]))
+    parse(Main, " ".join(sys.argv[1:]))
     csl = CLI()
     evt = Event()
     evt.orig = repr(csl)
     evt.type = "command"
-    evt.txt = cfg.otxt
+    evt.txt = Main.otxt
     command(evt)
     evt.wait()
 
+
 def service():
+    signal.signal(signal.SIGHUP, handler)
+    nodebug()
+    setwd(Main.name)
     privileges()
-    pidfile(pidname(Config.name))
+    pidfile(pidname(Main.name))
     Commands.add(cmd)
-    Table.inits(Config.init, pname)
+    inits(Main.init or "irc,rss")
     forever()
 
 
@@ -183,18 +246,24 @@ def service():
 
 
 def cmd(event):
-    event.reply(",".join(sorted(Commands.names)))
+    event.reply(",".join(sorted([x for x in Commands.names if x not in Main.ignore])))
+
+
+def md5(event):
+    table = mods("tbl")[0]
+    event.reply(md5sum(table))
 
 
 def srv(event):
     import getpass
     name = getpass.getuser()
-    event.reply(TXT % (Config.name.upper(), name, name, name, Config.name))
+    event.reply(TXT % (Main.name.upper(), name, name, name, Main.name))
 
 
 def tbl(event):
-    for mod in Table.all(MODS):
-        Commands.scan(mod)
+    import genocide.modules
+    for mod in mods():
+        scan(mod)
     event.reply("# This file is placed in the Public Domain.")
     event.reply("")
     event.reply("")
@@ -202,7 +271,13 @@ def tbl(event):
     event.reply("")
     event.reply("")
     event.reply(f"NAMES = {dumps(Commands.names, indent=4, sort_keys=True)}")
-    
+    event.reply("")
+    event.reply("")
+    event.reply("MD5 = {")
+    for mod in mods():
+        event.reply(f'    "{mod.__name__.split(".")[-1]}": "{md5sum(mod)}",')
+    event.reply("}")
+
 
 "data"
 
@@ -224,6 +299,15 @@ WantedBy=multi-user.target"""
 "runtime"
 
 
+def wrapped(func):
+    try:
+        func()
+    except (KeyboardInterrupt, EOFError):
+        output("")
+    for exc in Errors.errors:
+        print(Errors.format(exc))
+
+
 def wrap(func):
     import termios
     old = None
@@ -232,37 +316,30 @@ def wrap(func):
     except termios.error:
         pass
     try:
-        func()
-    except (KeyboardInterrupt, EOFError):
-        output("")
-    except Exception as exc:
-        later(exc)
+        wrapped(func)
     finally:
         if old:
             termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, old)
-    for line in errors():
-        output(line)
-
-
-def wrapped():
-    wrap(main)
-
-
-def wraps():
-    wrap(service)
 
 
 def main():
+    if check("a"):
+        Main.ignore = ""
+        Main.init   = ",".join(modules())
+        for mod in mods():
+            mod.DEBUG = False
+    if check("v"):
+        setattr(Main.opts, "v", True)
+        enable()
     if check("c"):
         wrap(console)
     elif check("d"):
         background()
     elif check("s"):
-        wrap(service)
+        wrapped(service)
     else:
-        control()
+        wrapped(control)
 
 
 if __name__ == "__main__":
     main()
-    sys.exit(0)

genocide-201/genocide/caching.py → genocide-203/genocide/cache.py

@@ -4,20 +4,23 @@
 "caching"
 
 
+import typing
+
+
 class Cache:
 
     objs = {}
 
     @staticmethod
-    def add(path, obj):
+    def add(path, obj) -> None:
         Cache.objs[path] = obj
 
     @staticmethod
-    def get(path):
+    def get(path) -> typing.Any:
         return Cache.objs.get(path, None)
 
     @staticmethod
-    def typed(matcher):
+    def typed(matcher) -> [typing.Any]:
         for key in Cache.objs:
             if matcher not in key:
                 continue

genocide-203/genocide/client.py

@@ -0,0 +1,30 @@
+# This file is placed in the Public Domain.
+
+
+"client"
+
+
+from .fleet   import Fleet
+from .reactor import Reactor
+ 
+
+class Client(Reactor):
+
+    def __init__(self):
+        Reactor.__init__(self)
+        Fleet.add(self)
+
+    def announce(self, txt) -> None:
+        pass
+
+    def raw(self, txt) -> None:
+        raise NotImplementedError("raw")
+
+    def say(self, channel, txt) -> None:
+        self.raw(txt)
+
+
+def __dir__():
+    return (
+        'Client',
+    )

genocide-201/genocide/persist.py → genocide-203/genocide/disk.py

@@ -1,23 +1,17 @@
 # This file is placed in the Public Domain.
 
 
-"persistence"
+"read/write"
 
 
-import datetime
-import os
 import json
 import pathlib
 import threading
 
 
-from .decoder import loads
-from .encoder import dumps
-from .objects import fqn, update
-from .workdir import store
+from .object import loads, dumps, update
 
 
-p    = os.path.join
 lock = threading.RLock()
 
 
@@ -26,15 +20,11 @@ class DecodeError(Exception):
     pass
 
 
-def cdir(pth):
+def cdir(pth) -> None:
     path = pathlib.Path(pth)
     path.parent.mkdir(parents=True, exist_ok=True)
 
 
-def ident(obj):
-    return p(fqn(obj),*str(datetime.datetime.now()).split())
-
-
 def read(obj, pth):
     with lock:
         with open(pth, 'r', encoding='utf-8') as ofile:
@@ -46,10 +36,8 @@ def read(obj, pth):
     return pth
 
 
-def write(obj, pth=None):
+def write(obj, pth):
     with lock:
-        if pth is None:
-            pth = store(ident(obj))
         cdir(pth)
         txt = dumps(obj, indent=4)
         with open(pth, 'w', encoding='utf-8') as ofile:
@@ -59,8 +47,8 @@ def write(obj, pth=None):
 
 def __dir__():
     return (
+        'DecodeError',
         'cdir',
-        'ident',
         'read',
         'write'
     )

genocide-201/genocide/excepts.py → genocide-203/genocide/error.py

@@ -1,18 +1,15 @@
 # This file is placed in the Public Domain.
 
 
-"exception handling"
+"deferred exception handling"
 
 
 import traceback
 
 
-DEBUG = True
-
-
 class Errors:
 
-    name = __file__.rsplit(".", maxsplit=2)[-2]
+    name = __file__.rsplit("/", maxsplit=2)[-2]
     errors = []
 
     @staticmethod
@@ -22,12 +19,14 @@ class Errors:
         result = ""
         for i in trace:
             fname = i[0]
+            if fname.endswith(".py"):
+                fname = fname[:-3]
             linenr = i[1]
-            plugfile = fname[:-3].split("/")
+            plugfile = fname.split("/")
             mod = []
             for i in plugfile[::-1]:
                 mod.append(i)
-                if Errors.name in i:
+                if Errors.name in i or "bin" in i:
                     break
             ownname = '.'.join(mod[::-1])
             if ownname.endswith("__"):
@@ -37,6 +36,9 @@ class Errors:
             result += f"{ownname}:{linenr} "
         del trace
         res = f"{exctype} {result[:-1]} {excvalue}"
+        if "__notes__" in dir(exc):
+            for note in exc.__notes__:
+                res += f" {note}"
         return res
 
     @staticmethod
@@ -48,12 +50,12 @@ class Errors:
         )
 
 
-def errors() -> []:
-    return Errors.errors
+def later(exc, txt="") -> None:
+    Errors.errors.append(exc)
 
 
-def later(exc) -> None:
-    excp = exc.with_traceback(exc.__traceback__)
-    fmt = Errors.format(excp)
-    if fmt not in Errors.errors:
-        Errors.errors.append(fmt)
+def __dir__():
+    return (
+        'Errors',
+        'later'
+    )

genocide-203/genocide/event.py

@@ -0,0 +1,47 @@
+# This file is placed in the Public Domain.
+
+
+"event"
+
+
+import threading
+import time
+
+
+from .fleet  import Fleet
+from .object import Default
+
+
+class Event(Default):
+
+    def __init__(self):
+        Default.__init__(self)
+        self._ready = threading.Event()
+        self._thr   = None
+        self.ctime  = time.time()
+        self.result = {}
+        self.type   = "event"
+        self.txt    = ""
+
+    def display(self):
+        Fleet.display(self)
+
+    def done(self) -> None:
+        self.reply("ok")
+
+    def ready(self) -> None:
+        self._ready.set()
+
+    def reply(self, txt) -> None:
+        self.result[time.time()] = txt
+
+    def wait(self) -> None:
+        self._ready.wait()
+        if self._thr:
+            self._thr.join()
+
+
+def __dir__():
+    return (
+        'Event',
+    )

genocide-201/genocide/locater.py → genocide-203/genocide/find.py

@@ -1,24 +1,24 @@
 # This file is placed in the Public Domain.
 
 
-"find objects"
+"locate objects"
 
 
+import datetime
 import os
 import time
 
 
-from .caching import Cache
-from .objects import Object, fqn, items, update
-from .persist import read
+from .cache   import Cache
+from .disk    import read
+from .object  import Object, fqn, items, update
 from .workdir import long, skel, store
 
 
 p = os.path.join
 
 
-def fns(clz):
-    dname = ''
+def fns(clz) -> [str]:
     pth = store(clz)
     for rootdir, dirs, _files in os.walk(pth, topdown=False):
         if dirs:
@@ -29,9 +29,9 @@ def fns(clz):
                         yield p(ddd, fll)
 
 
-def fntime(daystr):
-    daystr = daystr.replace('_', ':')
+def fntime(daystr) -> int:
     datestr = ' '.join(daystr.split(os.sep)[-2:])
+    datestr = datestr.replace("_", " ")
     if '.' in datestr:
         datestr, rest = datestr.rsplit('.', 1)
     else:
@@ -42,25 +42,32 @@ def fntime(daystr):
     return timed
 
 
-def find(clz, selector=None, deleted=False, matching=False):
+def find(clz, selector=None, deleted=False, matching=False) -> [Object]:
     skel()
-    pth = long(clz)
     res = []
-    for fnm in fns(pth):
-        obj = Cache.get(fnm)
+    clz = long(clz)
+    for pth in fns(clz):
+        obj = Cache.get(pth)
         if not obj:
             obj = Object()
-            read(obj, fnm)
-            Cache.add(fnm, obj)
+            read(obj, pth)
+            Cache.add(pth, 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))
+        res.append((pth, obj))
     return sorted(res, key=lambda x: fntime(x[0]))
 
 
-def last(obj, selector=None):
+"methods"
+
+
+def ident(obj) -> str:
+    return p(fqn(obj),*str(datetime.datetime.now()).split())
+
+
+def last(obj, selector=None) -> Object:
     if selector is None:
         selector = {}
     result = sorted(
@@ -75,7 +82,7 @@ def last(obj, selector=None):
     return res
 
 
-def search(obj, selector, matching=None):
+def search(obj, selector, matching=None) -> bool:
     res = False
     if not selector:
         return res
@@ -99,5 +106,6 @@ def __dir__():
         'fntime',
         'find',
         'last',
+        'ident',
         'search'
     )