morphir-python 0.0.1__py3-none-any.whl

morphir/ir/v3/distribution.py

@@ -0,0 +1,42 @@
+"""V3 distributions (morphir-elm ``Morphir.IR.Distribution``).
+
+Format 3.0.0 has only the ``Library`` distribution. Format 3.1.0 adds ``Specs``,
+which publishes a package's specification without its definitions (finos/morphir
+decision record 0018). Type attributes are unit (``None``) and value attributes
+are the value's type. There is no package release version.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import package
+from .path import Path
+from .type import Type
+
+type TypedValueAttributes = Type[None]
+
+
+@dataclass(frozen=True)
+class Library:
+    """A format-3 library: a package name, dependencies, and a definition."""
+
+    package_name: Path
+    definition: package.Definition[None, Type[None]]
+    dependencies: dict[Path, package.Specification[None]] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Specs:
+    """A format-3.1.0 Specs distribution: a package's public face.
+
+    It has the shape of a `Library`, with a package specification in place of the
+    package definition. Writers declare ``formatVersion`` ``"3.1.0"`` for it.
+    """
+
+    package_name: Path
+    specification: package.Specification[None]
+    dependencies: dict[Path, package.Specification[None]] = field(default_factory=dict)
+
+
+type Distribution = Library | Specs

morphir/ir/v3/documented.py

@@ -0,0 +1,13 @@
+"""V3 documented values (morphir-elm ``Morphir.IR.Documented``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Documented[T]:
+    """A value with documentation. In v3 the documentation is always a string."""
+
+    doc: str
+    value: T

morphir/ir/v3/fqname.py

@@ -0,0 +1,30 @@
+"""V3 fully qualified names (morphir-elm ``Morphir.IR.FQName``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import name, path
+from .name import Name
+from .path import Path
+
+
+@dataclass(frozen=True)
+class FQName:
+    """A package path, a module path, and a local name."""
+
+    package_path: Path
+    module_path: Path
+    local_name: Name
+
+
+def fqn(package: str, module: str, local: str) -> FQName:
+    """Build an FQName from strings, as elm ``FQName.fqn`` does.
+
+    Example:
+        >>> fqn("Morphir.SDK", "Basics", "Int").local_name
+        ('int',)
+    """
+    return FQName(
+        path.from_string(package), path.from_string(module), name.from_string(local)
+    )

morphir/ir/v3/literal.py

@@ -0,0 +1,46 @@
+"""V3 literals (morphir-elm ``Morphir.IR.Literal``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+
+
+@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 WholeNumberLiteral:
+    value: int
+
+
+@dataclass(frozen=True)
+class FloatLiteral:
+    value: float
+
+
+@dataclass(frozen=True)
+class DecimalLiteral:
+    value: Decimal
+
+
+type Literal = (
+    BoolLiteral
+    | CharLiteral
+    | StringLiteral
+    | WholeNumberLiteral
+    | FloatLiteral
+    | DecimalLiteral
+)

morphir/ir/v3/module.py

@@ -0,0 +1,32 @@
+"""V3 modules (morphir-elm ``Morphir.IR.Module``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import type as t
+from . import value as v
+from .access_controlled import AccessControlled
+from .documented import Documented
+from .name import Name
+from .path import Path
+
+type ModuleName = Path
+
+
+@dataclass(frozen=True)
+class Specification[TA]:
+    types: dict[Name, Documented[t.Specification[TA]]] = field(default_factory=dict)
+    values: dict[Name, Documented[v.Specification[TA]]] = field(default_factory=dict)
+    doc: str | None = None
+
+
+@dataclass(frozen=True)
+class Definition[TA, VA]:
+    types: dict[Name, AccessControlled[Documented[t.Definition[TA]]]] = field(
+        default_factory=dict
+    )
+    values: dict[Name, AccessControlled[Documented[v.Definition[TA, VA]]]] = field(
+        default_factory=dict
+    )
+    doc: str | None = None

morphir/ir/v3/name.py

@@ -0,0 +1,42 @@
+"""V3 names: lists of lowercase words (morphir-elm ``Morphir.IR.Name``)."""
+
+from __future__ import annotations
+
+import re
+
+
+class Name(tuple[str, ...]):
+    """A v3 name such as ``["value", "in", "u", "s", "d"]``.
+
+    Distinct from `morphir.ir.v4.Name` so that a type checker catches mixing.
+    """
+
+    __slots__ = ()
+
+
+def from_list(words: list[str] | tuple[str, ...]) -> Name:
+    """Build a name from words, as elm ``Name.fromList`` does."""
+    return Name(tuple(words))
+
+
+def to_list(name: Name) -> list[str]:
+    """Return the words of a name."""
+    return list(name)
+
+
+def from_string(text: str) -> Name:
+    """Split text into lowercase words, as elm ``Name.fromString`` does.
+
+    Example:
+        >>> from_string("valueInUSD")
+        ('value', 'in', 'u', 's', 'd')
+    """
+    words = re.findall(r"[a-zA-Z][a-z]*|[0-9]+", text)
+    return Name(tuple(word.lower() for word in words))
+
+
+def to_camel_case(name: Name) -> str:
+    """Render as camelCase, as elm ``Name.toCamelCase`` does."""
+    if not name:
+        return ""
+    return name[0] + "".join(word.capitalize() for word in name[1:])

morphir/ir/v3/package.py

@@ -0,0 +1,23 @@
+"""V3 packages (morphir-elm ``Morphir.IR.Package``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import module
+from .access_controlled import AccessControlled
+from .path import Path
+
+type PackageName = Path
+
+
+@dataclass(frozen=True)
+class Specification[TA]:
+    modules: dict[Path, module.Specification[TA]] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Definition[TA, VA]:
+    modules: dict[Path, AccessControlled[module.Definition[TA, VA]]] = field(
+        default_factory=dict
+    )

morphir/ir/v3/path.py

@@ -0,0 +1,29 @@
+"""V3 paths: lists of names (morphir-elm ``Morphir.IR.Path``)."""
+
+from __future__ import annotations
+
+from .name import Name
+from .name import from_string as name_from_string
+
+
+class Path(tuple[Name, ...]):
+    """A v3 path such as ``[["morphir"], ["s", "d", "k"]]``."""
+
+    __slots__ = ()
+
+
+def from_list(names: list[Name] | tuple[Name, ...]) -> Path:
+    """Build a path from names."""
+    return Path(tuple(names))
+
+
+def to_list(path: Path) -> list[Name]:
+    """Return the names of a path."""
+    return list(path)
+
+
+def from_string(text: str) -> Path:
+    """Split ``Morphir.SDK`` or ``morphir/sdk`` into a path of names."""
+    import re
+
+    return Path(tuple(name_from_string(p) for p in re.split(r"[./]", text) if p))

morphir/ir/v3/qname.py

@@ -0,0 +1,16 @@
+"""V3 qualified names (morphir-elm ``Morphir.IR.QName``)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .name import Name
+from .path import Path
+
+
+@dataclass(frozen=True)
+class QName:
+    """A module path and a local name."""
+
+    module_path: Path
+    local_name: Name

morphir/ir/v3/type.py

@@ -0,0 +1,126 @@
+"""V3 types (morphir-elm ``Morphir.IR.Type``).
+
+Every node is parameterized by its attribute type ``A``. A distribution fixes
+``A`` to ``None``, which is elm's unit ``()``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .access_controlled import AccessControlled
+from .fqname import FQName
+from .name import Name
+
+
+@dataclass(frozen=True)
+class Variable[A]:
+    attributes: A
+    name: Name
+
+
+@dataclass(frozen=True)
+class Reference[A]:
+    attributes: A
+    fqname: FQName
+    args: tuple[Type[A], ...] = ()
+
+
+@dataclass(frozen=True)
+class Tuple[A]:
+    attributes: A
+    elements: tuple[Type[A], ...] = ()
+
+
+@dataclass(frozen=True)
+class Record[A]:
+    attributes: A
+    fields: tuple[Field[A], ...] = ()
+
+
+@dataclass(frozen=True)
+class ExtensibleRecord[A]:
+    attributes: A
+    variable: Name
+    fields: tuple[Field[A], ...] = ()
+
+
+@dataclass(frozen=True)
+class Function[A]:
+    attributes: A
+    argument_type: Type[A]
+    return_type: Type[A]
+
+
+@dataclass(frozen=True)
+class Unit[A]:
+    attributes: A
+
+
+type Type[A] = (
+    Variable[A]
+    | Reference[A]
+    | Tuple[A]
+    | Record[A]
+    | ExtensibleRecord[A]
+    | Function[A]
+    | Unit[A]
+)
+
+
+@dataclass(frozen=True)
+class Field[A]:
+    name: Name
+    tpe: Type[A]
+
+
+type ConstructorArgs[A] = tuple[tuple[Name, Type[A]], ...]
+type Constructors[A] = dict[Name, ConstructorArgs[A]]
+
+
+@dataclass(frozen=True)
+class TypeAliasSpecification[A]:
+    type_params: tuple[Name, ...]
+    tpe: Type[A]
+
+
+@dataclass(frozen=True)
+class OpaqueTypeSpecification:
+    type_params: tuple[Name, ...]
+
+
+@dataclass(frozen=True)
+class CustomTypeSpecification[A]:
+    type_params: tuple[Name, ...]
+    constructors: Constructors[A]
+
+
+@dataclass(frozen=True)
+class DerivedTypeSpecification[A]:
+    type_params: tuple[Name, ...]
+    base_type: Type[A]
+    from_base_type: FQName
+    to_base_type: FQName
+
+
+type Specification[A] = (
+    TypeAliasSpecification[A]
+    | OpaqueTypeSpecification
+    | CustomTypeSpecification[A]
+    | DerivedTypeSpecification[A]
+)
+
+
+@dataclass(frozen=True)
+class TypeAliasDefinition[A]:
+    type_params: tuple[Name, ...]
+    tpe: Type[A]
+
+
+@dataclass(frozen=True)
+class CustomTypeDefinition[A]:
+    type_params: tuple[Name, ...]
+    constructors: AccessControlled[Constructors[A]]
+
+
+type Definition[A] = TypeAliasDefinition[A] | CustomTypeDefinition[A]

morphir/ir/v3/value.py

@@ -0,0 +1,235 @@
+"""V3 values and patterns (morphir-elm ``Morphir.IR.Value``).
+
+Values take two attribute parameters, as in elm: ``TA`` for the types inside
+definitions and ``VA`` for value and pattern nodes. A distribution fixes ``TA`` to
+``None`` and ``VA`` to ``Type[None]``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .fqname import FQName
+from .literal import Literal
+from .name import Name
+from .type import Type
+
+# --- Patterns ---
+
+
+@dataclass(frozen=True)
+class WildcardPattern[A]:
+    attributes: A
+
+
+@dataclass(frozen=True)
+class AsPattern[A]:
+    attributes: A
+    pattern: Pattern[A]
+    name: Name
+
+
+@dataclass(frozen=True)
+class TuplePattern[A]:
+    attributes: A
+    elements: tuple[Pattern[A], ...]
+
+
+@dataclass(frozen=True)
+class ConstructorPattern[A]:
+    attributes: A
+    constructor: FQName
+    args: tuple[Pattern[A], ...]
+
+
+@dataclass(frozen=True)
+class EmptyListPattern[A]:
+    attributes: A
+
+
+@dataclass(frozen=True)
+class HeadTailPattern[A]:
+    attributes: A
+    head: Pattern[A]
+    tail: Pattern[A]
+
+
+@dataclass(frozen=True)
+class LiteralPattern[A]:
+    attributes: A
+    literal: Literal
+
+
+@dataclass(frozen=True)
+class UnitPattern[A]:
+    attributes: A
+
+
+type Pattern[A] = (
+    WildcardPattern[A]
+    | AsPattern[A]
+    | TuplePattern[A]
+    | ConstructorPattern[A]
+    | EmptyListPattern[A]
+    | HeadTailPattern[A]
+    | LiteralPattern[A]
+    | UnitPattern[A]
+)
+
+# --- Values ---
+
+
+@dataclass(frozen=True)
+class LiteralValue[TA, VA]:
+    attributes: VA
+    literal: Literal
+
+
+@dataclass(frozen=True)
+class Constructor[TA, VA]:
+    attributes: VA
+    fqname: FQName
+
+
+@dataclass(frozen=True)
+class Tuple[TA, VA]:
+    attributes: VA
+    elements: tuple[Value[TA, VA], ...]
+
+
+@dataclass(frozen=True)
+class List[TA, VA]:
+    attributes: VA
+    items: tuple[Value[TA, VA], ...]
+
+
+@dataclass(frozen=True)
+class Record[TA, VA]:
+    attributes: VA
+    fields: dict[Name, Value[TA, VA]]
+
+
+@dataclass(frozen=True)
+class Variable[TA, VA]:
+    attributes: VA
+    name: Name
+
+
+@dataclass(frozen=True)
+class Reference[TA, VA]:
+    attributes: VA
+    fqname: FQName
+
+
+@dataclass(frozen=True)
+class Field[TA, VA]:
+    attributes: VA
+    subject: Value[TA, VA]
+    field_name: Name
+
+
+@dataclass(frozen=True)
+class FieldFunction[TA, VA]:
+    attributes: VA
+    name: Name
+
+
+@dataclass(frozen=True)
+class Apply[TA, VA]:
+    attributes: VA
+    function: Value[TA, VA]
+    argument: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class Lambda[TA, VA]:
+    attributes: VA
+    pattern: Pattern[VA]
+    body: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class LetDefinition[TA, VA]:
+    attributes: VA
+    name: Name
+    definition: Definition[TA, VA]
+    in_value: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class LetRecursion[TA, VA]:
+    attributes: VA
+    definitions: dict[Name, Definition[TA, VA]]
+    in_value: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class Destructure[TA, VA]:
+    attributes: VA
+    pattern: Pattern[VA]
+    value_to_destructure: Value[TA, VA]
+    in_value: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class IfThenElse[TA, VA]:
+    attributes: VA
+    condition: Value[TA, VA]
+    then_branch: Value[TA, VA]
+    else_branch: Value[TA, VA]
+
+
+@dataclass(frozen=True)
+class PatternMatch[TA, VA]:
+    attributes: VA
+    branch_on: Value[TA, VA]
+    cases: tuple[tuple[Pattern[VA], Value[TA, VA]], ...]
+
+
+@dataclass(frozen=True)
+class UpdateRecord[TA, VA]:
+    attributes: VA
+    value_to_update: Value[TA, VA]
+    fields: dict[Name, Value[TA, VA]]
+
+
+@dataclass(frozen=True)
+class Unit[TA, VA]:
+    attributes: VA
+
+
+type Value[TA, VA] = (
+    LiteralValue[TA, VA]
+    | Constructor[TA, VA]
+    | Tuple[TA, VA]
+    | List[TA, VA]
+    | Record[TA, VA]
+    | Variable[TA, VA]
+    | Reference[TA, VA]
+    | Field[TA, VA]
+    | FieldFunction[TA, VA]
+    | Apply[TA, VA]
+    | Lambda[TA, VA]
+    | LetDefinition[TA, VA]
+    | LetRecursion[TA, VA]
+    | Destructure[TA, VA]
+    | IfThenElse[TA, VA]
+    | PatternMatch[TA, VA]
+    | UpdateRecord[TA, VA]
+    | Unit[TA, VA]
+)
+
+# --- Specifications and definitions ---
+
+
+@dataclass(frozen=True)
+class Specification[TA]:
+    inputs: tuple[tuple[Name, Type[TA]], ...]
+    output: Type[TA]
+
+
+@dataclass(frozen=True)
+class Definition[TA, VA]:
+    input_types: tuple[tuple[Name, VA, Type[TA]], ...]
+    output_type: Type[TA]
+    body: Value[TA, VA]