morphir-python 0.0.1__py3-none-any.whl

morphir/ir/v4/decorations.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SchemaRef:
+    display_name: str
+    local_path: str
+    entry_point: str  # FQName as string for simplicity in meta structures
+    description: str | None = None
+    remote_ref: str | None = None
+    cached_at: str | None = None
+
+
+@dataclass(frozen=True)
+class DecorationFormat:
+    format_version: str
+    schema_registry: dict[str, SchemaRef] = field(default_factory=dict)
+    layers: list[str] = field(default_factory=list)
+    layer_priority: dict[str, int] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class LayerManifest:
+    format_version: str
+    layer: str
+    display_name: str
+    priority: int
+    created_at: str
+    updated_at: str
+    description: str | None = None
+    decoration_types: list[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class DecorationValuesFile:
+    format_version: str
+    decoration_type: str
+    layer: str
+    values: dict[str, Any] = field(default_factory=dict)  # Key is FQName string
+
+
+def deep_merge(base: Any, override: Any) -> Any:
+    """Deep merge two values.
+
+    - If both are dicts, merge recursively.
+    - If both are lists, concatenate (override extends base).
+    - Otherwise, override wins.
+    """
+    if isinstance(base, dict) and isinstance(override, dict):
+        merged = base.copy()
+        for k, v in override.items():
+            if k in merged:
+                merged[k] = deep_merge(merged[k], v)
+            else:
+                merged[k] = v
+        return merged
+    elif isinstance(base, list) and isinstance(override, list):
+        return base + override
+    else:
+        return override
+
+
+def merge_decoration_values(layers: list[tuple[int, dict[str, Any]]]) -> dict[str, Any]:
+    """Merge decoration values from multiple layers based on priority.
+
+    Args:
+        layers: List of (priority, values_dict) tuples.
+
+    Returns:
+        Merged dictionary of decoration values.
+    """
+    # Sort by priority (ascending) -> processed in order, so higher priority overrides later
+    # Wait, simple override logic usually means last one wins.
+    # If priority 0 is base, and 100 is override, then 0 should be processed first, then 100 merged on top.
+    # So ascending sort is correct for standard "last write wins" merge logic.
+    sorted_layers = sorted(layers, key=lambda x: x[0])
+
+    merged: dict[str, Any] = {}
+
+    for _, values in sorted_layers:
+        for key, value in values.items():
+            if key in merged:
+                merged[key] = deep_merge(merged[key], value)
+            else:
+                merged[key] = value
+
+    return merged

morphir/ir/v4/distribution.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Union
+
+from .documented import Documented
+from .fqname import FQName
+from .name import Name
+from .package import Definition as PackageDefinition
+from .package import Specification as PackageSpecification
+from .path import Path
+
+
+@dataclass(frozen=True)
+class PackageInfo:
+    name: Path
+    version: str | None = None
+
+
+@dataclass(frozen=True)
+class LibraryDistribution:
+    package: PackageInfo
+    definition: PackageDefinition
+    dependencies: dict[Path, PackageSpecification] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SpecsDistribution:
+    package: PackageInfo
+    specification: PackageSpecification
+    dependencies: dict[Path, PackageSpecification] = field(default_factory=dict)
+
+
+class EntryPointKind(Enum):
+    Main = "Main"
+    Command = "Command"
+    Handler = "Handler"
+    Job = "Job"
+    Policy = "Policy"
+
+
+@dataclass(frozen=True)
+class EntryPoint:
+    target: FQName
+    kind: EntryPointKind
+    doc: Documented[str] | None = None
+
+
+@dataclass(frozen=True)
+class ApplicationDistribution:
+    package: PackageInfo
+    definition: PackageDefinition
+    dependencies: dict[Path, PackageDefinition] = field(default_factory=dict)
+    entry_points: dict[Name, EntryPoint] = field(default_factory=dict)
+
+
+Distribution = Union[LibraryDistribution, SpecsDistribution, ApplicationDistribution]

morphir/ir/v4/document.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from typing import Union
+
+
+@dataclass(frozen=True)
+class DocNull:
+    pass
+
+
+@dataclass(frozen=True)
+class DocBool:
+    value: bool
+
+
+@dataclass(frozen=True)
+class DocInt:
+    value: int
+
+
+@dataclass(frozen=True)
+class DocFloat:
+    value: float
+
+
+@dataclass(frozen=True)
+class DocString:
+    value: str
+
+
+# Forward references for recursive types
+@dataclass(frozen=True)
+class DocArray:
+    elements: list[Document]
+
+
+@dataclass(frozen=True)
+class DocObject:
+    fields: dict[str, Document]
+
+
+Document = Union[DocNull, DocBool, DocInt, DocFloat, DocString, DocArray, DocObject]
+
+
+def null() -> Document:
+    return DocNull()
+
+
+def bool_(value: bool) -> Document:
+    return DocBool(value)
+
+
+def int_(value: int) -> Document:
+    return DocInt(value)
+
+
+def float_(value: float) -> Document:
+    return DocFloat(value)
+
+
+def string(value: str) -> Document:
+    return DocString(value)
+
+
+def array(elements: list[Document]) -> Document:
+    return DocArray(elements)
+
+
+def object_(fields: dict[str, Document]) -> Document:
+    return DocObject(fields)

morphir/ir/v4/documented.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class Documented(Generic[T]):
+    doc: str | None
+    value: T

morphir/ir/v4/fqname.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+
+from . import name, path
+from .name import Name
+from .path import Path
+from .qname import QName
+
+
+@dataclass(frozen=True)
+class FQName:
+    package_path: Path
+    module_path: Path
+    local_name: Name
+
+    @staticmethod
+    def from_qname(package_path: Path, qn: QName) -> FQName:
+        return FQName(package_path, qn.module_path, qn.local_name)
+
+    @staticmethod
+    def from_tuple(t: tuple[Path, Path, Name]) -> FQName:
+        return FQName(t[0], t[1], t[2])
+
+    def to_tuple(self) -> tuple[Path, Path, Name]:
+        return (self.package_path, self.module_path, self.local_name)
+
+    @staticmethod
+    def fqn(package_str: str, module_str: str, local_str: str) -> FQName:
+        return FQName(
+            path.from_string(package_str),
+            path.from_string(module_str),
+            name.from_string(local_str),
+        )
+
+    @staticmethod
+    def from_string(s: str) -> FQName:
+        # Parse canonical format: PackagePath:ModulePath#LocalName
+        import re
+
+        match = re.search(r"^([^:]+):([^#]+)#(.+)$", s)
+        if match:
+            pkg_str, mod_str, local_str = match.groups()
+            return FQName(
+                path.from_string(pkg_str),
+                path.from_string(mod_str),
+                name.from_string(local_str),
+            )
+
+        # Legacy/Fallback: Package.Module.Local or Package:Module:Local
+        # Attempt minimal parsing if canonical fails
+        # Assuming last part after separator is local name
+        if "#" not in s:
+            # if no hash, maybe using colon?
+            parts = s.split(":")
+            if len(parts) == 3:
+                return FQName(
+                    path.from_string(parts[0]),
+                    path.from_string(parts[1]),
+                    name.from_string(parts[2]),
+                )
+
+        # Return empty/default if totally unparseable
+        return FQName(path.from_string(""), path.from_string(""), name.from_string(s))
+
+    def to_string(self) -> str:
+        # Canonical: PackagePath:ModulePath#LocalName
+        package_str = path.to_string(self.package_path)  # defaults to /
+        module_str = path.to_string(self.module_path)
+        local_str = name.to_kebab_case(self.local_name)
+        return f"{package_str}:{module_str}#{local_str}"

morphir/ir/v4/incompleteness.py

@@ -0,0 +1,78 @@
+"""Incompleteness: why a type or value definition is not complete yet.
+
+Follows the finos/morphir v4 schema (``Incompleteness``, ``HoleReason``) at the
+pinned commit and the morphir-rust v4 model. A hole names its reason; a draft is
+work in progress and names none.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Union
+
+from .fqname import FQName
+from .type import Type
+
+
+@dataclass(frozen=True)
+class UnresolvedReference:
+    """A reference that could not be resolved.
+
+    Attributes:
+        target: The name that did not resolve.
+    """
+
+    target: FQName
+
+
+@dataclass(frozen=True)
+class DeletedDuringRefactor:
+    """A reference removed by a refactoring.
+
+    Attributes:
+        tx_id: The transaction id of the refactoring (JSON member ``tx-id``).
+    """
+
+    tx_id: str
+
+
+@dataclass(frozen=True)
+class TypeMismatch:
+    """Type checking failed.
+
+    Attributes:
+        expected: A description of the expected type.
+        found: A description of the type found.
+    """
+
+    expected: str
+    found: str
+
+
+HoleReason = Union[UnresolvedReference, DeletedDuringRefactor, TypeMismatch]
+"""Why a hole exists. ``Draft`` is an incompleteness, not a hole reason."""
+
+
+@dataclass(frozen=True)
+class HoleIncompleteness:
+    """A definition with a hole.
+
+    Attributes:
+        reason: Why the hole exists.
+        partial_body: The type the author had written when the definition stopped
+            being complete, if any. The schema gives this member the type
+            ``Type``; an incomplete value keeps its partial expression on
+            `IncompleteBody.partial_body` instead.
+    """
+
+    reason: HoleReason
+    partial_body: Type | None = None
+
+
+@dataclass(frozen=True)
+class DraftIncompleteness:
+    """A definition the author marked as work in progress."""
+
+
+Incompleteness = Union[HoleIncompleteness, DraftIncompleteness]
+"""Why a definition is incomplete: a hole or a draft."""

morphir/ir/v4/json.py

@@ -0,0 +1,103 @@
+from dataclasses import fields, is_dataclass
+from typing import Any
+
+from .decorations import (
+    DecorationFormat,
+    DecorationValuesFile,
+    LayerManifest,
+    SchemaRef,
+)
+from .distribution import PackageInfo
+from .document import DocArray, DocBool, DocFloat, DocInt, DocNull, DocObject, DocString
+from .fqname import FQName
+from .literal import (
+    BoolLiteral,
+    CharLiteral,
+    DecimalLiteral,
+    DocumentLiteral,
+    FloatLiteral,
+    IntegerLiteral,
+    StringLiteral,
+)
+from .name import Name
+from .name import to_string as name_to_string
+from .path import Path
+from .path import to_string as path_to_string
+
+# Placeholder for full implementation.
+# This will eventually contain robust encoders/decoders for all IR types.
+
+
+class MorphirJSONEncoder:
+    def encode(self, obj: Any) -> Any:
+        if isinstance(obj, Name):
+            return name_to_string(obj)
+        if isinstance(obj, Path):
+            return path_to_string(obj)
+        if isinstance(obj, FQName):
+            return obj.to_string()
+        if isinstance(obj, PackageInfo):
+            return {"name": path_to_string(obj.name), "version": obj.version}
+
+        # Decorations Encoding (Basic Dataclass Support handles these mostly, but explicit checks help)
+        if is_dataclass(obj) and isinstance(
+            obj, (DecorationFormat, LayerManifest, DecorationValuesFile, SchemaRef)
+        ):
+            # Use standard dataclass conversion but recursively encode values
+            return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)}
+
+        # Document Encoding
+        if isinstance(obj, DocNull):
+            return {"DocNull": {}}
+        if isinstance(obj, DocBool):
+            return {"DocBool": obj.value}
+        if isinstance(obj, DocInt):
+            return {"DocInt": obj.value}
+        if isinstance(obj, DocFloat):
+            return {"DocFloat": obj.value}
+        if isinstance(obj, DocString):
+            return {"DocString": obj.value}
+        if isinstance(obj, DocArray):
+            return {"DocArray": [self.encode(elem) for elem in obj.elements]}
+        if isinstance(obj, DocObject):
+            return {"DocObject": {k: self.encode(v) for k, v in obj.fields.items()}}
+
+        # Literal Encoding
+        if isinstance(
+            obj,
+            (
+                BoolLiteral,
+                CharLiteral,
+                StringLiteral,
+                IntegerLiteral,
+                FloatLiteral,
+                DecimalLiteral,
+            ),
+        ):
+            # { "IntegerLiteral": { "value": 42 } }
+            type_name = type(obj).__name__
+            return {
+                type_name: {
+                    "value": obj.value
+                    if not isinstance(obj, DecimalLiteral)
+                    else str(obj.value)
+                }
+            }
+        if isinstance(obj, DocumentLiteral):
+            # DocumentLiteral wraps a Document
+            return {"DocumentLiteral": {"value": self.encode(obj.value)}}
+        if is_dataclass(obj):
+            # Generic fallback for simple dataclasses
+            # Real implementation needs to handle tagged unions (Value, Type, Pattern) specifically
+            return {f.name: self.encode(getattr(obj, f.name)) for f in fields(obj)}
+
+        if isinstance(obj, list):
+            return [self.encode(item) for item in obj]
+        if isinstance(obj, dict):
+            return {k: self.encode(v) for k, v in obj.items()}
+
+        return obj
+
+
+def encode(obj: Any) -> Any:
+    return MorphirJSONEncoder().encode(obj)

morphir/ir/v4/literal.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Union
+
+from .document import Document
+
+
+@dataclass(frozen=True)
+class BoolLiteral:
+    value: bool
+
+
+@dataclass(frozen=True)
+class CharLiteral:
+    value: str
+
+
+@dataclass(frozen=True)
+class StringLiteral:
+    value: str
+
+
+@dataclass(frozen=True)
+class IntegerLiteral:
+    value: int
+
+
+@dataclass(frozen=True)
+class FloatLiteral:
+    value: float
+
+
+@dataclass(frozen=True)
+class DecimalLiteral:
+    value: Decimal
+
+
+@dataclass(frozen=True)
+class DocumentLiteral:
+    value: Document
+
+
+Literal = Union[
+    BoolLiteral,
+    CharLiteral,
+    StringLiteral,
+    IntegerLiteral,
+    FloatLiteral,
+    DecimalLiteral,
+    DocumentLiteral,
+]

morphir/ir/v4/meta.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SourceRange:
+    start: tuple[int, int]
+    end: tuple[int, int]
+
+
+@dataclass(frozen=True)
+class FileMeta:
+    # Provenance
+    source: str | None = None
+    source_range: SourceRange | None = None
+    compiler: str | None = None
+    generated: str | None = None  # ISO 8601
+    checksum: str | None = None
+
+    # Tooling
+    edited_by: str | None = None
+    edited_at: str | None = None  # ISO 8601
+    locked: bool | None = None
+    is_generated: bool | None = None
+
+    # Extensions
+    extensions: dict[str, Any] = field(default_factory=dict)

morphir/ir/v4/module.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass, field
+
+from . import type_def, type_spec, value
+from .access_controlled import AccessControlled
+from .annotation import Annotation
+from .documented import Documented
+from .name import Name
+from .path import Path
+
+ModuleName = Path
+QualifiedModuleName = tuple[Path, Path]
+
+
+@dataclass(frozen=True)
+class Specification:
+    types: dict[Name, Documented[type_spec.Specification]] = field(default_factory=dict)
+    values: dict[Name, Documented[value.Specification]] = field(default_factory=dict)
+    doc: str | None = None
+    annotations: list[Annotation] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Definition:
+    types: dict[Name, AccessControlled[Documented[type_def.Definition]]] = field(
+        default_factory=dict
+    )
+    values: dict[Name, AccessControlled[Documented[value.ValueDefinitionBody]]] = field(
+        default_factory=dict
+    )
+    doc: str | None = None

morphir/ir/v4/name.py

@@ -0,0 +1,69 @@
+import re
+
+
+class Name(tuple[str, ...]):
+    pass
+
+
+def from_list(words: list[str]) -> Name:
+    return Name(tuple(word.lower() for word in words))
+
+
+def to_list(name: Name) -> list[str]:
+    return list(name)
+
+
+def from_string(s: str) -> Name:
+    # Split by common delimiters including those used in FQName (colon, hash)
+    # IR v4 canonical is kebab-case (hyphens).
+    # Also handle underscores (snake_case), dots (paths), spaces, colons, hashes.
+    words = re.split(r"[_\-\s\.:#]", s)
+    # Filter empty strings
+    words = [w for w in words if w]
+
+    result = []
+    for word in words:
+        # Split camelCase / PascalCase / Acronyms
+        # Regex explanation:
+        # 1. [A-Z]+(?=[A-Z][a-z]) : Acronym followed by Capitalized word (e.g. JSON in JSONResponse)
+        # 2. [A-Z][a-z0-9]+       : Capitalized word with at least one lowercase/digit (e.g. Response)
+        # 3. [A-Z]+               : Acronym at end or isolated (e.g. SDK, ID in MakeID)
+        # 4. [a-z][a-z0-9]*       : Lowercase word
+        # 5. [0-9]+               : Numbers
+        parts = re.findall(
+            r"[A-Z]+(?=[A-Z][a-z])|[A-Z][a-z0-9]+|[A-Z]+|[a-z][a-z0-9]*|[0-9]+", word
+        )
+
+        if not parts:
+            parts = [word]  # fallback
+
+        for part in parts:
+            result.append(part.lower())
+
+    return Name(tuple(result))
+
+
+def to_title_case(name: Name) -> str:
+    return "".join(word.capitalize() for word in name)
+
+
+def to_camel_case(name: Name) -> str:
+    if not name:
+        return ""
+    return name[0] + "".join(word.capitalize() for word in name[1:])
+
+
+def to_snake_case(name: Name) -> str:
+    return "_".join(name)
+
+
+def to_kebab_case(name: Name) -> str:
+    return "-".join(name)
+
+
+def to_string(name: Name) -> str:
+    return to_kebab_case(name)
+
+
+def to_human_words(name: Name) -> list[str]:
+    return list(name)

morphir/ir/v4/package.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+
+from . import module
+from .access_controlled import AccessControlled
+from .path import Path
+
+PackageName = Path
+
+
+@dataclass(frozen=True)
+class Specification:
+    modules: dict[module.ModuleName, module.Specification] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Definition:
+    modules: dict[module.ModuleName, AccessControlled[module.Definition]] = field(
+        default_factory=dict
+    )