bigtalk 1__tar.gz

bigtalk-1/MANIFEST.in

@@ -0,0 +1,3 @@
+include bin/clean
+include bin/nixt
+recursive-include mods *

bigtalk-1/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: bigtalk
+Version: 1
+Summary: Big Talk
+Author-email: Bart <bthate@dds.nl>
+License-Expression: Unlicense
+Project-URL: home, https://pypi.org/project/bigtalk
+Project-URL: bugs, https://github.com/nixtniet/bigtalk/issues
+Project-URL: source, https://github.com/nixtniet/bigtalk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Description-Content-Type: text/x-rst
+
+B I G T A L K
+=============
+
+
+**NAME**
+
+
+|
+| ``bigtalk`` - Big Talk
+|
+
+
+**SYNOPSIS**
+
+::
+
+    >>> from bigtalk.objects import Object
+    >>> from bigtalk.serials import Jsondumps, loads
+    >>> o = Object()
+    >>> o.a = "b"
+    >>> print(Json.loads(Json.dumps(o)))
+    {'a': 'b'}
+
+
+**DESCRIPTION**
+
+BigTalk has all you need to program a unix cli program, such as disk
+perisistence for configuration files, event handler to handle the
+client/server connection, etc.
+
+BiGTalk contains python3 code to program objects in a functional
+way. it provides an “clean namespace” Object class that only has
+dunder methods, so the namespace is not cluttered with method names.
+This makes storing and reading to/from json possible.
+
+
+**INSTALL**
+
+installation is done with pip
+
+|
+| ``$ pip install bigtalk``
+|
+
+**AUTHOR**
+
+|
+| Bart Thate <``bthate@dds.nl``>
+|
+
+**COPYRIGHT**
+
+|
+| ``BigTalk`` is Public Domain.
+|

bigtalk-1/README.rst

@@ -0,0 +1,55 @@
+B I G T A L K
+=============
+
+
+**NAME**
+
+
+|
+| ``bigtalk`` - Big Talk
+|
+
+
+**SYNOPSIS**
+
+::
+
+    >>> from bigtalk.objects import Object
+    >>> from bigtalk.serials import Jsondumps, loads
+    >>> o = Object()
+    >>> o.a = "b"
+    >>> print(Json.loads(Json.dumps(o)))
+    {'a': 'b'}
+
+
+**DESCRIPTION**
+
+BigTalk has all you need to program a unix cli program, such as disk
+perisistence for configuration files, event handler to handle the
+client/server connection, etc.
+
+BiGTalk contains python3 code to program objects in a functional
+way. it provides an “clean namespace” Object class that only has
+dunder methods, so the namespace is not cluttered with method names.
+This makes storing and reading to/from json possible.
+
+
+**INSTALL**
+
+installation is done with pip
+
+|
+| ``$ pip install bigtalk``
+|
+
+**AUTHOR**
+
+|
+| Bart Thate <``bthate@dds.nl``>
+|
+
+**COPYRIGHT**
+
+|
+| ``BigTalk`` is Public Domain.
+|

bigtalk-1/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-1/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-1/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-1/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-1/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-1/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-1/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-1/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',
+    )