fred.mlambda 0.4.0__py3-none-any.whl

fred/mlambda/_count.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def count(value: Any, fail: bool = False) -> int:
+    if hasattr(value, "__len__"):
+        return len(value)
+    from collections.abc import Sized
+    if isinstance(value, Sized):
+        return len(value)
+    error = f"Unknown type: {type(value)}"
+    if fail:
+        raise ValueError(error)
+    return 0

fred/mlambda/_rand.py

@@ -0,0 +1,12 @@
+import random
+from typing import Any
+
+
+def rand(*args, k=1, disable_autoflat: bool = False) -> list[Any]:
+    if not disable_autoflat and k == 1:
+        out, *_ = rand(*args, k=k, disable_autoflat=True)
+        return out
+    return random.choices(
+        population=args,
+        k=k,
+    )

fred/mlambda/_strops.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+
+def strops(string: str, ops: str, fail: bool = False) -> Optional[str]:
+    match ops:
+        case "lower":
+            return string.lower()
+        case "upper":
+            return string.upper()
+        case "title":
+            return string.title()
+        case "capitalize":
+            return string.capitalize()
+        case "strip":
+            return string.strip()
+        case "lstrip":
+            return string.lstrip()
+        case "rstrip":
+            return string.rstrip()
+        case _:
+            msg = f"Unknown operation: {ops}"
+            if fail:
+                raise ValueError(msg)
+            return None

fred/mlambda/catalog.py

@@ -0,0 +1,57 @@
+from enum import Enum
+from typing import Optional
+
+from fred.mlambda.settings import FRED_MLAMBDA_PARSED_ALIASES
+from fred.mlambda.interface import MLambda
+
+
+class MLambdaCatalog(Enum):
+    STROPS = MLambda(
+        name="strops",
+        import_pattern="fred.mlambda._strops",
+    )
+    RAND = MLambda(
+        name="rand",
+        import_pattern="fred.mlambda._rand",
+    )
+
+    @classmethod
+    def keys(cls) -> list[str]:
+        return [
+            mem.name
+            for mem in cls
+        ]
+
+    @classmethod
+    def get_or_create(cls, target: str, fail: bool = False) -> Optional[MLambda]:
+        if "." in target:
+            *import_path, function_name = target.split(".")
+            return MLambda(
+                name=function_name,
+                import_pattern=".".join(import_path),
+            )
+        return cls.find(
+            alias=target,
+            fail=fail,
+        )
+
+    @classmethod
+    def find(cls, alias: str, fail: bool = False, disable_variants: bool = False) -> Optional[MLambda]:
+        if "." in alias:
+            return None
+        variants: list[str] = [alias, alias.upper(), alias.lower()]
+        for variant in variants[:(1 if disable_variants else len(variants))]:
+            # Check if the target is an alias registered in the environment or defaults
+            if variant in FRED_MLAMBDA_PARSED_ALIASES:
+                *import_path, function_name = FRED_MLAMBDA_PARSED_ALIASES[variant].split(".")
+                return MLambda(
+                    name=function_name,
+                    import_pattern=".".join(import_path),
+                )
+            # Check if the alias is a registered MLambdaCatalog Enum
+            elif variant in cls.keys():
+                return cls[variant].value
+        error = f"Unknown MLambda: {alias}"
+        if fail:
+            raise ValueError(error)
+        return None

fred/mlambda/interface.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass(frozen=True, slots=True)
+class Arguments:
+    args: list
+    kwargs: dict
+
+
+@dataclass(frozen=True, slots=True)
+class MLambda:
+    name: str
+    import_pattern: str
+
+    @property
+    def function(self) -> Callable:
+        import importlib
+        # Import the module
+        module = importlib.import_module(self.import_pattern)
+        # Get the function from the module
+        if not (fn := getattr(module, self.name, None)):
+            raise ValueError(f"Function {self.name} not found in module {self.import_pattern}")
+        return fn
+
+    def run(self, arguments: Arguments):
+        return self.function(*arguments.args, **arguments.kwargs)
+
+    def __call__(self, *args, **kwargs):
+        arguments = Arguments(
+            args=args,
+            kwargs=kwargs
+        )
+        return self.run(
+            arguments=arguments
+        )

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/settings.py

@@ -0,0 +1,24 @@
+import os
+
+
+FRED_MLAMBDA_ALIASES_SEP = os.environ.get(
+    "FRED_MLAMBDA_ALIASES_SEP",
+    ";",
+)
+
+FRED_MLAMBDA_ALIASES = [
+    alias
+    for line in os.environ.get(
+        "FRED_MLAMBDA_ALIASES",
+        "",
+    ).split(FRED_MLAMBDA_ALIASES_SEP)
+    if "=" in line and (alias := line.strip().split("="))
+]
+
+FRED_MLAMBDA_PARSED_ALIASES = {
+    "count": "fred.mlambda._count.count",
+    **{
+        key: val
+        for key, val in FRED_MLAMBDA_ALIASES
+    }
+}

fred/mlambda/version

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

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.4.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: fred.mlambda
+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
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# FRED MLAMBDA

fred_mlambda-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+fred/mlambda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fred/mlambda/_count.py,sha256=nm9FYAPJoQkbfLfyfKGCaUUcaAmGBRYomdPt5sJuLbA,333
+fred/mlambda/_rand.py,sha256=413iDWAK70Wf-5i4C_EFNPaW90WXh7UWAqUmAFQPKZw,294
+fred/mlambda/_strops.py,sha256=oGWM_5vgQcykojxNFOYkF-644R6pTY0sfBOMUtpYCzA,668
+fred/mlambda/catalog.py,sha256=db2a6-973eMv_bd5gA87_u6dIBx7JFH_hSW3tTZrtQk,1873
+fred/mlambda/interface.py,sha256=sc9gHHWUZyc8HtOWkTPHN4_oH6Tr_o4J20WSipq4zBg,927
+fred/mlambda/parser.py,sha256=NwzIEvA__Ly9c02GKnY5M8AHafve6KJSLuZ3cjxOBKM,8620
+fred/mlambda/settings.py,sha256=x5mLnvXI9w1pqyhgvhgwqbwoyqCkY5dPCX0j9hhqquA,461
+fred/mlambda/version,sha256=zXhTTtFa1GkStxM50UF9DQQ9gwnCuUQV8-0bnR_frtA,5
+fred/mlambda/version.py,sha256=pfhriCzyq166o5KVK2r44i0TY90iqC3l4jOjUHIN90c,1417
+fred_mlambda-0.4.0.dist-info/METADATA,sha256=ADNdHstgRBWmSFTa4z4jTuNv2F0tM9HzBvbs9rBU30g,427
+fred_mlambda-0.4.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fred_mlambda-0.4.0.dist-info/entry_points.txt,sha256=vxpaOh6wOm4RgK0O1sG3_9DGUH9bsJFImbnShS-BUas,68
+fred_mlambda-0.4.0.dist-info/top_level.txt,sha256=amdkZ5b-sD33wi769YgrltKPSlpOVT-7V5pBT3wWcb4,5
+fred_mlambda-0.4.0.dist-info/RECORD,,

fred_mlambda-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fred_mlambda-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fred-mlambda = fred.mlambda.cli.main:CLI.cli_exec

fred_mlambda-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fred