funcnodes-core 0.1.0__tar.gz

funcnodes_core-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: funcnodes-core
+Version: 0.1.0
+Summary: core package for funcnodes
+Author: Julian Kimmig
+Author-email: julian.kimmig@linkdlab.de
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: exposedfunctionality (>=0.3.10)
+Requires-Dist: python-dotenv
+Description-Content-Type: text/markdown
+
+Core package for funcnodes.
+for detailed instructions go to the funcnodes repo
+

funcnodes_core-0.1.0/README.md

@@ -0,0 +1,2 @@
+Core package for funcnodes.
+for detailed instructions go to the funcnodes repo

funcnodes_core-0.1.0/funcnodes_core/__init__.py

@@ -0,0 +1,68 @@
+from .io import (
+    NodeInput,
+    NodeOutput,
+    NodeIO,
+    NodeInputSerialization,
+    NodeOutputSerialization,
+    NodeConnectionError,
+    MultipleConnectionsError,
+    NoValue,
+    SameNodeConnectionError,
+    NodeIOSerialization,
+)
+from .utils import run_until_complete, JSONEncoder, JSONDecoder
+from .node import Node, get_nodeclass, NodeJSON
+from .nodespace import NodeSpace, FullNodeSpaceJSON, NodeSpaceJSON
+from .lib import FullLibJSON, Shelf, Library, find_shelf, NodeClassNotFoundError
+from .nodemaker import NodeClassMixin, NodeDecorator, instance_nodefunction
+from ._logging import FUNCNODES_LOGGER, get_logger
+
+from .data import DataEnum
+
+from . import config
+from .config import RenderOptions
+
+from .utils import special_types as types
+
+from exposedfunctionality import add_type
+
+__all__ = [
+    "NodeInput",
+    "NodeOutput",
+    "NodeIO",
+    "NodeConnectionError",
+    "MultipleConnectionsError",
+    "SameNodeConnectionError",
+    "NodeInputSerialization",
+    "NodeOutputSerialization",
+    "Node",
+    "get_nodeclass",
+    "run_until_complete",
+    "NodeSpace",
+    "FullNodeSpaceJSON",
+    "NodeSpaceJSON",
+    "FullLibJSON",
+    "Shelf",
+    "NodeJSON",
+    "NodeClassMixin",
+    "NodeDecorator",
+    "Library",
+    "find_shelf",
+    "JSONEncoder",
+    "JSONDecoder",
+    "NodeClassNotFoundError",
+    "FUNCNODES_LOGGER",
+    "get_logger",
+    "instance_nodefunction",
+    "config",
+    "RenderOptions",
+    "NoValue",
+    "DataEnum",
+    "add_type",
+    "types",
+    "NodeIOSerialization",
+]
+
+__version__ = "0.1.0"
+
+DEBUG = True

funcnodes_core-0.1.0/funcnodes_core/_logging.py

@@ -0,0 +1,100 @@
+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.DEBUG)
+
+
+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

funcnodes_core-0.1.0/funcnodes_core/config.py

@@ -0,0 +1,141 @@
+from typing import TypedDict
+import os
+import json
+from .utils import deep_fill_dict
+
+from dotenv import load_dotenv
+from exposedfunctionality.function_parser.types import type_to_string
+
+load_dotenv(override=True)
+
+
+BASE_CONFIG_DIR = os.environ.get(
+    "FUNCNODES_CONFIG_DIR", os.path.join(os.path.expanduser("~"), ".funcnodes")
+)
+
+DEFAULT_CONFIG = {
+    "env_dir": os.path.join(BASE_CONFIG_DIR, "env"),
+    "worker_manager": {
+        "host": "localhost",
+        "port": 9380,
+    },
+    "frontend": {
+        "port": 8000,
+    },
+}
+
+
+CONFIG = DEFAULT_CONFIG
+CONFIG_DIR = BASE_CONFIG_DIR
+
+
+def load_config(path):
+    """
+    Loads the configuration file.
+
+    Args:
+      path (str): The path to the configuration file.
+
+    Returns:
+      None
+
+    Examples:
+      >>> load_config("config.json")
+    """
+    global CONFIG
+    if not os.path.exists(path):
+        config = DEFAULT_CONFIG
+    else:
+        with open(path, "r") as f:
+            config = json.load(f)
+    deep_fill_dict(config, DEFAULT_CONFIG)
+    with open(path, "w") as f:
+        json.dump(config, f, indent=2)
+    CONFIG = config
+
+
+def check_config_dir():
+    """
+    Checks the configuration directory.
+
+    Returns:
+      None
+
+    Examples:
+      >>> check_config_dir()
+    """
+    global CONFIG_DIR
+    if not os.path.exists(BASE_CONFIG_DIR):
+        os.makedirs(BASE_CONFIG_DIR)
+    load_config(os.path.join(BASE_CONFIG_DIR, "config.json"))
+    if "custom_config_dir" in CONFIG:
+        load_config(os.path.join(CONFIG["custom_config_dir"], "config.json"))
+        CONFIG_DIR = CONFIG["custom_config_dir"]
+
+
+check_config_dir()
+
+
+class RenderOptions(TypedDict, total=False):
+    """
+    A typed dictionary for render options.
+
+    Attributes:
+      typemap (dict[str, str]): A dictionary mapping types to strings.
+      inputconverter (dict[str, str]): A dictionary mapping input types to strings.
+    """
+
+    typemap: dict[str, str]
+    inputconverter: dict[str, str]
+
+
+FUNCNODES_RENDER_OPTIONS: RenderOptions = {"typemap": {}, "inputconverter": {}}
+
+
+def update_render_options(options: RenderOptions):
+    """
+    Updates the render options.
+
+    Args:
+      options (RenderOptions): The render options to update.
+
+    Returns:
+      None
+
+    Examples:
+      >>> update_render_options({"typemap": {"int": "int32"}, "inputconverter": {"str": "string"}})
+    """
+    if not isinstance(options, dict):
+        return
+    if "typemap" not in options:
+        options["typemap"] = {}
+    for k, v in list(options["typemap"].items()):
+        if not isinstance(k, str):
+            del options["typemap"][k]
+            k = type_to_string(k)
+            options["typemap"][k] = v
+
+        if not isinstance(v, str):
+            v = type_to_string(v)
+            options["typemap"][k] = v
+
+    if "inputconverter" not in options:
+        options["inputconverter"] = {}
+    for k, v in list(options["inputconverter"].items()):
+        if not isinstance(k, str):
+            del options["typemap"][k]
+            k = type_to_string(k)
+            options["inputconverter"][k] = v
+        if not isinstance(v, str):
+            v = type_to_string(v)
+            options["inputconverter"][k] = v
+        FUNCNODES_RENDER_OPTIONS["inputconverter"][k] = v
+
+    # make sure its json serializable
+    try:
+        json.dumps(options)
+    except json.JSONDecodeError:
+        return
+    deep_fill_dict(
+        FUNCNODES_RENDER_OPTIONS, options, merge_lists=True, unfify_lists=True
+    )

funcnodes_core-0.1.0/funcnodes_core/data.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+import enum
+from exposedfunctionality.function_parser.types import add_type
+from typing import Union, Any, TypeVar, Type
+
+
+ET = TypeVar("ET", bound="DataEnum")
+
+
+class DataEnum(enum.Enum):
+    """
+    Base class for data enums. They should be used as a type hint for a function argument for funcnodes.
+    In the function the value can be accessed by using the v method.
+    The reson for this is to be more robust that the values to the function can be
+    passed as the Enum, as a value or as a enum key.
+
+    Example:
+    ```python
+    class TestEnum(DataEnum):
+        A = 1
+        B = 2
+        C = 3
+
+    @NodeDecorator(node_id="test_enum")
+    def test_enum_node(a: TestEnum) -> int:
+        a = TestEnum.v(a)
+        return a
+    """
+
+    def __init_subclass__(cls) -> None:
+        add_type(
+            cls,
+            cls.__name__,
+        )
+
+        cls._lookup = {}
+        for member in cls:
+            cls._lookup[member.name] = member
+            try:
+                if member.value not in cls._lookup:
+                    cls._lookup[member.value] = member
+            except TypeError:
+                pass
+            if str(member.value) not in cls._lookup:
+                cls._lookup[str(member.value)] = member
+
+    @classmethod
+    def interfere(cls: Type[ET], a: Union[ET, str, Any]) -> ET:
+        if isinstance(a, cls):
+            return a
+        if a in cls._lookup:
+            return cls._lookup[a]
+        try:
+            return cls(a)
+        except ValueError as e:
+            if isinstance(a, str):
+                if a.startswith(cls.__name__ + "."):
+                    a = a[len(cls.__name__) + 1 :]
+                    if a in cls._lookup:
+                        return cls._lookup[a]
+
+            raise e
+
+    @classmethod
+    def v(cls: Type[ET], a: Union[ET, str, Any]) -> Any:
+        return cls.interfere(a).value