bigtalk 1__py3-none-any.whl

bigtalk/brokers.py

@@ -0,0 +1,36 @@
+# This file is placed in the Public Domain.
+
+
+"an object for a string"
+
+
+class Broker:
+
+    objects = {}
+
+    @staticmethod
+    def add(obj):
+        Broker.objects[repr(obj)] = obj
+        
+    @staticmethod
+    def all(attr):
+       for obj in Broker.objects.values():
+           if attr in dir(obj):
+               yield obj
+
+    @staticmethod
+    def get(origin):
+        return Broker.objects.get(origin)
+
+
+    @staticmethod
+    def like(txt):
+        for orig in Broker.objects:
+            if orig.split()[0] in orig.split()[0]:
+                yield orig
+
+
+def __dir__():
+    return (
+        'Broker',
+    )

bigtalk/clients.py

@@ -0,0 +1,87 @@
+# This file is placed in the Public Domain.
+
+
+"client-side event handling"
+
+
+import logging
+import queue
+import threading
+import _thread
+
+
+from .brokers import Broker
+from .command import Commands
+from .handler import Handler
+from .threads import Threads
+
+
+class Client(Handler):
+
+    def __init__(self):
+        super().__init__()
+        self.olock = threading.RLock()
+        self.oqueue = queue.Queue()
+        self.silent = True
+        Broker.add(self)
+
+    def announce(self, text):
+        if not self.silent:
+            self.raw(text)
+
+    def display(self, event):
+        with self.olock:
+            for tme in event.result:
+                txt = event.result.get(tme)
+                self.dosay(event.channel, txt)
+
+    def dosay(self, channel, text):
+        self.say(channel, text)
+
+    def raw(self, text):
+        raise NotImplementedError("raw")
+
+    def say(self, channel, text):
+        self.raw(text)
+
+    def wait(self):
+        try:
+            self.oqueue.join()
+        except Exception as ex:
+            logging.exception(ex)
+            _thread.interrupt_main()
+
+
+class CLI(Client):
+ 
+     def __init__(self):
+         super().__init__()
+         self.register("command", Commands.command)
+
+
+class Output(Client):
+
+    def output(self):
+        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):
+        Threads.launch(self.output)
+        super().start()
+
+    def stop(self):
+        self.oqueue.put(None)
+        super().stop()
+
+
+def __dir__():
+    return (
+        'Client',
+        'CLI',
+        'Output'
+    )

bigtalk/command.py

@@ -0,0 +1,49 @@
+# This file is placed in the Public Domain.
+
+
+"write your own commands"
+
+
+import inspect
+
+
+from .methods import Methods
+
+
+class Commands:
+
+    cmds = {}
+    names = {}
+
+    @staticmethod
+    def add(*args):
+        for func in args:
+            name = func.__name__
+            Commands.cmds[name] = func
+            Commands.names[name] = func.__module__.split(".")[-1]
+
+    @staticmethod
+    def command(evt):
+        Methods.parse(evt, evt.text)
+        func = Commands.get(evt.cmd)
+        if func:
+           func(evt)
+           evt.display()
+        evt.ready()
+
+    @staticmethod
+    def get(cmd):
+        return Commands.cmds.get(cmd, None)
+
+    @staticmethod
+    def scan(module):
+        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',
+    )

bigtalk/handler.py

@@ -0,0 +1,54 @@
+# This file is placed in the Public Domain.
+
+
+"handle your own events"
+
+
+import queue
+
+
+from .threads import Threads
+
+
+class Handler:
+
+    def __init__(self):
+        self.cbs = {}
+        self.queue = queue.Queue()
+
+    def callback(self, event):
+        func = self.cbs.get(event.kind, None)
+        if not func:
+            event.ready()
+            return
+        name = event.text and event.text.split()[0]
+        event._thr = Threads.launch(func, event, name=name)
+
+    def loop(self):
+        while True:
+            event = self.poll()
+            if not event:
+                break
+            event.orig = repr(self)
+            self.callback(event)
+
+    def poll(self):
+        return self.queue.get()
+
+    def put(self, event):
+        self.queue.put(event)
+
+    def register(self, kind, callback):
+        self.cbs[kind] = callback
+
+    def start(self):
+        Threads.launch(self.loop)
+
+    def stop(self):
+        self.queue.put(None)
+
+
+def __dir__():
+    return (
+        'Handler',
+    )

bigtalk/kernels.py

@@ -0,0 +1,69 @@
+# This file is placed in the Public Domain.
+
+
+"in the beginning"
+
+
+import time
+
+
+from .command import Commands
+from .loggers import Logging
+from .objects import Default
+from .package import Mods
+from .threads import Threads
+from .utility import Utils
+from .workdir import Workdir
+
+
+class Config(Default):
+
+    debug = False
+    init = ""
+    level = "info"
+    name = ""
+    opts = ""
+    sets = Default()
+    version = 0
+
+
+class Kernel:
+
+    @staticmethod
+    def configure(local=False, network=False):
+        assert Config.name
+        Logging.level(Config.sets.level or "info")
+        Workdir.configure(Config.name)
+        Mods.configure(local, network)
+
+    @staticmethod
+    def forever():
+        while True:
+            try:
+                time.sleep(0.1)
+            except (KeyboardInterrupt, EOFError):
+                break
+
+    @staticmethod
+    def init(names, wait=False):
+        thrs = []
+        for name in Utils.spl(names):
+            mod = Mods.get(name)
+            if "init" not in dir(mod):
+                continue
+            thrs.append(Threads.launch(mod.init))
+        if wait:
+            for thr in thrs:
+                thr.join()
+
+    @staticmethod
+    def scanner(names):
+        for mod in Mods.mods(names):
+            Commands.scan(mod)
+
+
+def __dir__():
+    return (
+        'Config',
+        'Kernel'
+    )

bigtalk/locater.py

@@ -0,0 +1,86 @@
+# This file is placed in the Public Domain.
+
+
+"find objects"
+
+
+import os
+import time
+
+
+from .methods import Methods
+from .objects import Object
+from .persist import Cache, Disk
+from .workdir import Workdir
+
+
+keys   = Object.keys
+update = Object.update
+
+
+class Locater:
+
+    @staticmethod
+    def attrs(kind):
+        objs = list(Locater.find(kind))
+        if objs:
+            return list(keys(objs[0][1]))
+        return []
+
+    @staticmethod
+    def find(kind, selector={}, removed=False, matching=False):
+        fullname = Workdir.long(kind)
+        for pth in Locater.fns(fullname):
+            obj = Cache.get(pth)
+            if not obj:
+                obj = Object()
+                Disk.read(obj, pth)
+                Cache.add(pth, obj)
+            if not removed and Methods.deleted(obj):
+                continue
+            if selector and not Methods.search(obj, selector, matching):
+                continue
+            yield pth, obj
+
+    @staticmethod
+    def fns(kind):
+        path = Workdir.store(kind)
+        for rootdir, dirs, _files in os.walk(path, topdown=True):
+            for dname in dirs:
+                if dname.count("-") != 2:
+                    continue
+                ddd = os.path.join(rootdir, dname)
+                for fll in os.listdir(ddd):
+                    yield os.path.join(ddd, fll)
+
+    @staticmethod
+    def fntime(daystr):
+        datestr = " ".join(daystr.split(os.sep)[-2:])
+        datestr = datestr.replace("_", " ")
+        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 float(timed)
+
+    @staticmethod
+    def last(obj, selector={}):
+        result = sorted(
+                        Locater.find(Object.fqn(obj), selector),
+                        key=lambda x: Locater.fntime(x[0])
+                       )
+        res = ""
+        if result:
+            inp = result[-1]
+            update(obj, inp[-1])
+            res = inp[0]
+        return res
+
+
+def __dir__():
+    return (
+        'Locater',
+    )

bigtalk/loggers.py

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

bigtalk/message.py

@@ -0,0 +1,46 @@
+# This file is placed in the Public Domain.
+
+
+"only message"
+
+
+import threading
+import time
+
+
+from .brokers import Broker
+from .objects import Default
+
+
+class Message(Default):
+
+    def __init__(self):
+        super().__init__()
+        self._ready = threading.Event()
+        self.result = {}
+        self.thr = None
+        self.args = []
+        self.index = 0
+        self.kind = "event"
+        self.orig = ""
+
+    def display(evt):
+        bot = Broker.get(evt.orig)
+        bot.display(evt)
+        
+    def ready(self):
+        self._ready.set()
+
+    def reply(self, text):
+        self.result[time.time()] = text
+
+    def wait(self, timeout=0.0):
+        if self.thr:
+            self.thr.join(timeout)
+        self._ready.wait(timeout or None)
+
+
+def __dir__():
+    return (
+        'Message',
+    )

bigtalk/methods.py

@@ -0,0 +1,139 @@
+# This file is placed in the Public Domain.
+
+
+"functions with an object as the first argument"
+
+
+from .objects import Default, Object
+
+
+class Methods:
+
+    @staticmethod
+    def deleted(obj):
+        return "__deleted__" in dir(obj) and obj.__deleted__
+
+    @staticmethod
+    def edit(obj, setter={}, skip=False):
+        for key, val in Object, items(setter):
+            if skip and val == "":
+                continue
+            try:
+                setattr(obj, key, int(val))
+                continue
+            except ValueError:
+                pass
+            try:
+                setattr(obj, key, float(val))
+                continue
+            except ValueError:
+                pass
+            if val in ["True", "true"]:
+                setattr(obj, key, True)
+            elif val in ["False", "false"]:
+                setattr(obj, key, False)
+            else: 
+                setattr(obj, key, val)
+
+    @staticmethod
+    def fmt(obj, args=[], skip=[], plain=False, empty=False):
+        if args == []:
+            args = list(obj.__dict__.keys())
+        txt = ""
+        for key in args:
+            if key.startswith("__"):
+                continue
+            if key in skip:
+                continue
+            value = getattr(obj, key, None)
+            if value is None:
+                continue
+            if not empty and not value:
+                continue
+            if plain:
+                txt += f"{value} "
+            elif isinstance(value, str):
+                txt += f'{key}="{value}" '
+            elif isinstance(value, (int, float, dict, bool, list)):
+                txt += f"{key}={value} "
+            else:
+                txt += f"{key}={Object.fqn(value)}((value))"
+        if txt == "":
+             txt = "{}"
+        return txt.strip()
+
+    @staticmethod
+    def parse(obj, text):
+        data = {
+            "args": [],
+            "cmd": "",
+            "gets": Default(),
+            "index": None,
+            "init": "",
+            "opts": "",
+            "otxt": text,
+            "rest": "",
+            "silent": Default(),
+            "sets": Default(),
+            "text": text
+        }
+        for k, v in data.items():
+            setattr(obj, k, getattr(obj, k, v) or v)
+        args = []
+        nr = -1
+        for spli in text.split():
+            if spli.startswith("-"):
+                try:
+                    obj.index = int(spli[1:])
+                except ValueError:
+                    obj.opts += spli[1:]
+                continue
+            if "-=" in spli:
+                key, value = spli.split("-=", maxsplit=1)
+                setattr(obj.silent, key, value)
+                setattr(obj.gets, key. value)
+                continue
+            if "==" in spli:
+                key, value = spli.split("==", maxsplit=1)
+                setattr(obj.gets, key, value)
+                continue
+            if "=" in spli:
+                key, value = spli.split("=", maxsplit=1)
+                setattr(obj.sets, key, value)
+                continue
+            nr += 1
+            if nr == 0:
+                obj.cmd = spli
+                continue
+            args.append(spli)
+        if args:
+            obj.args = args
+            obj.text  = obj.cmd or ""
+            obj.rest = " ".join(obj.args)
+            obj.text  = obj.cmd + " " + obj.rest
+        else:
+            obj.text = obj.cmd or ""
+
+    @staticmethod
+    def search(obj, selector={}, matching=False):
+        res = False
+        for key, value in items(selector):
+            val = getattr(obj, key, None)
+            if not val:
+                res = False
+                break
+            elif matching and value != val:
+                res = False
+                break
+            elif str(value).lower() not in str(val).lower():
+                res = False
+                break
+            else:
+                res = True
+        return res
+
+
+def __dir__():
+    return (
+        'Methods',
+    )

bigtalk/objects.py

@@ -0,0 +1,99 @@
+# This file is placed in the Public Domain.
+
+
+"a clean namespace"
+
+
+import types
+
+
+class Reserved(Exception):
+
+    pass
+
+
+class Object:
+
+    def __contains__(self, key):
+        return key in dir(self)
+
+    def __iter__(self):
+        return iter(self.__dict__)
+
+    def __len__(self):
+        return len(self.__dict__)
+
+    def __str__(self):
+        return str(self.__dict__)
+
+    @staticmethod
+    def construct(obj, *args, **kwargs):
+        if args:
+            val = args[0]
+            if isinstance(val, zip):
+                Object.update(obj, dict(val))
+            elif isinstance(val, dict):
+                Object.update(obj, val)
+            else:
+                Object.update(obj, vars(val))
+        if kwargs:
+            Object.update(obj, kwargs)
+
+    @staticmethod
+    def fqn(obj):
+        kin = str(type(obj)).split()[-1][1:-2]
+        if kin == "type":
+            tpe = type(obj)
+            kin = f"{tpe.__module__}.{tpe.__name__}"
+        return kin
+
+    @staticmethod
+    def items(obj):
+        if isinstance(obj, dict):
+            return obj.items()
+        if isinstance(obj, types.MappingProxyType):
+            return obj.items()
+        return obj.__dict__.items()
+
+    @staticmethod
+    def keys(obj):
+        if isinstance(obj, dict):
+            return obj.keys()
+        return obj.__dict__.keys()
+
+    @staticmethod
+    def update(obj, data, empty=True):
+        if isinstance(obj, type):
+            for k, v in Object.items(data):
+                if isinstance(getattr(obj, k, None), types.MethodType):
+                    raise Reserved(k)
+                setattr(obj, k, v)
+        elif isinstance(obj, dict):
+            for k, v in items(data):
+                setattr(obj, k, v)
+        else:
+            for key, value in Object.items(data):
+                if not empty and not value:
+                    continue
+                setattr(obj, key, value)
+
+    @staticmethod
+    def values(obj):
+       if isinstance(obj, dict):
+           return obj.values()
+       return obj.__dict__.values()
+
+
+class Default(Object):
+
+    def __getattr__(self, key):
+        return self.__dict__.get(key, "")
+
+
+
+def __dir__():
+    return (
+        'Default',
+        'Object',
+        'Reserved'
+    )