funcnodes-core 0.2.2__tar.gz → 0.2.4__tar.gz

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funcnodes-core
-Version: 0.2.2
+Version: 0.2.4
 Summary: core package for funcnodes
 License: MIT
 Author: Julian Kimmig

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/funcnodes_core/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 from .io import (
     NodeInput,

funcnodes_core-0.2.4/funcnodes_core/_logging.py

@@ -0,0 +1,215 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from .config import CONFIG_DIR
+import os
+
+LOGGINGDIR = os.path.join(CONFIG_DIR, "logs")
+if not os.path.exists(LOGGINGDIR):
+    os.makedirs(LOGGINGDIR)
+
+
+_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+# Add the handler to the logger
+
+
+def _overwrite_add_handler(logger):
+    """
+    Overwrites the addHandler method of the given logger to ensure handlers are added with a formatter
+    and prevent duplicate handlers from being added.
+
+    Args:
+      logger (logging.Logger): The logger whose addHandler method will be overwritten.
+
+    Returns:
+      None
+
+    Example:
+      >>> _overwrite_add_handler(FUNCNODES_LOGGER)
+    """
+    _old_add_handler = logger.addHandler
+
+    def _new_add_handler(hdlr):
+        """
+        Adds a handler to the given logger if it's not already added,
+        and sets the formatter for the handler.
+
+        Args:
+          hdlr (logging.Handler): The handler to add to the logger.
+
+        Returns:
+          None
+        """
+        hdlr.setFormatter(_formatter)
+        if hdlr not in logger.handlers:
+            _old_add_handler(hdlr)
+
+    logger.addHandler = _new_add_handler
+
+
+def getChildren(logger: logging.Logger):
+    """
+    Retrieves all child loggers of a given logger.
+
+    Args:
+      logger (logging.Logger): The logger for which to retrieve the child loggers.
+
+    Returns:
+      set: A set of child loggers of the given logger.
+
+    Example:
+      >>> getChildren(FUNCNODES_LOGGER)
+    """
+
+    def _hierlevel(_logger: logging.Logger):
+        """
+        Helper function to determine the hierarchy level of a logger.
+
+        Args:
+          _logger (logging.Logger): The logger whose hierarchy level is to be determined.
+
+        Returns:
+          int: The hierarchy level of the logger.
+        """
+        if _logger is _logger.manager.root:
+            return 0
+        return 1 + _logger.name.count(".")
+
+    d = dict(logger.manager.loggerDict)
+    children = set()
+    for item in list(d.values()):
+        try:
+            # catch Exception because ne cannot aquire the logger _lock
+            if (
+                isinstance(item, logging.Logger)
+                and item.parent is logger
+                and _hierlevel(item) == 1 + _hierlevel(item.parent)
+            ):
+                children.add(item)
+        except Exception:
+            pass
+
+    return children
+
+
+def _update_logger_handlers(logger: logging.Logger):
+    """
+    Updates the handlers for the given logger, ensuring it has a StreamHandler and a RotatingFileHandler.
+    The log files are stored in the logs directory, and the log formatting is set correctly.
+    Also updates the handlers for all child loggers.
+
+    Args:
+      logger (logging.Logger): The logger to update handlers for.
+
+    Returns:
+      None
+
+    Example:
+      >>> _update_logger_handlers(FUNCNODES_LOGGER)
+    """
+
+    has_stream_handler = False
+    for hdlr in list(logger.handlers):
+        if isinstance(hdlr, logging.StreamHandler):
+            has_stream_handler = True
+            hdlr.setFormatter(_formatter)
+
+        if isinstance(hdlr, RotatingFileHandler):
+            if hdlr.baseFilename == os.path.join(LOGGINGDIR, f"{logger.name}.log"):
+                hdlr.close()
+                logger.removeHandler(hdlr)
+                continue
+
+        if isinstance(hdlr, logging.Handler):
+            hdlr.setFormatter(_formatter)
+
+    if not has_stream_handler:
+        ch = logging.StreamHandler()
+        ch.setFormatter(_formatter)
+        logger.addHandler(ch)
+
+    fh = RotatingFileHandler(
+        os.path.join(LOGGINGDIR, f"{logger.name}.log"),
+        maxBytes=1024 * 1024 * 5,
+        backupCount=5,
+    )
+    fh.setFormatter(_formatter)
+    logger.addHandler(fh)
+
+    # get child loggers
+    for child in getChildren(logger):
+        _update_logger_handlers(child)
+
+
+def get_logger(name, propagate=True):
+    """
+    Returns a logger with the given name as a child of FUNCNODES_LOGGER,
+    and ensures the logger is set up with appropriate handlers.
+
+    Args:
+      name (str): The name of the logger to retrieve.
+      propagate (bool): Whether to propagate the logger's messages to its parent logger.
+
+    Returns:
+      logging.Logger: The logger with the given name, configured with appropriate handlers.
+
+    Example:
+      >>> get_logger("foo")
+    """
+    sublogger = FUNCNODES_LOGGER.getChild(name)
+    _overwrite_add_handler(sublogger)
+    sublogger.propagate = propagate
+    _update_logger_handlers(sublogger)
+
+    return sublogger
+
+
+def set_logging_dir(path):
+    """
+    Sets a custom directory path for storing log files. If the directory does not exist, it will be created.
+    After updating the directory, the logger's handlers will be updated accordingly.
+
+    Args:
+      path (str): The directory path where log files should be stored.
+
+    Returns:
+      None
+
+    Example:
+      >>> set_logging_dir("/path/to/custom/logs")
+    """
+    global LOGGINGDIR
+    LOGGINGDIR = path
+    if not os.path.exists(path):
+        os.makedirs(path)
+    _update_logger_handlers(FUNCNODES_LOGGER)
+
+
+def set_format(fmt: str):
+    """
+    Sets the log formatting string. The format string will be used for all log handlers.
+
+    Args:
+      fmt (str): The format string for log messages.
+
+    Returns:
+      None
+
+    Example:
+      >>> set_format("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    """
+
+    global _formatter
+    _formatter = logging.Formatter(fmt)
+    _update_logger_handlers(FUNCNODES_LOGGER)
+
+
+FUNCNODES_LOGGER = logging.getLogger("funcnodes")
+
+FUNCNODES_LOGGER.setLevel(logging.INFO)
+_overwrite_add_handler(FUNCNODES_LOGGER)
+_update_logger_handlers(FUNCNODES_LOGGER)
+set_logging_dir(LOGGINGDIR)
+
+
+__all__ = ["FUNCNODES_LOGGER", "get_logger", "set_logging_dir", "set_format"]

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/funcnodes_core/lib/lib.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import List, Optional, TypedDict, Dict, Type, Tuple, Set
+from typing import List, Optional, TypedDict, Dict, Type, Tuple, Set, Sequence
 from funcnodes_core.node import Node, SerializedNodeClass
 from funcnodes_core.utils.serialization import JSONEncoder, Encdata
 from dataclasses import dataclass, field
@@ -180,7 +180,7 @@ def get_node_in_shelf(shelf: Shelf, nodeid: str) -> Tuple[int, Type[Node]]:
     raise NodeClassNotFoundError(f"Node with id {nodeid} not found")
 
 
-def update_nodes_in_shelf(shelf: Shelf, nodes: List[Type[Node]]):
+def update_nodes_in_shelf(shelf: Shelf, nodes: Sequence[Type[Node]]):
     """
     Adds nodes to a shelf
     """
@@ -347,7 +347,7 @@ class Library(EventEmitterMixin):
     @emit_after()
     def add_nodes(
         self,
-        nodes: List[Type[Node]],
+        nodes: Sequence[Type[Node]],
         shelf: str | List[str],
     ):
         if isinstance(shelf, str):
@@ -403,7 +403,7 @@ class Library(EventEmitterMixin):
             i, _ = get_node_in_shelf(shelf, node.node_id)
             shelf.nodes.pop(i)
 
-    def remove_nodeclasses(self, nodes: List[Type[Node]]):
+    def remove_nodeclasses(self, nodes: Sequence[Type[Node]]):
         for node in nodes:
             self.remove_nodeclass(node)
 

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/funcnodes_core/node.py

@@ -345,6 +345,7 @@ class Node(EventEmitterMixin, ABC, metaclass=NodeMeta):
         self._inputs: List[NodeInput] = []
         self._outputs: List[NodeOutput] = []
         self._triggerstack: Optional[TriggerStack] = None
+        self._trigger_open = False
         self._requests_trigger = False
         self.asynceventmanager = AsyncEventManager(self)
         if uuid is None and id is not None:
@@ -797,6 +798,8 @@ class Node(EventEmitterMixin, ABC, metaclass=NodeMeta):
             """Wraps the node's function to handle the triggering of events before and after its execution."""
             # set the trigger event
             await self.asynceventmanager.set_and_clear("triggered")
+            await asyncio.sleep(self._pretrigger_delay)
+            self._trigger_open = False
             self.emit("triggerstart")
             # run the function
 
@@ -852,6 +855,8 @@ class Node(EventEmitterMixin, ABC, metaclass=NodeMeta):
         # if the node is ready to trigger, trigger it
         if self.ready_to_trigger():
             self.trigger()
+        elif self._trigger_open:
+            return
         else:
             # otherwise set the _requests_trigger attribute to True
             self._requests_trigger = True
@@ -914,6 +919,8 @@ class Node(EventEmitterMixin, ABC, metaclass=NodeMeta):
             raise InTriggerError("Node is already in trigger")
         if triggerstack is None:
             triggerstack = TriggerStack()
+        self._pretrigger_delay = 0.02  # 20ms
+        self._trigger_open = True
         triggerlogger.debug(f"triggering {self}")
         self._triggerstack = triggerstack
         self._triggerstack.append(self())

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/funcnodes_core/nodemaker.py

@@ -91,13 +91,6 @@ def node_class_maker(
         """
         A wrapper for the exposed function that sets the output values of the node.
         """
-        print(
-            "BBBtriggering",
-            self,
-            {ip.name: ip.value for ip in self.inputs.values()},
-            args,
-            kwargs,
-        )
         outs = await asyncfunc(*args, **kwargs)
         if len(outputs) > 1:
             for op, out in zip(outputs, outs):

{funcnodes_core-0.2.2 → funcnodes_core-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "funcnodes-core"
-version = "0.2.2"
+version = "0.2.4"
 description = "core package for funcnodes"
 authors = ["Julian Kimmig <julian.kimmig@linkdlab.de>"]
 readme = "README.md"

funcnodes_core-0.2.2/funcnodes_core/_logging.py

@@ -1,100 +0,0 @@
-import logging
-from logging.handlers import RotatingFileHandler
-from .config import CONFIG_DIR
-import os
-
-LOGGINGDIR = os.path.join(CONFIG_DIR, "logs")
-if not os.path.exists(LOGGINGDIR):
-    os.makedirs(LOGGINGDIR)
-
-FUNCNODES_LOGGER = logging.getLogger("funcnodes")
-
-FUNCNODES_LOGGER.setLevel(logging.INFO)
-
-
-ch = logging.StreamHandler()
-
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
-# Add the handler to the logger
-
-
-def _overwrite_add_handler(logger):
-    """
-    Overwrites the addHandler method of the given logger.
-
-    Args:
-      logger (Logger): The logger to overwrite the addHandler method for.
-
-    Returns:
-      None.
-
-    Examples:
-      >>> _overwrite_add_handler(FUNCNODES_LOGGER)
-    """
-    _old_add_handler = logger.addHandler
-
-    def _new_add_handler(hdlr):
-        """
-        Adds a handler to the given logger.
-
-        Args:
-          hdlr (Handler): The handler to add to the logger.
-
-        Returns:
-          None.
-
-        Examples:
-          >>> _new_add_handler(ch)
-        """
-        hdlr.setFormatter(formatter)
-        if hdlr not in logger.handlers:
-            _old_add_handler(hdlr)
-
-    logger.addHandler = _new_add_handler
-
-
-_overwrite_add_handler(FUNCNODES_LOGGER)
-
-FUNCNODES_LOGGER.addHandler(ch)
-
-
-def set_logging_dir(path):
-    if not os.path.exists(path):
-        os.makedirs(path)
-    for hdlr in FUNCNODES_LOGGER.handlers:
-        if isinstance(hdlr, RotatingFileHandler):
-            if hdlr.baseFilename.endswith("funcnodes.log"):
-                hdlr.close()
-                FUNCNODES_LOGGER.removeHandler(hdlr)
-
-    fh = RotatingFileHandler(
-        os.path.join(path, "funcnodes.log"), maxBytes=1024 * 1024 * 5, backupCount=5
-    )
-    fh.setFormatter(formatter)
-    FUNCNODES_LOGGER.addHandler(fh)
-
-
-set_logging_dir(LOGGINGDIR)
-
-
-def get_logger(name, propagate=True):
-    """
-    Returns a logger with the given name.
-
-    Args:
-      name (str): The name of the logger.
-      propagate (bool): Whether to propagate the logger's messages to its parent logger.
-
-    Returns:
-      Logger: The logger with the given name.
-
-    Examples:
-      >>> get_logger("funcnodes")
-    """
-    sublogger = FUNCNODES_LOGGER.getChild(name)
-    _overwrite_add_handler(sublogger)
-    sublogger.propagate = propagate
-    sublogger.addHandler(ch)
-    # _init_logger(sublogger)
-    return sublogger