meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7010__py2.py3-none-any.whl

meerk40t/kernel/lifecycles.py

@@ -1,71 +1,71 @@
-LIFECYCLE_KERNEL_INIT = 0
-LIFECYCLE_KERNEL_PRECLI = 20
-LIFECYCLE_KERNEL_CLI = 25
-LIFECYCLE_KERNEL_INVALIDATE = 50
-LIFECYCLE_KERNEL_PREREGISTER = 100
-LIFECYCLE_KERNEL_REGISTER = 101
-LIFECYCLE_KERNEL_CONFIGURE = 102
-LIFECYCLE_KERNEL_PREBOOT = 200
-LIFECYCLE_KERNEL_BOOT = 201
-LIFECYCLE_KERNEL_POSTBOOT = 202
-LIFECYCLE_KERNEL_PRESTART = 300
-LIFECYCLE_KERNEL_START = 301
-LIFECYCLE_KERNEL_POSTSTART = 302
-LIFECYCLE_KERNEL_READY = 303
-LIFECYCLE_KERNEL_FINISHED = 304
-LIFECYCLE_KERNEL_PREMAIN = 400
-LIFECYCLE_KERNEL_MAINLOOP = 401
-LIFECYCLE_KERNEL_POSTMAIN = 402
-LIFECYCLE_KERNEL_PRESHUTDOWN = 900
-LIFECYCLE_KERNEL_SHUTDOWN = 1000
-
-LIFECYCLE_SERVICE_INIT = 0
-LIFECYCLE_SERVICE_ADDED = 50
-LIFECYCLE_SERVICE_ATTACHED = 100
-LIFECYCLE_SERVICE_ASSIGNED = 101
-LIFECYCLE_SERVICE_DETACHED = 200
-LIFECYCLE_SERVICE_SHUTDOWN = 1000
-
-LIFECYCLE_MODULE_OPENED = 100
-LIFECYCLE_MODULE_CLOSED = 200
-
-KERNEL_LIFECYCLE_NAMES = {
-    LIFECYCLE_KERNEL_INIT: "init",
-    LIFECYCLE_KERNEL_PRECLI: "precli",
-    LIFECYCLE_KERNEL_CLI: "cli",
-    LIFECYCLE_KERNEL_INVALIDATE: "invalidate",
-    LIFECYCLE_KERNEL_PREREGISTER: "preregister",
-    LIFECYCLE_KERNEL_REGISTER: "register",
-    LIFECYCLE_KERNEL_CONFIGURE: "configure",
-    LIFECYCLE_KERNEL_PREBOOT: "preboot",
-    LIFECYCLE_KERNEL_BOOT: "boot",
-    LIFECYCLE_KERNEL_POSTBOOT: "postboot",
-    LIFECYCLE_KERNEL_PRESTART: "prestart",
-    LIFECYCLE_KERNEL_START: "start",
-    LIFECYCLE_KERNEL_POSTSTART: "poststart",
-    LIFECYCLE_KERNEL_READY: "ready",
-    LIFECYCLE_KERNEL_FINISHED: "finished",
-    LIFECYCLE_KERNEL_PREMAIN: "premain",
-    LIFECYCLE_KERNEL_MAINLOOP: "mainloop",
-    LIFECYCLE_KERNEL_POSTMAIN: "postmain",
-    LIFECYCLE_KERNEL_PRESHUTDOWN: "preshutdown",
-    LIFECYCLE_KERNEL_SHUTDOWN: "shutdown",
-}
-
-
-def kernel_lifecycle_name(lifecycle):
-    return KERNEL_LIFECYCLE_NAMES[lifecycle]
-
-
-SERVICE_LIFECYCLE_NAMES = {
-    LIFECYCLE_SERVICE_INIT: "init",
-    LIFECYCLE_SERVICE_ADDED: "added",
-    LIFECYCLE_SERVICE_ATTACHED: "attached",
-    LIFECYCLE_SERVICE_ASSIGNED: "assigned",
-    LIFECYCLE_SERVICE_DETACHED: "detached",
-    LIFECYCLE_SERVICE_SHUTDOWN: "shutdown",
-}
-
-
-def service_lifecycle_name(lifecycle):
-    return SERVICE_LIFECYCLE_NAMES[lifecycle]
+LIFECYCLE_KERNEL_INIT = 0
+LIFECYCLE_KERNEL_PRECLI = 20
+LIFECYCLE_KERNEL_CLI = 25
+LIFECYCLE_KERNEL_INVALIDATE = 50
+LIFECYCLE_KERNEL_PREREGISTER = 100
+LIFECYCLE_KERNEL_REGISTER = 101
+LIFECYCLE_KERNEL_CONFIGURE = 102
+LIFECYCLE_KERNEL_PREBOOT = 200
+LIFECYCLE_KERNEL_BOOT = 201
+LIFECYCLE_KERNEL_POSTBOOT = 202
+LIFECYCLE_KERNEL_PRESTART = 300
+LIFECYCLE_KERNEL_START = 301
+LIFECYCLE_KERNEL_POSTSTART = 302
+LIFECYCLE_KERNEL_READY = 303
+LIFECYCLE_KERNEL_FINISHED = 304
+LIFECYCLE_KERNEL_PREMAIN = 400
+LIFECYCLE_KERNEL_MAINLOOP = 401
+LIFECYCLE_KERNEL_POSTMAIN = 402
+LIFECYCLE_KERNEL_PRESHUTDOWN = 900
+LIFECYCLE_KERNEL_SHUTDOWN = 1000
+
+LIFECYCLE_SERVICE_INIT = 0
+LIFECYCLE_SERVICE_ADDED = 50
+LIFECYCLE_SERVICE_ATTACHED = 100
+LIFECYCLE_SERVICE_ASSIGNED = 101
+LIFECYCLE_SERVICE_DETACHED = 200
+LIFECYCLE_SERVICE_SHUTDOWN = 1000
+
+LIFECYCLE_MODULE_OPENED = 100
+LIFECYCLE_MODULE_CLOSED = 200
+
+KERNEL_LIFECYCLE_NAMES = {
+    LIFECYCLE_KERNEL_INIT: "init",
+    LIFECYCLE_KERNEL_PRECLI: "precli",
+    LIFECYCLE_KERNEL_CLI: "cli",
+    LIFECYCLE_KERNEL_INVALIDATE: "invalidate",
+    LIFECYCLE_KERNEL_PREREGISTER: "preregister",
+    LIFECYCLE_KERNEL_REGISTER: "register",
+    LIFECYCLE_KERNEL_CONFIGURE: "configure",
+    LIFECYCLE_KERNEL_PREBOOT: "preboot",
+    LIFECYCLE_KERNEL_BOOT: "boot",
+    LIFECYCLE_KERNEL_POSTBOOT: "postboot",
+    LIFECYCLE_KERNEL_PRESTART: "prestart",
+    LIFECYCLE_KERNEL_START: "start",
+    LIFECYCLE_KERNEL_POSTSTART: "poststart",
+    LIFECYCLE_KERNEL_READY: "ready",
+    LIFECYCLE_KERNEL_FINISHED: "finished",
+    LIFECYCLE_KERNEL_PREMAIN: "premain",
+    LIFECYCLE_KERNEL_MAINLOOP: "mainloop",
+    LIFECYCLE_KERNEL_POSTMAIN: "postmain",
+    LIFECYCLE_KERNEL_PRESHUTDOWN: "preshutdown",
+    LIFECYCLE_KERNEL_SHUTDOWN: "shutdown",
+}
+
+
+def kernel_lifecycle_name(lifecycle):
+    return KERNEL_LIFECYCLE_NAMES[lifecycle]
+
+
+SERVICE_LIFECYCLE_NAMES = {
+    LIFECYCLE_SERVICE_INIT: "init",
+    LIFECYCLE_SERVICE_ADDED: "added",
+    LIFECYCLE_SERVICE_ATTACHED: "attached",
+    LIFECYCLE_SERVICE_ASSIGNED: "assigned",
+    LIFECYCLE_SERVICE_DETACHED: "detached",
+    LIFECYCLE_SERVICE_SHUTDOWN: "shutdown",
+}
+
+
+def service_lifecycle_name(lifecycle):
+    return SERVICE_LIFECYCLE_NAMES[lifecycle]

meerk40t/kernel/module.py

@@ -1,49 +1,49 @@
-class Module:
-    """
-    Modules are a generic lifecycle object. These are registered in the kernel as modules and when open() is called for
-    a context. When close() is called on the context, it will close and delete references to the opened module and call
-    module_close().
-
-    If an opened module tries to open() a second time in a context with the same name, and was not closed, the
-    restore() function is called for the module, with the same args and kwargs that would have been called on
-    __init__().
-
-    Multiple instances of a module can be opened but this requires a different initialization name.
-    """
-
-    def __init__(
-        self,
-        context: "Context",
-        name: str = None,
-        registered_path: str = None,
-        *args,
-        **kwargs,
-    ):
-        self.context = context
-        self.name = name
-        self.registered_path = registered_path
-        self.state = "init"
-
-    def __repr__(self):
-        return f'{self.__class__.__name__}({repr(self.context)}, name="{self.name}")'
-
-    def restore(self, *args, **kwargs):
-        """Called with the same values of __init()__ on an attempt to reopen of a module with the same name at the
-        same context."""
-        pass
-
-    def module_open(self, *args, **kwargs):
-        """Initialize() is called after open() to set up the module and allow it to register various hooks into the
-        kernelspace."""
-        pass
-
-    def module_close(self, *args, **kwargs):
-        """Finalize is called after close() to unhook various kernelspace hooks. This will happen if kernel is being
-        shutdown or if this individual module is being closed on its own."""
-        pass
-
-    def add_module_delegate(self, delegate):
-        self.context.kernel.add_delegate(delegate, self)
-
-    def remove_module_delegate(self, delegate):
-        self.context.kernel.remove_delegate(delegate, self)
+class Module:
+    """
+    Modules are a generic lifecycle object. These are registered in the kernel as modules and when open() is called for
+    a context. When close() is called on the context, it will close and delete references to the opened module and call
+    module_close().
+
+    If an opened module tries to open() a second time in a context with the same name, and was not closed, the
+    restore() function is called for the module, with the same args and kwargs that would have been called on
+    __init__().
+
+    Multiple instances of a module can be opened but this requires a different initialization name.
+    """
+
+    def __init__(
+        self,
+        context: "Context",
+        name: str = None,
+        registered_path: str = None,
+        *args,
+        **kwargs,
+    ):
+        self.context = context
+        self.name = name
+        self.registered_path = registered_path
+        self.state = "init"
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({repr(self.context)}, name="{self.name}")'
+
+    def restore(self, *args, **kwargs):
+        """Called with the same values of __init()__ on an attempt to reopen of a module with the same name at the
+        same context."""
+        pass
+
+    def module_open(self, *args, **kwargs):
+        """Initialize() is called after open() to set up the module and allow it to register various hooks into the
+        kernelspace."""
+        pass
+
+    def module_close(self, *args, **kwargs):
+        """Finalize is called after close() to unhook various kernelspace hooks. This will happen if kernel is being
+        shutdown or if this individual module is being closed on its own."""
+        pass
+
+    def add_module_delegate(self, delegate):
+        self.context.kernel.add_delegate(delegate, self)
+
+    def remove_module_delegate(self, delegate):
+        self.context.kernel.remove_delegate(delegate, self)

meerk40t/kernel/service.py

@@ -1,147 +1,147 @@
-from typing import Any, Callable
-
-from .context import Context
-from .functions import (
-    console_argument,
-    console_command,
-    console_command_remove,
-    console_option,
-)
-from .lifecycles import *
-
-
-class Service(Context):
-    """
-    A service is a context that with additional capabilities. These get registered by a domain in the kernel as a
-    particular aspect. For example, .device or .gui could be a service and this service would be found at that attribute
-    at for any context. As a type of context, services have a path for saving settings. The path is the saving/loading
-    location for persistent settings. As a service, these contexts may exist at .<domain> relative to any context.
-    This also allows several services to be registered for the same domain. These are swapped with the activate_service
-    commands in the kernel.
-
-    Each service has its own registered lookup of data. This extends the lookup of the kernel but only for those
-    services which are currently active. This extends to various data types that are registered in the kernel such
-    as choices and console commands. The currently active service can modify these simply by being activated. A command
-    registered in a deactivated service cannot be executed from the console, only the activated service's command is
-    executed in that case.
-
-    Unlike contexts which should be derived or gotten at a particular path. Services can be directly instanced.
-    """
-
-    def __init__(self, kernel: "Kernel", path: str, registered_path: str = None):
-        super().__init__(kernel, path)
-        kernel.register_as_context(self)
-        self.registered_path = registered_path
-        self._registered = {}
-
-    def __str__(self):
-        if hasattr(self, "label"):
-            return self.label
-        return f"Service('{self._path}', {self.registered_path})"
-
-    def service_attach(self, *args, **kwargs):
-        pass
-
-    def service_detach(self, *args, **kwargs):
-        pass
-
-    def shutdown(self, *args, **kwargs):
-        """
-        Called by kernel during shutdown process for all services.
-        @param args:
-        @param kwargs:
-        @return:
-        """
-        pass
-
-    def register(self, path: str, obj: Any) -> None:
-        """
-        Registers an element within this service.
-
-        @param path:
-        @param obj:
-        @return:
-        """
-        self._registered[path] = obj
-        try:
-            obj.sub_register(self)
-        except AttributeError:
-            pass
-        self._kernel.lookup_change(path)
-
-    def unregister(self, path: str) -> None:
-        """
-        Unregister an element within this service.
-
-        @param path: Path to unregister
-        @return:
-        """
-        del self._registered[path]
-        self._kernel.lookup_change(path)
-
-    def console_argument(self, *args, **kwargs) -> Callable:
-        """
-        Delegate to Kernel
-
-        Uses current context to be passed to the console_argument being registered.
-        """
-        return console_argument(*args, **kwargs)
-
-    def console_option(self, *args, **kwargs) -> Callable:
-        """
-        Delegate to Kernel
-
-        Uses current context to be passed to the console_option being registered.
-        """
-        return console_option(*args, **kwargs)
-
-    def console_command(self, *args, **kwargs) -> Callable:
-        """
-        Service console command registration.
-
-        Uses the current registration to register the given command.
-        """
-        return console_command(self, *args, **kwargs)
-
-    def console_command_remove(self, *args, **kwargs) -> None:
-        """
-        Delegate to Kernel
-
-        Uses current context to be passed to the console_command being removed.
-        """
-        return console_command_remove(self, *args, **kwargs)
-
-    def destroy(self):
-        self.kernel.set_service_lifecycle(self, LIFECYCLE_SERVICE_SHUTDOWN)
-        self.clear_persistent()
-        self.close_subpaths()
-
-    def register_choices(self, sheet, choices):
-        """
-        Registers choices to a given sheet. If the sheet already exists then the new choices
-        are appended to the given sheet.
-
-        If these choices are registered to an object of Context type we then set the given
-        default values.
-
-        Service register choices command registration.
-
-        Uses the current registration to register the choices.
-        @param sheet: Name of choices being registered
-        @param choices: list of choices
-        @return:
-        """
-        key = f"choices/{sheet}"
-        if key in self._registered:
-            others = self._registered[key]
-            others.extend(choices)
-            self.register(key, others)  # Reregister to trigger lookup change
-        else:
-            self.register(key, choices)
-        for c in choices:
-            obj = c["object"]
-            if isinstance(obj, Context):
-                obj.setting(c["type"], c["attr"], c["default"])
-
-    def add_service_delegate(self, delegate):
-        self.kernel.add_delegate(delegate, self)
+from typing import Any, Callable
+
+from .context import Context
+from .functions import (
+    console_argument,
+    console_command,
+    console_command_remove,
+    console_option,
+)
+from .lifecycles import *
+
+
+class Service(Context):
+    """
+    A service is a context that with additional capabilities. These get registered by a domain in the kernel as a
+    particular aspect. For example, .device or .gui could be a service and this service would be found at that attribute
+    at for any context. As a type of context, services have a path for saving settings. The path is the saving/loading
+    location for persistent settings. As a service, these contexts may exist at .<domain> relative to any context.
+    This also allows several services to be registered for the same domain. These are swapped with the activate_service
+    commands in the kernel.
+
+    Each service has its own registered lookup of data. This extends the lookup of the kernel but only for those
+    services which are currently active. This extends to various data types that are registered in the kernel such
+    as choices and console commands. The currently active service can modify these simply by being activated. A command
+    registered in a deactivated service cannot be executed from the console, only the activated service's command is
+    executed in that case.
+
+    Unlike contexts which should be derived or gotten at a particular path. Services can be directly instanced.
+    """
+
+    def __init__(self, kernel: "Kernel", path: str, registered_path: str = None):
+        super().__init__(kernel, path)
+        kernel.register_as_context(self)
+        self.registered_path = registered_path
+        self._registered = {}
+
+    def __str__(self):
+        if hasattr(self, "label"):
+            return self.label
+        return f"Service('{self._path}', {self.registered_path})"
+
+    def service_attach(self, *args, **kwargs):
+        pass
+
+    def service_detach(self, *args, **kwargs):
+        pass
+
+    def shutdown(self, *args, **kwargs):
+        """
+        Called by kernel during shutdown process for all services.
+        @param args:
+        @param kwargs:
+        @return:
+        """
+        pass
+
+    def register(self, path: str, obj: Any) -> None:
+        """
+        Registers an element within this service.
+
+        @param path:
+        @param obj:
+        @return:
+        """
+        self._registered[path] = obj
+        try:
+            obj.sub_register(self)
+        except AttributeError:
+            pass
+        self._kernel.lookup_change(path)
+
+    def unregister(self, path: str) -> None:
+        """
+        Unregister an element within this service.
+
+        @param path: Path to unregister
+        @return:
+        """
+        del self._registered[path]
+        self._kernel.lookup_change(path)
+
+    def console_argument(self, *args, **kwargs) -> Callable:
+        """
+        Delegate to Kernel
+
+        Uses current context to be passed to the console_argument being registered.
+        """
+        return console_argument(*args, **kwargs)
+
+    def console_option(self, *args, **kwargs) -> Callable:
+        """
+        Delegate to Kernel
+
+        Uses current context to be passed to the console_option being registered.
+        """
+        return console_option(*args, **kwargs)
+
+    def console_command(self, *args, **kwargs) -> Callable:
+        """
+        Service console command registration.
+
+        Uses the current registration to register the given command.
+        """
+        return console_command(self, *args, **kwargs)
+
+    def console_command_remove(self, *args, **kwargs) -> None:
+        """
+        Delegate to Kernel
+
+        Uses current context to be passed to the console_command being removed.
+        """
+        return console_command_remove(self, *args, **kwargs)
+
+    def destroy(self):
+        self.kernel.set_service_lifecycle(self, LIFECYCLE_SERVICE_SHUTDOWN)
+        self.clear_persistent()
+        self.close_subpaths()
+
+    def register_choices(self, sheet, choices):
+        """
+        Registers choices to a given sheet. If the sheet already exists then the new choices
+        are appended to the given sheet.
+
+        If these choices are registered to an object of Context type we then set the given
+        default values.
+
+        Service register choices command registration.
+
+        Uses the current registration to register the choices.
+        @param sheet: Name of choices being registered
+        @param choices: list of choices
+        @return:
+        """
+        key = f"choices/{sheet}"
+        if key in self._registered:
+            others = self._registered[key]
+            others.extend(choices)
+            self.register(key, others)  # Reregister to trigger lookup change
+        else:
+            self.register(key, choices)
+        for c in choices:
+            obj = c["object"]
+            if isinstance(obj, Context):
+                obj.setting(c["type"], c["attr"], c["default"])
+
+    def add_service_delegate(self, delegate):
+        self.kernel.add_delegate(delegate, self)