fred.mlambda 0.2.0__tar.gz → 0.4.0__tar.gz

{fred_mlambda-0.2.0/src/main/fred.mlambda.egg-info → fred_mlambda-0.4.0}/PKG-INFO

@@ -1,19 +1,17 @@
 Metadata-Version: 2.4
 Name: fred.mlambda
-Version: 0.2.0
+Version: 0.4.0
 Summary: FRED-MLAMBDA
 Home-page: https://fred.fhr.tools
 Author: Fahera Research, Education, and Development
 Author-email: fred@fahera.mx
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: fred-oss==0.66.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
-Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred/mlambda/_count.py

@@ -1,9 +1,4 @@
-from typing import Any, Optional
-
-from fred.settings import logger_manager
-
-
-logger = logger_manager.get_logger(__name__)
+from typing import Any
 
 
 def count(value: Any, fail: bool = False) -> int:
@@ -13,7 +8,6 @@ def count(value: Any, fail: bool = False) -> int:
     if isinstance(value, Sized):
         return len(value)
     error = f"Unknown type: {type(value)}"
-    logger.warning(error)
     if fail:
         raise ValueError(error)
     return 0

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred/mlambda/_rand.py

@@ -1,11 +1,6 @@
 import random
 from typing import Any
 
-from fred.settings import logger_manager
-
-
-logger = logger_manager.get_logger(__name__)
-
 
 def rand(*args, k=1, disable_autoflat: bool = False) -> list[Any]:
     if not disable_autoflat and k == 1:

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred/mlambda/_strops.py

@@ -1,10 +1,5 @@
 from typing import Optional
 
-from fred.settings import logger_manager
-
-
-logger = logger_manager.get_logger(__name__)
-
 
 def strops(string: str, ops: str, fail: bool = False) -> Optional[str]:
     match ops:
@@ -26,5 +21,4 @@ def strops(string: str, ops: str, fail: bool = False) -> Optional[str]:
             msg = f"Unknown operation: {ops}"
             if fail:
                 raise ValueError(msg)
-            logger.warning(msg)
             return None

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred/mlambda/catalog.py

@@ -1,12 +1,9 @@
 from enum import Enum
 from typing import Optional
 
-from fred.settings import logger_manager
 from fred.mlambda.settings import FRED_MLAMBDA_PARSED_ALIASES
 from fred.mlambda.interface import MLambda
 
-logger = logger_manager.get_logger(__name__)
-
 
 class MLambdaCatalog(Enum):
     STROPS = MLambda(
@@ -41,7 +38,6 @@ class MLambdaCatalog(Enum):
     @classmethod
     def find(cls, alias: str, fail: bool = False, disable_variants: bool = False) -> Optional[MLambda]:
         if "." in alias:
-            logger.warning("The target is a dotpath, not an alias. Use MLambdaParser.from_string() instead.")
             return None
         variants: list[str] = [alias, alias.upper(), alias.lower()]
         for variant in variants[:(1 if disable_variants else len(variants))]:
@@ -56,7 +52,6 @@ class MLambdaCatalog(Enum):
             elif variant in cls.keys():
                 return cls[variant].value
         error = f"Unknown MLambda: {alias}"
-        logger.warning(error)
         if fail:
             raise ValueError(error)
         return None

fred_mlambda-0.4.0/src/main/fred/mlambda/parser.py

@@ -0,0 +1,252 @@
+import re
+import io
+import csv
+from dataclasses import dataclass
+from typing import Any, Callable, Union, Optional
+
+from fred.mlambda.interface import Arguments, MLambda
+from fred.mlambda.catalog import MLambdaCatalog
+
+# Matches innermost ${...} — i.e. no $, {, or } inside the braces.
+# Used by _resolve_nested to find leaf-level expressions to evaluate first.
+_INNER_PATTERN = re.compile(r"\$\{[^${}]*\}")
+
+# Validates the funref portion: "path.to.function" or "ALIAS"
+_FUNREF_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_.]*$")
+
+# Supported type annotations via the "::" syntax, e.g. "42::int"
+MLAMBDA_TYPES = Optional[Union[int, float, bool, str]]
+_NULL_VALUES = ("null", "none", "")
+_TYPE_CASTERS: dict[str, Callable] = {
+    "int": int,
+    "float": float,
+    "bool": lambda v: v.strip().lower() not in ("false", "0", "no", ""),
+    "str": str,
+}
+
+
+def _serialize(value: Any) -> str:
+    """
+    Convert an execution result back into a string token that cast() can
+    handle — used when embedding a nested result into its parent param_line.
+
+    Examples:
+        None        -> "null"
+        True        -> "true"
+        False       -> "false"
+        42          -> "42"
+        3.14        -> "3.14"
+        "alice"     -> "alice"
+    """
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
+def _extract_outer(string: str) -> tuple[str, str]:
+    """
+    Parse the outermost ${funref: param_line} shell using a brace-depth
+    counter so that nested '}' inside param_line are handled correctly.
+
+    Returns:
+        (funref, raw_param_line)
+
+    Raises:
+        ValueError: if the string is not a valid outer MLambda expression.
+    """
+    s = string.strip()
+
+    if not s.startswith("${"):
+        raise ValueError(
+            f"Invalid MLambda expression: {s!r}\n"
+            "Expected format: ${funref: arg1,arg2,kwarg=value,...}"
+        )
+
+    # Walk from position 1 (the '{') counting brace depth
+    depth = 0
+    closing = -1
+    for i in range(1, len(s)):
+        if s[i] == "{":
+            depth += 1
+        elif s[i] == "}":
+            depth -= 1
+            if depth == 0:
+                closing = i
+                break
+
+    if closing == -1:
+        raise ValueError(f"Unmatched '{{' in MLambda expression: {s!r}")
+    if closing != len(s) - 1:
+        raise ValueError(
+            f"Unexpected characters after closing '}}' in: {s!r}"
+        )
+
+    inner = s[2:closing]  # content between ${ and }
+
+    colon_idx = inner.find(":")
+    if colon_idx == -1:
+        raise ValueError(
+            f"Missing ':' separator in MLambda expression: {s!r}\n"
+            "Expected format: ${funref: param_line}"
+        )
+
+    funref = inner[:colon_idx].strip()
+    param_line = inner[colon_idx + 1:]
+
+    if not _FUNREF_RE.match(funref):
+        raise ValueError(
+            f"Invalid function reference {funref!r}. "
+            "Must be an identifier or dotted path (e.g. 'MY_ALIAS' or 'path.to.func')."
+        )
+
+    return funref, param_line
+
+
+@dataclass(frozen=True, slots=True)
+class MLambdaParser:
+    mlambda: MLambda
+    arguments: Arguments
+
+    @staticmethod
+    def cast(raw: str, disable_autoinfer: bool = False) -> MLAMBDA_TYPES:
+        """
+        Parse a raw token string, applying an optional '::type' suffix.
+
+        Examples:
+            "hello"        -> "hello"   (str)
+            "42::int"      -> 42        (int)
+            "3.14::float"  -> 3.14      (float)
+            "true::bool"   -> True      (bool)
+        """
+        raw = raw.strip()
+        # Early exit for None values IF autoinfer is enabled
+        if not disable_autoinfer and raw.lower() in ("null", "none", ""):
+            return None
+        # Check for explicit type annotation
+        if "::" in raw:
+            value_part, _, type_name = raw.rpartition("::")
+            caster = _TYPE_CASTERS.get(type_name.strip())
+            if caster is None:
+                raise ValueError(
+                    f"Unknown type annotation '{type_name}'. "
+                    f"Supported: {list(_TYPE_CASTERS)}"
+                )
+            return caster(value_part.strip())
+        if not disable_autoinfer and raw.isdigit():
+            return int(raw)
+        if not disable_autoinfer and raw.replace(".", "", 1).isdigit():
+            return float(raw)
+        if not disable_autoinfer and raw.lower() in ("true", "false"):
+            return raw.lower() == "true"
+        return raw
+
+    @classmethod
+    def parse_line(cls, param_line: str) -> tuple[list[MLAMBDA_TYPES], dict[str, MLAMBDA_TYPES]]:
+        """
+        Split a CSV-like parameter string into positional args and keyword args.
+
+        The CSV reader handles:
+        - Comma-separated tokens
+        - Quoted values (e.g. "hello, world" treated as a single token)
+
+        Each token is classified as:
+        - kwarg if it contains '=' (first '=' is the separator)
+        - positional arg otherwise
+
+        Type coercion via '::type' is applied to every value.
+        """
+        args: list[MLAMBDA_TYPES] = []
+        kwargs: dict[str, MLAMBDA_TYPES] = {}
+
+        if not param_line.strip():
+            return args, kwargs
+
+        reader = csv.reader(io.StringIO(param_line), skipinitialspace=True)
+        for row in reader:
+            for token in row:
+                token = token.strip()
+                if not token:
+                    continue
+                if "=" in token:
+                    key, _, raw_value = token.partition("=")
+                    kwargs[key.strip()] = cls.cast(raw_value)
+                else:
+                    args.append(cls.cast(token))
+
+        return args, kwargs
+
+    @classmethod
+    def _resolve_nested(cls, param_line: str) -> str:
+        """
+        Resolve all nested ${...} expressions within a param_line string,
+        evaluating innermost expressions first and working outward.
+
+        For each iteration, _INNER_PATTERN finds expressions with no nested
+        braces (guaranteed to be fully flat), evaluates them via from_string,
+        and serializes the result back as a plain token string.  Repeats until
+        no ${...} remain.
+
+        Example:
+            "${RAND: alice, bob, carol}"
+            -> (evaluates RAND) -> "alice"
+
+            "${STROPS: ${RAND: hello, world}, upper}"
+            -> pass 1: "${RAND: hello, world}" -> "world"
+            -> param becomes "world, upper" (no more ${)
+            -> parse_line sees: args=["world"], kwargs={"upper": ...}
+            ... Wait: that's positional, so: args=["world", "upper"]
+        """
+        while "${" in param_line:
+            resolved = _INNER_PATTERN.sub(
+                lambda m: _serialize(cls.from_string(m.group(0)).execute()),
+                param_line,
+            )
+            if resolved == param_line:
+                # No substitution made — malformed inner expression
+                raise ValueError(
+                    f"Could not resolve nested MLambda expression in: {param_line!r}"
+                )
+            param_line = resolved
+        return param_line
+
+    @classmethod
+    def from_string(cls, string: str) -> "MLambdaParser":
+        """
+        Parse a (potentially nested) MLambda expression string.
+
+        Supports expressions at arbitrary nesting depth, e.g.:
+            ${COUNT: ${RAND: alice, bob, carol}}
+            ${STROPS: ${RAND: hello, world}, upper}
+            ${A: ${B: ${C: x}}}
+        """
+        payload = string.strip()
+
+        # Step 1: extract the outer ${funref: raw_param_line} shell
+        # using a stack-based approach that correctly handles nested '}'
+        funref, raw_param_line = _extract_outer(payload)
+
+        # Step 2: resolve any nested ${...} within the param_line
+        resolved_param_line = cls._resolve_nested(raw_param_line)
+
+        # Step 3: parse the now-flat param_line
+        args, kwargs = cls.parse_line(resolved_param_line)
+        arguments = Arguments(args=args, kwargs=kwargs)
+
+        # Step 4: resolve the function reference
+        if "." not in funref:
+            # Bare alias — look up in catalog / settings
+            return cls(
+                mlambda=MLambdaCatalog.get_or_create(funref, fail=True),
+                arguments=arguments,
+            )
+        # Dotted path — construct MLambda directly
+        import_pattern, fname = funref.rsplit(".", 1)
+        return cls(
+            mlambda=MLambda(name=fname, import_pattern=import_pattern),
+            arguments=arguments,
+        )
+
+    def execute(self) -> Any:
+        return self.mlambda.run(arguments=self.arguments)

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred/mlambda/settings.py

@@ -1,18 +1,16 @@
 import os
 
-from fred.settings import get_environ_variable
 
-
-FRED_MLAMBDA_ALIASES_SEP = get_environ_variable(
+FRED_MLAMBDA_ALIASES_SEP = os.environ.get(
     "FRED_MLAMBDA_ALIASES_SEP",
-    default=";"
+    ";",
 )
 
 FRED_MLAMBDA_ALIASES = [
     alias
-    for line in get_environ_variable(
+    for line in os.environ.get(
         "FRED_MLAMBDA_ALIASES",
-        default="",
+        "",
     ).split(FRED_MLAMBDA_ALIASES_SEP)
     if "=" in line and (alias := line.strip().split("="))
 ]

fred_mlambda-0.4.0/src/main/fred/mlambda/version

@@ -0,0 +1 @@
+0.4.0

fred_mlambda-0.4.0/src/main/fred/mlambda/version.py

@@ -0,0 +1,46 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Version:
+    name: str
+    value: str
+
+    def components(self, as_int: bool = False) -> list:
+        return [int(val) if as_int else val for val in self.value.split(".")]
+
+    @property
+    def major(self) -> int:
+        component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def minor(self) -> int:
+        _, component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def patch(self) -> int:
+        *_, component = self.components(as_int=True)
+        return component
+
+    @classmethod
+    def from_path(cls, dirpath: str, name: str):
+        for file in os.listdir(dirpath):
+            if file.lower().endswith("version"):
+                filepath = os.path.join(dirpath, file)
+                break
+        else:
+            raise ValueError("Version file not found for package name: " + name)
+
+        with open(filepath, "r") as version_file:
+            version_value = version_file.readline().strip()  # TODO: Validate version pattern via regex
+            return cls(name=name, value=version_value)
+
+
+try:
+    version = Version.from_path(name="fred.mlambda", dirpath=os.path.dirname(__file__))
+except Exception:
+    print("Version file not found for package name: fred.mlambda, using 0.0.0")
+    version = Version(name="fred.mlambda", value="0.0.0")

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0/src/main/fred.mlambda.egg-info}/PKG-INFO

@@ -1,19 +1,17 @@
 Metadata-Version: 2.4
 Name: fred.mlambda
-Version: 0.2.0
+Version: 0.4.0
 Summary: FRED-MLAMBDA
 Home-page: https://fred.fhr.tools
 Author: Fahera Research, Education, and Development
 Author-email: fred@fahera.mx
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: fred-oss==0.66.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
-Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{fred_mlambda-0.2.0 → fred_mlambda-0.4.0}/src/main/fred.mlambda.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ src/main/fred.mlambda.egg-info/PKG-INFO
 src/main/fred.mlambda.egg-info/SOURCES.txt
 src/main/fred.mlambda.egg-info/dependency_links.txt
 src/main/fred.mlambda.egg-info/entry_points.txt
-src/main/fred.mlambda.egg-info/requires.txt
 src/main/fred.mlambda.egg-info/top_level.txt
 src/main/fred/mlambda/__init__.py
 src/main/fred/mlambda/_count.py

fred_mlambda-0.2.0/requirements.txt

@@ -1,2 +0,0 @@
-# Install the baseline fred-oss package
-fred-oss==0.66.0

fred_mlambda-0.2.0/src/main/fred/mlambda/parser.py

@@ -1,137 +0,0 @@
-import re
-import io
-import csv
-from dataclasses import dataclass
-from typing import Any, Callable, Union, Optional
-
-from fred.mlambda.interface import Arguments, MLambda
-from fred.mlambda.catalog import MLambdaCatalog
-
-# Matches: ${path.to.function: param_line}
-# Group 1 (dotpath):   "path.to.function"
-# Group 2 (param_line): "arg1,arg2,kwarg1=value1,..."
-_MLAMBDA_PATTERN = re.compile(
-    r"^\$\{\s*(?P<funref>[A-Za-z_][A-Za-z0-9_.]*)\s*:\s*(?P<param_line>[^}]*)\}$"
-)
-
-# Supported type annotations via the "::" syntax, e.g. "42::int"
-MLAMBDA_TYPES = Optional[Union[int, float, bool, str]]
-_NULL_VALUES = ("null", "none", "")
-_TYPE_CASTERS: dict[str, Callable] = {
-    "int": int,
-    "float": float,
-    "bool": lambda v: v.strip().lower() not in ("false", "0", "no", ""),
-    "str": str,
-}
-
-
-@dataclass(frozen=True, slots=True)
-class MLambdaParser:
-    mlambda: MLambda
-    arguments: Arguments
-
-    @staticmethod
-    def cast(raw: str, disable_autoinfer: bool = False) -> MLAMBDA_TYPES:
-        """
-        Parse a raw token string, applying an optional '::type' suffix.
-
-        Examples:
-            "hello"        -> "hello"   (str)
-            "42::int"      -> 42        (int)
-            "3.14::float"  -> 3.14      (float)
-            "true::bool"   -> True      (bool)
-        """
-        raw = raw.strip()
-        # Early exit for None values IF autoinfer is enabled
-        if not disable_autoinfer and raw.lower() in ("null", "none", ""):
-            return None
-        # Check for type annotation
-        if "::" in raw:
-            value_part, _, type_name = raw.rpartition("::")
-            caster = _TYPE_CASTERS.get(type_name.strip())
-            if caster is None:
-                raise ValueError(
-                    f"Unknown type annotation '{type_name}'. "
-                    f"Supported: {list(_TYPE_CASTERS)}"
-                )
-            return caster(value_part.strip())
-        if not disable_autoinfer and raw.isdigit():
-            return int(raw)
-        if not disable_autoinfer and raw.replace(".", "", 1).isdigit():
-            return float(raw)
-        if not disable_autoinfer and raw.lower() in ("true", "false"):
-            return raw.lower() == "true"
-        return raw
-
-    @classmethod
-    def parse_line(cls, param_line: str) -> tuple[list[MLAMBDA_TYPES], dict[str, MLAMBDA_TYPES]]:
-        """
-        Split a CSV-like parameter string into positional args and keyword args.
-
-        The CSV reader handles:
-        - Comma-separated tokens
-        - Quoted values (e.g. "hello, world" treated as a single token)
-
-        Each token is classified as:
-        - kwarg if it contains '=' (first '=' is the separator)
-        - positional arg otherwise
-
-        Type coercion via '::type' is applied to every value.
-        """
-        args: list[MLAMBDA_TYPES] = []
-        kwargs: dict[str, MLAMBDA_TYPES] = {}
-
-        if not param_line.strip():
-            return args, kwargs
-
-        reader = csv.reader(io.StringIO(param_line), skipinitialspace=True)
-        for row in reader:
-            for token in row:
-                token = token.strip()
-                if not token:
-                    continue
-                if "=" in token:
-                    key, _, raw_value = token.partition("=")
-                    kwargs[key.strip()] = cls.cast(raw_value)
-                else:
-                    args.append(cls.cast(token))
-
-        return args, kwargs
-
-    @classmethod
-    def from_string(cls, string: str) -> "MLambdaParser":
-        payload = string.strip()
-
-        match = _MLAMBDA_PATTERN.match(payload)
-        if not match:
-            raise ValueError(
-                f"Invalid MLambda expression: {payload!r}\n"
-                "Expected format: ${path.to.function: arg1,arg2,kwarg1=value1,...}"
-            )
-        # Get the function reference and param_line from the match
-        funref: str = match.group("funref")
-        param_line: str = match.group("param_line")
-        # Parse the CSV-like parameter line
-        args, kwargs = cls.parse_line(param_line)
-        arguments = Arguments(
-            args=args,
-            kwargs=kwargs,
-        )
-        # If the function reference is an alias, get the MLambda from the catalog
-        if "." not in funref:
-            return cls(
-                mlambda=MLambdaCatalog.get_or_create(funref, fail=True),
-                arguments=arguments,
-            )
-        # Split "path.to.function" -> import_pattern="path.to", fname="function"
-        import_pattern, fname = funref.rsplit(".", 1)
-        return cls(
-            mlambda=MLambda(
-                name=fname,
-                import_pattern=import_pattern
-            ),
-            arguments=arguments,
-        )
-
-    def execute(self) -> Any:
-        return self.mlambda.run(arguments=self.arguments)

fred_mlambda-0.2.0/src/main/fred/mlambda/version

@@ -1 +0,0 @@
-0.2.0

fred_mlambda-0.2.0/src/main/fred/mlambda/version.py

@@ -1,9 +0,0 @@
-import os
-
-from fred.version import Version
-
-
-version = Version.from_path(
-    name="fred.mlambda",
-    dirpath=os.path.dirname(__file__)
-)

fred_mlambda-0.2.0/src/main/fred.mlambda.egg-info/requires.txt

@@ -1 +0,0 @@
-fred-oss==0.66.0