in-layers-core 0.1.1__tar.gz

in_layers_core-0.1.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: in-layers-core
+Version: 0.1.1
+Summary: The Python port of Node in Layers Core.
+License: GPLv3
+Keywords: layers,python,in-layers,node,domains
+Author: Mike Cornwell
+Author-email: mike@mikecornwell.com
+Requires-Python: >=3.13
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: python-box (>=7,<9)
+Description-Content-Type: text/markdown
+
+# In Layers Core
+
+Python port of the Node-in-Layers core framework.
+Supports  Domains, config and layers loading, and cross-layer logging.
+
+Key points:
+- Domains explicitly provided in config (no convention discovery)
+- Layers are loaded in configured order (supports composite layers)
+- Cross-layer logging with automatic id propagation and function wraps
+
+

in_layers_core-0.1.1/README.md

@@ -0,0 +1,10 @@
+# In Layers Core
+
+Python port of the Node-in-Layers core framework.
+Supports  Domains, config and layers loading, and cross-layer logging.
+
+Key points:
+- Domains explicitly provided in config (no convention discovery)
+- Layers are loaded in configured order (supports composite layers)
+- Cross-layer logging with automatic id propagation and function wraps
+

in_layers_core-0.1.1/pyproject.toml

@@ -0,0 +1,191 @@
+[project]
+name = "in-layers-core"
+version = "0.1.1"
+description = "The Python port of Node in Layers Core."
+authors = [
+    {name = "Mike Cornwell",email = "mike@mikecornwell.com"}
+]
+license = {text = "GPLv3"}
+readme = "README.md"
+homepage = "https://github.com/node-in-layers/python-in-layers-core"  
+repository = "https://github.com/node-in-layers/python-in-layers-core"
+keywords = ["layers", "python", "in-layers", "node", "domains"]
+requires-python = ">=3.13"
+dependencies = [
+]
+
+[tool.poetry]
+name = "in-layers-core"
+version = "0.1.0"
+description = ""
+authors = []
+packages = [
+    { include = "in_layers", from = "src" }
+]
+
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "black>=24.0.0",
+    "ruff>=0.7.0",
+    "isort>=5.12.0",
+    "mypy>=1.12.0",
+    "pytest>=8.0.0",
+    "commitizen (>=3.13,<4.0)",
+    "pytest-cov (>=7.0.0,<8.0.0)",
+    "build (>=1.3.0,<2.0.0)",
+    "twine (>=6.2.0,<7.0.0)",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.13"
+python-box = ">=7,<9"
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+lines_after_imports = 2
+
+
+# ================================================================
+# BLACK (code formatting)
+# ================================================================
+[tool.black]
+line-length = 88
+target-version = ["py313"]
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.venv
+  | venv
+  | build
+  | dist
+  | __pycache__
+  | \.mypy_cache
+  | \.ruff_cache
+)/
+'''
+
+# ================================================================
+# RUFF (linting + import sorting + auto-fixes)
+# ================================================================
+[tool.ruff]
+target-version = "py313"
+line-length = 88
+# Run Ruff from the root; it will traverse all subdirs except excluded.
+exclude = [
+  ".git",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "build",
+  "dist",
+  ".mypy_cache",
+  ".ruff_cache",
+  "tests",
+  "*/tests",
+  "**/tests"
+]
+
+[tool.ruff.lint]
+select = [
+  "E",   # pycodestyle errors
+  "W",   # pycodestyle warnings
+  "F",   # Pyflakes
+  "B",   # flake8-bugbear (common bugs / bad patterns)
+  "I",   # isort (import sorting)
+  "UP",  # pyupgrade (modern syntax)
+  "N",   # pep8-naming (function, class, etc. naming)
+  "C90", # mccabe (complexity)
+  "SIM", # flake8-simplify
+  "S",   # flake8-bandit (basic security checks)
+  "DTZ", # flake8-datetimez (timezone-aware datetimes)
+  "T20", # flake8-print (no stray prints in non-test code)
+  "ARG", # flake8-unused-arguments
+  "PL",  # pylint-like checks (subset)
+  "RUF", # Ruff-specific rules
+]
+
+# Rules we choose to ignore or relax:
+ignore = [
+  "E501",  # Let Black handle line length
+  "W291",  # Trailing whitespace (Black fixes this)
+]
+
+# Per-file ignore examples (customize as desired):
+[tool.ruff.lint.per-file-ignores]
+"**/tests/**" = [
+  "S101",   # Allow 'assert' in tests
+  "T201",   # Allow 'print' in tests if you wish
+]
+"orchestration/scripts/**" = [
+  "T201",   # Allow print in CLI-style scripts
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+# Optionally enable Ruff as a formatter (complementing Black):
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
+
+# -------------------------------------------------------------------
+# Mypy configuration (type checking / "code lensing")
+# -------------------------------------------------------------------
+[tool.mypy]
+ignore_missing_imports = true
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unreachable = true
+disallow_untyped_defs = true        # Functions must be typed
+disallow_incomplete_defs = true     # Arguments & returns must be fully typed
+disallow_untyped_calls = false      # Relaxed for now; can tighten later
+disallow_untyped_decorators = false
+no_implicit_optional = true
+strict_equality = true
+show_error_codes = true
+pretty = true
+exclude = '''
+/(
+    \.git
+  | \.venv
+  | build
+  | dist
+  | __pycache__
+  | \.mypy_cache
+  | tmp
+)/
+'''
+
+# Optional: per-module/per-package overrides
+[[tool.mypy.overrides]]
+module = "tests.*"
+ignore_errors = true
+
+# -------------------------------------------------------------------
+# Pytest configuration (unit tests)
+# -------------------------------------------------------------------
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra -q"
+python_files = [
+    "test_*.py",
+    "*_test.py",
+    "test_*.py",
+    "*-test.py",
+]
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "$version"
+version_scheme = "pep440"
+version_provider = "pep621"

in_layers_core-0.1.1/src/in_layers/core/__init__.py

@@ -0,0 +1,54 @@
+from .entries import load_system
+from .globals.libs import (  # noqa: F401
+    extract_cross_layer_props,
+)
+from .globals.logging import (
+    composite_logger,
+    console_log_full,
+    console_log_json,
+    console_log_simple,
+    log_tcp,
+    standard_logger,
+)
+from .libs import (  # noqa: F401
+    combine_cross_layer_props,
+    create_error_object,
+    get_layers_unavailable,
+    get_log_level_name,
+    get_log_level_number,
+    is_config,
+    validate_config,
+)
+from .protocols import (  # noqa: F401
+    App,
+    AppLayer,
+    CommonContext,
+    Config,
+    CoreConfig,
+    CoreNamespace,
+    CrossLayerProps,
+    FeaturesContext,
+    FunctionLogger,
+    HighLevelLogger,
+    LayerContext,
+    LayerDescription,
+    LayerLogger,
+    LogFormat,
+    Logger,
+    LogId,
+    LogLevel,
+    LogLevelNames,
+    LogMessage,
+    LogMethod,
+    RootLogger,
+)
+
+__all__ = [
+    "composite_logger",
+    "console_log_full",
+    "console_log_json",
+    "console_log_simple",
+    "load_system",
+    "log_tcp",
+    "standard_logger",
+]

in_layers_core-0.1.1/src/in_layers/core/entries.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any
+
+from box import Box
+
+from .globals import features as globals_features
+from .globals import name as globals_name
+from .globals import services as globals_services
+from .layers import features as layers_features
+from .layers import name as layers_name
+from .layers import services as layers_services
+
+
+async def load_system(args: Mapping[str, Any]):
+    environment: str = args["environment"]
+    config: Mapping[str, Any] | None = args.get("config")
+
+    global_services = globals_services.create(
+        {
+            "environment": environment,
+            "working_directory": os.getcwd(),
+        }
+    )
+    global_features = globals_features.create(
+        Box(
+            {
+                "services": {
+                    globals_name: global_services,
+                }
+            }
+        )
+    )
+    globals_context = await global_features.load_globals(config or environment)
+
+    # layers
+
+    the_layers_services = layers_services.create()
+    the_layers_features = layers_features.create(
+        Box(
+            {
+                **globals_context,
+                "services": {
+                    layers_name: the_layers_services,
+                },
+            }
+        )
+    )
+    layers_loaded = await the_layers_features.load_layers()
+    try:
+        if "services" in layers_loaded and layers_name in layers_loaded.services:
+            del layers_loaded.services[layers_name]
+    except Exception:  # noqa: S110
+        pass
+    return layers_loaded

in_layers_core-0.1.1/src/in_layers/core/globals/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from ..protocols import CoreNamespace
+from . import (
+    features,
+    services,
+)
+
+name = CoreNamespace.globals.value
+__all__ = ["features", "name", "services"]

in_layers_core-0.1.1/src/in_layers/core/globals/features.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..libs import is_config, validate_config
+from ..protocols import CommonContext, CoreNamespace, FeaturesContext
+
+globals_name = CoreNamespace.globals.value
+
+
+class GlobalsFeatures:
+    def __init__(self, context: FeaturesContext):
+        self.context = context
+
+    async def load_globals(self, environment_or_config: Any):
+        services = self.context.services[globals_name]
+        if not services:
+            raise RuntimeError(f"Services for {globals_name} not found")
+        config = (
+            environment_or_config
+            if is_config(environment_or_config)
+            else services.load_config()
+        )
+        validate_config(config)
+        common_globals: CommonContext = {
+            "config": config,
+            "root_logger": services.get_root_logger(),
+            "constants": services.get_constants(),
+        }
+        return common_globals
+
+
+def create(context: FeaturesContext) -> GlobalsFeatures:
+    return GlobalsFeatures(context)

in_layers_core-0.1.1/src/in_layers/core/globals/libs.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+from ..libs import combine_cross_layer_props
+from ..protocols import CrossLayerProps, Logger, LogLevelNames
+
+
+def default_get_function_wrap_log_level(layer_name: str) -> LogLevelNames:
+    if layer_name in ("features", "entries"):
+        return LogLevelNames.info
+    if layer_name == "services":
+        return LogLevelNames.trace
+    return LogLevelNames.debug
+
+
+def combine_logging_props(
+    logger: Logger, cross_layer_props: CrossLayerProps | None = None
+) -> Mapping[str, Any]:
+
+    base: CrossLayerProps = {"logging": {"ids": logger.get_ids()}}
+    final = combine_cross_layer_props(base, cross_layer_props or {})  # type: ignore[arg-type]
+    return final["logging"]
+
+
+def is_cross_layer_logging_props(maybe: CrossLayerProps | None) -> bool:
+    return bool(maybe and isinstance(maybe, Mapping) and "logging" in maybe and isinstance(maybe.get("logging"), Mapping) and isinstance(maybe["logging"].get("ids"), list))  # type: ignore[index]
+
+
+def cap_for_logging(input: Any, max_size: int = 50000) -> Any:
+    def safe_stringify(obj: Any) -> str:
+        try:
+            return json.dumps(obj, default=str)
+        except Exception:
+            return "[Unserializable]"
+
+    if not isinstance(input, (list, dict)):
+        return input
+    if len(safe_stringify(input)) <= max_size:
+        return input
+    if isinstance(input, list):
+        build: list[Any] = []
+        for item in input:
+            candidate = [*build, item]
+            if (
+                len(
+                    safe_stringify(
+                        [*candidate, f"[truncated, original length: {len(input)}]"]
+                    )
+                )
+                > max_size
+            ):
+                return [*build, f"[truncated, original length: {len(input)}]"]
+            build.append(item)
+        return build
+    keys = list(input.keys())
+    out: dict[str, Any] = {}
+    for k in keys:
+        out[k] = input[k]
+        truncated = dict(out)
+        truncated["[truncated]"] = f"original keys: {len(keys)}"
+        if len(safe_stringify(truncated)) > max_size:
+            return truncated
+    return out
+
+
+def extract_cross_layer_props(
+    args: list[Any],
+) -> tuple[list[Any], CrossLayerProps | None]:
+    if not args:
+        return [], None
+    last = args[-1]
+    if is_cross_layer_logging_props(last):  # type: ignore[arg-type]
+        return args[:-1], last  # type: ignore[return-value]
+    return args, None