morphir-python 0.0.1__py3-none-any.whl

morphir/ir/v4/path.py

@@ -0,0 +1,50 @@
+from .name import Name
+from .name import from_string as name_from_string
+
+
+class Path(tuple[Name, ...]):
+    pass
+
+
+def from_list(names: list[Name]) -> Path:
+    return Path(tuple(names))
+
+
+def to_list(path: Path) -> list[Name]:
+    return list(path)
+
+
+def from_string(s: str) -> Path:
+    if not s:
+        return Path(tuple())
+    # Support both "/" (v4) and "." (legacy) as separators
+    # Use regex split to handle both
+    import re
+
+    parts = re.split(r"[/\.]", s)
+    return Path(tuple(name_from_string(p) for p in parts if p))
+
+
+def to_string(path: Path, separator: str = "/") -> str:
+    # Default separator per IR v4 is "/"
+    from .name import to_kebab_case
+
+    return separator.join(to_kebab_case(name) for name in path)
+
+
+def empty() -> Path:
+    return Path(tuple())
+
+
+def append(path: Path, name: Name) -> Path:
+    return Path(path + (name,))
+
+
+def concat(path1: Path, path2: Path) -> Path:
+    return Path(path1 + path2)
+
+
+def is_prefix_of(prefix: Path, path: Path) -> bool:
+    if len(prefix) > len(path):
+        return False
+    return path[: len(prefix)] == prefix

morphir/ir/v4/qname.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+
+from . import name, path
+from .name import Name
+from .path import Path
+
+
+@dataclass(frozen=True)
+class QName:
+    module_path: Path
+    local_name: Name
+
+    @staticmethod
+    def from_tuple(t: tuple[Path, Name]) -> QName:
+        return QName(t[0], t[1])
+
+    def to_tuple(self) -> tuple[Path, Name]:
+        return (self.module_path, self.local_name)
+
+    @staticmethod
+    def from_name(n: Name) -> QName:
+        return QName(path.empty(), n)
+
+    def to_string(self) -> str:
+        module_str = path.to_string(self.module_path, ".")
+        local_str = name.to_camel_case(self.local_name)
+        return f"{module_str}:{local_str}"
+
+    @staticmethod
+    def from_string(s: str) -> QName:
+        parts = s.split(":")
+        if len(parts) == 2:
+            return QName(path.from_string(parts[0]), name.from_string(parts[1]))
+        return QName(path.empty(), name.from_string(s))

morphir/ir/v4/ref.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar, Union
+
+
+@dataclass(frozen=True)
+class DefRef:
+    """Shorthand reference to an entry in $defs."""
+
+    name: str
+
+
+@dataclass(frozen=True)
+class PointerRef:
+    """Full JSON Pointer reference."""
+
+    pointer: list[str]
+
+    @staticmethod
+    def from_string(pointer_str: str) -> PointerRef:
+        if pointer_str.startswith("#/"):
+            # Remove #/ and split
+            path = pointer_str[2:].split("/")
+            return PointerRef(pointer=path)
+        raise ValueError(f"Invalid pointer string: {pointer_str}")
+
+
+Ref = Union[DefRef, PointerRef]
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class FileWithDefs(Generic[T]):
+    content: T
+    defs: dict[str, Any] = field(default_factory=dict)

morphir/ir/v4/type.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from typing import Union as TUnion
+
+from .fqname import FQName
+from .name import Name
+from .type_constraints import TypeConstraints
+
+
+@dataclass(frozen=True)
+class SourceLocation:
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+
+
+@dataclass(frozen=True)
+class TypeAttributes:
+    source: SourceLocation | None = None
+    constraints: TypeConstraints | None = None
+    extensions: dict[FQName, Any] = field(
+        default_factory=dict
+    )  # Any for extensions due to circular dep with Value
+
+
+EMPTY_TYPE_ATTRIBUTES = TypeAttributes()
+
+
+@dataclass(frozen=True)
+class Variable:
+    attributes: TypeAttributes
+    name: Name
+
+
+@dataclass(frozen=True)
+class Reference:
+    attributes: TypeAttributes
+    fqname: FQName
+    args: list[Type] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Tuple:
+    attributes: TypeAttributes
+    elements: list[Type] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Record:
+    attributes: TypeAttributes
+    fields: list[Field] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class ExtensibleRecord:
+    attributes: TypeAttributes
+    variable: Name
+    fields: list[Field] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Function:
+    attributes: TypeAttributes
+    argument_type: Type
+    return_type: Type
+
+
+@dataclass(frozen=True)
+class Unit:
+    attributes: TypeAttributes
+
+
+@dataclass(frozen=True)
+class Union:
+    """An untagged union: values of at least one of the alternative types.
+
+    Draft v4 type expression (finos/morphir ``docs/spec/draft/types.md``). It
+    introduces no constructor or tag. Alternative order, duplicates and nesting
+    are content and are kept.
+
+    Attributes:
+        attributes: The type attributes.
+        alternatives: Two or more alternative types.
+    """
+
+    attributes: TypeAttributes
+    alternatives: list[Type] = field(default_factory=list)
+
+
+Type = TUnion[
+    Variable, Reference, Tuple, Record, ExtensibleRecord, Function, Unit, Union
+]
+
+
+@dataclass(frozen=True)
+class Field:
+    name: Name
+    tpe: Type
+
+
+def get_attributes(tpe: Type) -> TypeAttributes:
+    return tpe.attributes
+
+
+def map_attributes(tpe: Type, f: Any) -> Type:
+    # f should be Callable[[TypeAttributes], TypeAttributes]
+    # But doing precise typing here might be verbose with Union destructuring
+    # For now, simplistic implementation
+    ta = tpe.attributes
+    new_ta = f(ta)
+
+    if isinstance(tpe, Variable):
+        return Variable(new_ta, tpe.name)
+    elif isinstance(tpe, Reference):
+        return Reference(new_ta, tpe.fqname, [map_attributes(a, f) for a in tpe.args])
+    elif isinstance(tpe, Tuple):
+        return Tuple(new_ta, [map_attributes(e, f) for e in tpe.elements])
+    elif isinstance(tpe, Record):
+        return Record(
+            new_ta, [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields]
+        )
+    elif isinstance(tpe, ExtensibleRecord):
+        return ExtensibleRecord(
+            new_ta,
+            tpe.variable,
+            [Field(fl.name, map_attributes(fl.tpe, f)) for fl in tpe.fields],
+        )
+    elif isinstance(tpe, Function):
+        return Function(
+            new_ta,
+            map_attributes(tpe.argument_type, f),
+            map_attributes(tpe.return_type, f),
+        )
+    elif isinstance(tpe, Union):
+        return Union(new_ta, [map_attributes(a, f) for a in tpe.alternatives])
+    else:
+        return Unit(new_ta)

morphir/ir/v4/type_constraints.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Literal, Union
+
+from .fqname import FQName
+
+# Numeric Constraints
+IntWidth = Literal[8, 16, 32, 64]
+FloatWidth = Literal[32, 64]
+
+
+@dataclass(frozen=True)
+class Signed:
+    bits: IntWidth
+
+
+@dataclass(frozen=True)
+class Unsigned:
+    bits: IntWidth
+
+
+@dataclass(frozen=True)
+class FloatingPoint:
+    bits: FloatWidth
+
+
+@dataclass(frozen=True)
+class Bounded:
+    min: int | None = None
+    max: int | None = None
+
+
+@dataclass(frozen=True)
+class Decimal:
+    precision: int
+    scale: int
+
+
+NumericConstraint = Union[Signed, Unsigned, FloatingPoint, Bounded, Decimal]
+
+
+# String Constraints
+class StringEncoding(Enum):
+    UTF8 = auto()
+    UTF16 = auto()
+    ASCII = auto()
+    LATIN1 = auto()
+
+
+@dataclass(frozen=True)
+class StringConstraint:
+    encoding: StringEncoding | None = None
+    min_length: int | None = None
+    max_length: int | None = None
+    pattern: str | None = None
+
+
+# Collection Constraints
+@dataclass(frozen=True)
+class CollectionConstraint:
+    min_length: int | None = None
+    max_length: int | None = None
+    unique_items: bool = False
+
+
+# Custom Constraints
+# We use 'Any' for arguments to avoid circular dependency with Value for now
+# Ideally this should be Value, but Value depends on Type (sometimes)
+from typing import Any
+
+
+@dataclass(frozen=True)
+class CustomConstraint:
+    predicate: FQName
+    arguments: list[Any]
+
+
+@dataclass(frozen=True)
+class TypeConstraints:
+    """Structured constraints on a type.
+
+    Deprecated: the upstream v4 schema keeps ``TypeAttributes.constraints`` as a
+    placeholder with no defined members, so these constraints have no v4 spelling
+    and encoding fails with ``no_v4_spelling``. Keep constraints in
+    ``TypeAttributes.extensions`` until upstream defines them.
+    """
+
+    numeric: NumericConstraint | None = None
+    string: StringConstraint | None = None
+    collection: CollectionConstraint | None = None
+    custom: list[CustomConstraint] = field(default_factory=list)

morphir/ir/v4/type_def.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import Union
+
+from .access_controlled import AccessControlled
+from .incompleteness import Incompleteness
+from .name import Name
+from .type import Type
+from .type_spec import Constructors
+
+
+@dataclass(frozen=True)
+class TypeAliasDefinition:
+    type_params: list[Name]
+    tpe: Type
+
+
+@dataclass(frozen=True)
+class CustomTypeDefinition:
+    type_params: list[Name]
+    constructors: AccessControlled[Constructors]
+
+
+@dataclass(frozen=True)
+class IncompleteTypeDefinition:
+    """A type definition that is not complete yet.
+
+    Attributes:
+        type_params: The declared type parameters.
+        incompleteness: Why the definition is incomplete.
+        partial_type_exp: The type expression written so far, if any.
+    """
+
+    type_params: list[Name]
+    incompleteness: Incompleteness
+    partial_type_exp: Type | None = None
+
+
+Definition = Union[TypeAliasDefinition, CustomTypeDefinition, IncompleteTypeDefinition]

morphir/ir/v4/type_spec.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Union
+
+from .annotation import Annotation
+from .fqname import FQName
+from .name import Name
+from .type import Type
+
+ConstructorArgs = list[tuple[Name, Type]]
+Constructors = dict[Name, ConstructorArgs]
+
+
+@dataclass(frozen=True)
+class TypeAliasSpecification:
+    """Specification for a type alias."""
+
+    type_params: list[Name]
+    tpe: Type
+    annotations: list[Annotation] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class OpaqueTypeSpecification:
+    """Specification for an opaque type."""
+
+    type_params: list[Name]
+    annotations: list[Annotation] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class CustomTypeSpecification:
+    """Specification for a custom type (ADT)."""
+
+    type_params: list[Name]
+    constructors: Constructors
+    annotations: list[Annotation] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class DerivedTypeSpecificationDetails:
+    """Details for a derived type."""
+
+    base_type: Type
+    from_base_type: FQName
+    to_base_type: FQName
+
+
+@dataclass(frozen=True)
+class DerivedTypeSpecification:
+    """Specification for a derived type."""
+
+    type_params: list[Name]
+    details: DerivedTypeSpecificationDetails
+    annotations: list[Annotation] = field(default_factory=list)
+
+
+Specification = Union[
+    TypeAliasSpecification,
+    OpaqueTypeSpecification,
+    CustomTypeSpecification,
+    DerivedTypeSpecification,
+]