genocide 232__tar.gz → 233__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: genocide
-Version: 232
-Summary: Since 4 march 2019.
+Version: 233
+Summary: Since 4 March 2019.
 Author-email: Bart Thate <bthate@dds.nl>
 License-Expression: Unlicense
 Project-URL: home, https://pypi.org/project/genocide
@@ -66,3 +66,6 @@ are poison at the time they voted for this law and the day the Wfz law took
 effect (1-1-2019), i ask the prosecutor to prosecute the king for making the
 commiting of the above mentioned crimes (killing, torture and impotent making)
 possible.
+
+
+(*) The website of the **ECHA** <European Chemical Agency> has been updated in January 2026 and no longer shows a skull and bones when visited.

{genocide-232 → genocide-233}/README.rst

@@ -51,3 +51,6 @@ are poison at the time they voted for this law and the day the Wfz law took
 effect (1-1-2019), i ask the prosecutor to prosecute the king for making the
 commiting of the above mentioned crimes (killing, torture and impotent making)
 possible.
+
+
+(*) The website of the **ECHA** <European Chemical Agency> has been updated in January 2026 and no longer shows a skull and bones when visited.

genocide-233/genocide/booting.py

@@ -0,0 +1,137 @@
+# This file is placed in the Public Domain.
+
+
+"at the beginning"
+
+
+import argparse
+
+
+from .runtime import Runtime
+from .command import Commands
+from .configs import Main
+from .handler import Console, Event
+from .objects import Object
+
+
+class Arguments:
+
+    args = None
+    txt = None
+
+    @classmethod
+    def getargs(cls):
+        "parse commandline arguments."
+        parser = argparse.ArgumentParser(prog=Main.name, description=f"{Main.name.upper()}")
+        parser.add_argument("-a", "--all", action="store_true", help="load all modules.")
+        parser.add_argument("-c", "--console", action="store_true", help="start console.")
+        parser.add_argument("-d", "--daemon", action="store_true", help="start background daemon.")
+        parser.add_argument("-i", "--ignore", default="", help='modules to ignore.')
+        parser.add_argument("-l", "--level", default=Main.level, help='set loglevel.')
+        parser.add_argument("-m", "--mods", default="", help='modules to load.')
+        parser.add_argument("-n", "--index", action="store", type=int, help="set index to use.")
+        parser.add_argument("-r", "--read", action="store_true", help="read config on start.")
+        parser.add_argument("-s", "--service", action="store_true", help="start service.")
+        parser.add_argument("-v", "--verbose", action='store_true', help='enable verbose.')
+        parser.add_argument("-w", "--wait", action='store_true', help='wait for services to start.')
+        parser.add_argument("-u", "--user", action="store_true", help="use local mods directory.")
+        parser.add_argument("-x", "--admin", action="store_true", help="enable admin mode.")
+        parser.add_argument("--wdr", help='set working directory.')
+        parser.add_argument("--nochdir", action="store_true", help='set working directory.')
+        parser.add_argument("--noignore", action="store_true", help="disable ignore")
+        cls.args, arguments = parser.parse_known_args()
+        cls.txt = " ".join(arguments)
+        Object.merge(Main, cls.args)
+
+
+class Line(Console):
+
+    def raw(self, text):
+        "write to console."
+        print(text.encode('utf-8', 'replace').decode("utf-8"))
+
+
+class CSL(Line):
+
+    def poll(self):
+        "poll for an event."
+        evt = Event()
+        evt.orig = repr(self)
+        evt.text = input("> ")
+        evt.kind = "command"
+        return evt
+
+
+class Scripts:
+
+    @staticmethod
+    def background():
+        "background script."
+        Runtime.daemon(Main.verbose, Main.nochdir)
+        Runtime.privileges()
+        Runtime.configure(Main)
+        Runtime.pidfile(Main.name)
+        Runtime.scan(Main)
+        Runtime.init(Main)
+        Runtime.forever()
+
+    @staticmethod
+    def cmd(text):
+        cli = Line()
+        for txt in text.split(" ! "):
+            evt = Event()
+            evt.kind = "command"
+            evt.orig = repr(cli)
+            evt.text = txt
+            Commands.command(evt)
+            evt.wait()
+
+    @staticmethod
+    def console():
+        "console script."
+        import readline
+        readline.redisplay()
+        Runtime.configure(Main)
+        if Main.verbose:
+            Runtime.banner()
+        Runtime.scan(Main)
+        Runtime.init(Main)
+        csl = CSL()
+        csl.start()
+        Runtime.forever()
+
+    @staticmethod
+    def control():
+        "cli script."
+        if not Arguments.txt:
+            return
+        Main.all = True
+        Runtime.configure(Main)
+        Runtime.scan(Main)
+        Scripts.cmd(Arguments.txt)
+
+    @staticmethod
+    def service():
+        "service script."
+        Runtime.privileges()
+        Runtime.configure(Main)
+        Runtime.scan(Main)
+        Runtime.banner()
+        Runtime.pidfile(Main.name)
+        Runtime.init(Main)
+        Runtime.forever()
+
+
+def main():
+    "main"
+    Arguments.getargs()
+    Main.all = True
+    Main.ignore = "mbx,rst,udp,web,wsd"
+    if Main.daemon:
+        Runtime.wrap(Scripts.background)
+    elif Main.console:
+        Runtime.wrap(Scripts.console)
+    elif Main.service:
+        Runtime.wrap(Scripts.service)
+    else:
+        Runtime.wrap(Scripts.control)

genocide-233/genocide/brokers.py

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

genocide-233/genocide/command.py

@@ -0,0 +1,77 @@
+# This file is placed in the Public Domain.
+
+
+"write your own commands"
+
+
+import inspect
+
+
+from .objects import Methods
+from .package import Mods
+
+
+class Commands:
+
+    cmds = {}
+    names = {}
+
+    @classmethod
+    def add(cls, *args):
+        "add functions to commands."
+        for func in args:
+            name = func.__name__
+            cls.cmds[name] = func
+            modname = func.__module__.split(".")[-1]
+            if "__" in modname:
+                continue
+            cls.names[name] = modname
+
+    @classmethod
+    def command(cls, evt):
+        "command callback."
+        Methods.parse(evt, evt.text)
+        func = cls.get(evt.cmd)
+        if not func:
+            name = cls.names.get(evt.cmd)
+            mod = None
+            if name:
+                mod = Mods.get(name)
+            if mod:
+                cls.scan(mod)
+                func = cls.get(evt.cmd)
+        if func:
+            func(evt)
+            evt.display()
+        evt.ready()
+
+    @classmethod
+    def commands(cls, orig):
+        "list cpmmands available."
+        return cls.names.keys()
+
+    @classmethod
+    def get(cls, cmd):
+        "get function for command."
+        return cls.cmds.get(cmd, None)
+
+    @classmethod
+    def scan(cls, module):
+        "scan a module for functions with event as argument."
+        for key, cmdz in inspect.getmembers(module, inspect.isfunction):
+            if 'event' in inspect.signature(cmdz).parameters:
+                cls.add(cmdz)
+
+    @classmethod
+    def table(cls):
+        "load names from table."
+        mod = Mods.get("tbl")
+        names = getattr(mod, "NAMES", None)
+        if names:
+            cls.names.update(names)
+
+
+def __dir__():
+    return (
+        'Commands',
+    )

genocide-232/genocide/defines.py → genocide-233/genocide/configs.py

@@ -4,18 +4,13 @@
 "configurations"
 
 
-from .objects import Data, Dict, Methods
+from .objects import Base, Object
 from .utility import Utils
 
 
-class Configuration(Data):
+class Configuration(Base):
 
-    def __init__(self, *args, **kwargs):
-        super().__init__()
-        if args:
-            Dict.update(self, args[0])
-        if kwargs:
-            Dict.update(self, kwargs)
+    pass
 
 
 class MainConfig(type):
@@ -26,13 +21,14 @@ class MainConfig(type):
         return cls.__getattribute__(key)
 
     def __str__(cls):
-        return str(Methods.skip(cls.__dict__))
+        return str(Object.skip(cls.__dict__))
 
 
 class Main(metaclass=MainConfig):
 
-    name = Utils.pkgname(Configuration)
-    wdr = f".{name}"
+    level = "info"
+    name = Utils.pkgname(MainConfig)
+    wdr = ""
 
 
 def __dir__():

{genocide-232 → genocide-233}/genocide/encoder.py

@@ -5,25 +5,35 @@
 
 
 import json
+import threading
 import types
 
 
+from .objects import Object
+
+
 class Encoder(json.JSONEncoder):
 
+    lock = threading.RLock()
+
     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:
+        "generate serializable versions."
+        with Encoder.lock:
+            if isinstance(o, type):
+                return Object.skip(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 vars(o)
+                return json.JSONEncoder.default(self, o)
             except TypeError:
-                return repr(o)
+                try:
+                    return vars(o)
+                except TypeError:
+                    return repr(o)
 
 
 class Json:

{genocide-232 → genocide-233}/genocide/handler.py

@@ -4,32 +4,44 @@
 "callback engine"
 
 
+import collections
 import logging
 import queue
 import threading
-import time
 import _thread
 
 
 from .brokers import Broker
+from .command import Commands
+from .objects import Base
 from .threads import Thread
 
 
-class Event:
+class Event(Base):
 
     def __init__(self):
+        Base.__init__(self)
         self._ready = threading.Event()
         self._thr = None
-        self.result = {}
         self.args = []
+        self.channel = ""
         self.index = 0
         self.kind = "event"
-
-    def __getattr__(self, key):
-        return self.__dict__.get(key, "")
-
-    def __str__(self):
-        return str(self.__dict__)
+        self.orig = ""
+        self.result = collections.deque()
+        self.text = ""
+
+    def display(self):
+        "print results."
+        bot = Broker.get(self.orig)
+        if bot:
+            bot.display(self)
+
+    def ok(self, txt=""):
+        "print ok response."
+        if not txt:
+            txt = self.text
+        self.reply(f"ok {txt}".strip())
 
     def ready(self):
         "flag message as ready."
@@ -37,13 +49,13 @@ class Event:
 
     def reply(self, text):
         "add text to result."
-        self.result[time.time()] = text
+        self.result.append(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)
+        self._ready.wait(timeout or None)
 
 
 class Handler:
@@ -66,7 +78,7 @@ class Handler:
         "event loop."
         while self.running.is_set():
             event = self.queue.get()
-            if not event:
+            if event is None:
                 break
             event.orig = repr(self)
             self.callback(event)
@@ -79,16 +91,19 @@ class Handler:
         "register callback."
         self.cbs[kind] = callback
 
-    def start(self):
+    def start(self, daemon=True):
         "start event handler loop."
         self.running.set()
-        Thread.launch(self.loop)
+        Thread.launch(self.loop, daemon=daemon)
 
     def stop(self):
         "stop event handler loop."
         self.running.clear()
         self.queue.put(None)
 
+    def wait(self):
+        pass
+
 
 class Client(Handler):
 
@@ -108,8 +123,8 @@ class Client(Handler):
     def display(self, event):
         "display event results."
         with self.olock:
-            for tme in event.result:
-                self.dosay(event.channel, event.result.get(tme))
+            for txt in event.result:
+                self.dosay(event.channel, txt)
 
     def dosay(self, channel, text):
         "say called by display."
@@ -117,18 +132,15 @@ class Client(Handler):
 
     def loop(self):
         "input loop."
-        while True:
-            event = self.poll()
-            if not event or self.stopped.is_set():
+        while self.running.is_set():
+            event = self.iqueue.get()
+            if not event:
                 break
             event.orig = repr(self)
             self.callback(event)
 
-    def poll(self):
-        "return event."
-        return self.iqueue.get()
-
     def put(self, event):
+        "put event into queue."
         self.iqueue.put(event)
 
     def raw(self, text):
@@ -138,25 +150,52 @@ class Client(Handler):
         "say text in channel."
         self.raw(text)
 
+    def stop(self):
+        "stop client."
+        self.running.clear()
+        self.iqueue.put(None)
 
-class Console(Client):
+
+class Polled(Client):
 
     def loop(self):
-        "input loop."
-        while True:
+        "polling loop."
+        while self.running.is_set():
             event = self.poll()
-            if not event or self.stopped.is_set():
+            if event is None:
                 break
+            if not event.text:
+                event.ready()
+                continue
             event.orig = repr(self)
             self.callback(event)
-            event.wait()
 
     def poll(self):
         "return event."
         return self.iqueue.get()
 
 
-class Output(Client):
+class Console(Polled):
+
+    def __init__(self):
+        super().__init__()
+        self.register("command", Commands.command)
+
+    def loop(self):
+        "input loop."
+        while self.running.is_set():
+            event = self.poll()
+            if event is None:
+                break
+            if not event.text:
+                event.ready()
+                continue
+            event.orig = repr(self)
+            self.callback(event)
+            event.wait()
+
+
+class Output(Polled):
 
     def __init__(self):
         super().__init__()
@@ -164,7 +203,7 @@ class Output(Client):
 
     def output(self):
         "output loop."
-        while True:
+        while self.running.is_set():
             event = self.oqueue.get()
             if event is None:
                 self.oqueue.task_done()
@@ -172,10 +211,10 @@ class Output(Client):
             self.display(event)
             self.oqueue.task_done()
 
-    def start(self):
+    def start(self, daemon=True):
         "start output loop."
         super().start()
-        Thread.launch(self.output)
+        Thread.launch(self.output, daemon=daemon)
 
     def stop(self):
         "stop output loop."

genocide-233/genocide/modules/adm.py

@@ -0,0 +1,54 @@
+#  This file is placed in the Public Domain.
+
+
+"administrator"
+
+
+from genocide.command import Commands
+from genocide.configs import Main
+from genocide.encoder import Json
+from genocide.package import Mods
+from genocide.persist import Workdir
+from genocide.runtime import Runtime
+
+
+def srv(event):
+    "generate systemd service file."
+    import getpass
+    name = getpass.getuser()
+    event.reply(SYSTEMD % (Main.name.upper(), name, name, name, Main.name))
+
+
+def tbl(event):
+    "create table."
+    Runtime.md5s = {}
+    Commands.names = {}
+    Mods.md5s = {}
+    for name, module in Mods.all():
+        Commands.scan(module)
+    Runtime.setmd5s()
+    Mods.setmd5s()
+    event.reply("# This file is placed in the Pubic Domain.\n\n")
+    event.reply('"tables"\n\n')
+    event.reply(f"CORE = {Json.dumps(Runtime.md5s, indent=4, sort_keys=True)}\n\n")
+    event.reply(f"NAMES = {Json.dumps(Commands.names, indent=4, sort_keys=True)}\n\n")
+    event.reply(f"MD5 = {Json.dumps(Mods.md5s, indent=4, sort_keys=True)}")
+
+
+def wdr(event):
+    "show working directory."
+    event.reply(Workdir.workdir())
+
+
+SYSTEMD = """[Unit]
+Description=%s
+After=multi-user.target
+
+[Service]
+Type=simple
+User=%s
+Group=%s
+ExecStart=/home/%s/.local/bin/%s -s
+
+[Install]
+WantedBy=multi-user.target"""

genocide-233/genocide/modules/bsc.py

@@ -0,0 +1,40 @@
+#  This file is placed in the Public Domain.
+
+
+"administrator"
+
+
+import time
+
+
+from genocide.command import Commands
+from genocide.configs import Main
+from genocide.package import Mods
+from genocide.utility import Time, Utils
+
+
+STARTTIME = time.time()
+
+
+def cmd(event):
+    "list available commands."
+    event.reply(",".join(sorted(Commands.commands(event.orig))))
+
+
+def mod(event):
+    "list available modules."
+    mods = Mods.list()
+    if not mods:
+        event.reply("no modules available")
+        return
+    event.reply(mods)
+
+
+def upt(event):
+    "show uptiome."
+    event.reply(Time.elapsed(time.time()-STARTTIME))
+
+
+def ver(event):
+    "show verson."
+    event.reply(f"{Main.name.upper()} {Utils.md5sum(Mods.path('tbl') or '')[:7]}")