Merge pull request #90 from digital-asset/python-fix-type-identifiers

python: Make type string identifiers more consistent with the HTTP JSON API

Author: da-tanabe

.circleci/config.yml

@@ -4,6 +4,7 @@ jobs:
     working_directory: ~/dazl
     docker:
       - image: rappdw/docker-java-python
+    resource_class: medium+
     steps:
       - run:
           name: Install poetry and jq

VERSION

@@ -1 +1 @@
-6.7.6
+6.8.0

python/dazl/damlast/_builtins_meta.py

@@ -9,8 +9,9 @@
 
 from typing import Any, Optional, Sequence, Union
 
-from .daml_lf_1 import Expr, Type, BuiltinFunction
-from ..model.types import TypeReference, ValueReference
+from .daml_lf_1 import BuiltinFunction, Expr, Type, ValName
+from .util import package_local_name
+from ..model.types import TypeReference
 
 
 class _BuiltinMeta(type):
@@ -60,16 +61,16 @@ def add(self, builtin: Builtin):
         else:
             raise ValueError(f'A builtin could not be registered! {builtin!r}')
 
-    def resolve(self, ref: 'Union[str, ValueReference, TypeReference, BuiltinFunction]') -> \
+    def resolve(self, ref: 'Union[str, ValName, TypeReference, BuiltinFunction]') -> \
             'Optional[Builtin]':
         """
         Return a :class:`Builtin` implementation for the name or reference if one is defined.
         """
         if isinstance(ref, BuiltinFunction):
             # All BuiltinFunctions MUST be defined
             return self.by_builtin[ref]
-        elif isinstance(ref, (ValueReference, TypeReference)):
-            return self.by_name.get(ref.full_name_unambiguous)
+        elif isinstance(ref, (ValName, TypeReference)):
+            return self.by_name.get(package_local_name(ref))
         elif isinstance(ref, str):
             return self.by_name.get(ref)
         else:

python/dazl/damlast/daml_lf_1.py

@@ -4,14 +4,14 @@
 # NOTE TO IMPLEMENTORS: A future version of this file is intended to be code-generated instead of
 # manually maintained. The makeup of this file is intentionally highly formulaic in order to
 # facilitate a smooth transition to automatically-generated data structures.
+import warnings
 
 from dataclasses import dataclass
 from enum import Enum
 from io import StringIO
-from typing import Callable, Optional, Sequence, Union
+from typing import Callable, NewType, Optional, Sequence, Tuple, Union
 
 from ._base import MISSING, T
-from ..model.types import ModuleRef, PackageId, ValueReference, TypeReference as TypeConName, TypeReference, TypeSynName
 from ..util.typing import safe_cast
 
 
@@ -22,7 +22,9 @@ class Unit:
 UNIT = Unit()
 
 
-# PackageRef
+# Reference to a package via a package identifier. The identifier is the ascii7
+# lowercase hex-encoded hash of the package contents found in the DAML LF Archive.
+PackageRef = NewType('PackageRef', str)
 
 
 class DottedName:
@@ -33,12 +35,185 @@ class DottedName:
     def __init__(self, segments: Sequence[str] = ()):
         object.__setattr__(self, 'segments', tuple(segments))
 
+    def __str__(self):
+        return '.'.join(self.segments)
+
+    def __eq__(self, other):
+        return isinstance(other, DottedName) and self.segments == other.segments
+
+    def __hash__(self):
+        return hash(self.segments)
+
+
+class ModuleRef:
+    """
+    A reference to a module.
+
+    In dazl 7.0.0, ModuleRef will become a `NewType(str)`, so making assumptions about the structure
+    of this type should be avoided, and accessor methods should be instead used for callers that
+    care about the structure of these names.
+    """
+    __slots__ = '_package_id', '_module_name'
+
+    def __init__(self, package_id: 'PackageRef', module_name: 'DottedName'):
+        self._package_id = PackageRef(safe_cast(str, package_id))
+        self._module_name = safe_cast(DottedName, module_name)
+
+    @property
+    def package_id(self) -> 'PackageRef':
+        warnings.warn(
+            "Do not use ModuleRef.package_id; use package_ref(...) instead.", DeprecationWarning)
+        return self._package_id
+
+    @property
+    def module_name(self) -> 'DottedName':
+        warnings.warn(
+            "Do not use ModuleRef.module_name; use module_name(...) instead.", DeprecationWarning)
+        return self._module_name
+
+    def __eq__(self, other):
+        return isinstance(other, ModuleRef) and \
+               self._package_id == other._package_id and \
+               self._module_name == other._module_name
+
+    def __lt__(self, other):
+        return self._package_id < other.package_id or \
+               (self._package_id == other.package_id and self._module_name < other.module_name)
+
+    def __le__(self, other):
+        return self._package_id < other.package_id or \
+               (self._package_id == other.package_id and self._module_name <= other.module_name)
+
+    def __gt__(self, other):
+        return self._package_id > other.package_id or \
+               (self._package_id == other.package_id and self._module_name > other.module_name)
+
+    def __ge__(self, other):
+        return self._package_id > other.package_id or \
+               (self._package_id == other.package_id and self._module_name >= other.module_name)
+
+    def __hash__(self):
+        return hash(self._package_id) ^ hash(self._module_name)
+
+    def __str__(self):
+        return f'{self._package_id}:{self._module_name}'
+
+    def __repr__(self):
+        return f'ModuleRef(package_id={self._package_id!r}, ' \
+            f'module_name={self._module_name})'
+
+
+class _Name:
+    """
+    A reference by name to another object.
+
+    This implementation powers all of a TypeConName, TypeSynName, and ValName.
+
+    In dazl 7.0.0, these will become `NewType(str)`, so making assumptions about the structure of
+    this type should be avoided, and accessor methods should be instead used for callers that care
+    about the structure of these names.
+    """
+
+    __slots__ = '_module', '_name'
+
+    def __init__(self, module: 'ModuleRef', name: 'Sequence[str]'):
+        from collections.abc import Collection
+        if not isinstance(name, Collection):
+            raise TypeError(f'Tuple of strings required here (got {name!r} instead)')
+
+        self._module = safe_cast(ModuleRef, module)
+        self._name = tuple(name)  # type: Tuple[str, ...]
+
+    @property
+    def module(self) -> 'ModuleRef':
+        warnings.warn(
+            "Do not use Name.module; you can use module_ref(...) instead.",
+            DeprecationWarning)
+        return self._module
+
+    @property
+    def name(self) -> 'Sequence[str]':
+        warnings.warn(
+            "Do not use Name.name; you can use module_local_name(...) instead.",
+            DeprecationWarning)
+        return self._name
+
+    @property
+    def full_name(self) -> str:
+        from .util import module_name
+        warnings.warn(
+            "Do not use Name.full_name; this format is no longer used, so it has no replacement.",
+            DeprecationWarning)
+        return f"{module_name(self)}.{'.'.join(self._name)}"
+
+    @property
+    def full_name_unambiguous(self):
+        from .util import package_local_name
+        warnings.warn(
+            "Do not use Name.full_name_unambiguous; use package_local_name(...) instead.",
+            DeprecationWarning)
+        return package_local_name(self)
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and \
+               self._module == other._module and self._name == other._name
+
+    def __ne__(self, other):
+        return not isinstance(other, type(self)) or \
+               self._module != other._module or self._name != other._name
+
+    def __lt__(self, other):
+        if not isinstance(other, _Name):
+            raise TypeError("must compare Name to other names")
+
+        return self._module < other._module or \
+               (self._module == other._module and self._name < other._name)
+
+    def __le__(self, other):
+        if not isinstance(other, _Name):
+            raise TypeError("must compare Name to other names")
+        return self._module <= other._module or \
+               (self._module == other._module and self._name <= other._name)
+
+    def __gt__(self, other):
+        if not isinstance(other, _Name):
+            raise TypeError("must compare Name to other names")
+        return self._module > other._module or \
+               (self._module == other._module and self._name > other._name)
+
+    def __ge__(self, other):
+        if not isinstance(other, _Name):
+            raise TypeError("must compare Name to other names")
+
+        return self._module >= other._module or \
+               (self._module == other._module and self._name >= other._name)
+
+    def __hash__(self):
+        return hash(self._module) ^ hash(self._name)
+
+    def __str__(self):
+        return f"{self._module}:{'.'.join(self._name)}"
+
+    def __repr__(self):
+        return f"{type(self).__name__}({str(self)!r})"
+
+
+class TypeConName(_Name):
+    """
+    A reference to a type constructor.
+    """
+
 
-# ModuleRef
-# TypeConName
+class TypeSynName(_Name):
+    """
+    A reference to a type synonym.
+    """
 
 
-ValName = ValueReference
+class ValName(_Name):
+    """
+    A reference to a value.
+    """
 
 
 @dataclass(frozen=True)
@@ -162,10 +337,10 @@ class Var:
         args: 'Sequence[Type]'
 
     class Con:
-        tycon: 'TypeReference'
+        tycon: 'TypeConName'
         args: 'Sequence[Type]'
 
-        def __init__(self, tycon: 'TypeReference', args: 'Sequence[Type]'):
+        def __init__(self, tycon: 'TypeConName', args: 'Sequence[Type]'):
             self.tycon = tycon
             self.args = tuple(args)
 
@@ -413,7 +588,7 @@ def numeric(self) -> 'Optional[str]':
         Serialization of number with precision 38 and scale between 0 and 37
 
         Must be a string that matched
-            `-?([0-1]\d*|0)\.(\d*)
+            `-?([0-1]\\d*|0)\\.(\\d*)
 
         The number of decimal digits indicate the scale of the number.
         """
@@ -504,7 +679,7 @@ def __init__(self, tycon: 'Type.Con', variant_con: str, variant_arg: 'Expr'):
 
     @dataclass(frozen=True)
     class EnumCon:
-        tycon: 'TypeReference'  # Always fully applied
+        tycon: 'TypeConName'  # Always fully applied
         enum_con: str
 
     @dataclass(frozen=True)
@@ -991,7 +1166,7 @@ def __init__(self, con, variant, binder):
 
     @dataclass(frozen=True)
     class Enum:
-        con: TypeReference
+        con: TypeConName
         constructor: str
 
     @dataclass(frozen=True)
@@ -1858,5 +2033,5 @@ class PackageMetadata:
 
 @dataclass(frozen=True)
 class Archive:
-    hash: 'PackageId'
+    hash: 'PackageRef'
     package: 'Package'

python/dazl/damlast/evaluate.py

@@ -3,13 +3,17 @@
 
 from datetime import datetime, date, timedelta, timezone
 from decimal import Decimal
-from typing import Any, Mapping
+from typing import Any, Mapping, TYPE_CHECKING
 
 from .. import LOG
 from ..model.core import Party
-from ..model.types_store import PackageStore
 from ..util.prim_types import frozendict
 from .daml_lf_1 import *
+from .util import package_local_name
+
+
+if TYPE_CHECKING:
+    from ..model.types import PackageStore
 
 
 class Evaluator:
@@ -111,7 +115,7 @@ def eval_var(self, var: str) -> Any:
         return self.eval_Expr(expr)
 
     def eval_val(self, val: 'ValName') -> 'Any':
-        if val.full_name_unambiguous == 'DA.Internal.Prelude:concat':
+        if package_local_name(val) == 'DA.Internal.Prelude:concat':
             return PartialFunction(lambda a: PartialFunction(Evaluator.concat))
         value = self.store.resolve_value_reference(val)
         if value is None:

python/dazl/damlast/expand.py

@@ -6,6 +6,7 @@
 
 from .builtins import builtins
 from .daml_lf_1 import Block, Expr, Type, ValName
+from .util import package_local_name
 from .visitor import IdentityVisitor
 from ..model.types_store import PackageStore
 
@@ -67,13 +68,13 @@ def visit_expr_val(self, val: 'ValName') -> 'Expr':
         builtin = builtins.resolve(val)
         if builtin is not None:
             return Expr(val=val)
-        if self.always_expand or val.name[0][0] == '$' or val.full_name_unambiguous == 'DA.Internal.Template:toParties':
+        if self.always_expand or val.name[0][0] == '$' or package_local_name(val) == 'DA.Internal.Template:toParties':
             val_expr = self.resolve_val(val)
             if val_expr is not None:
                 child = self.without_val(val)
                 return child.visit_expr(val_expr)
             else:
-                print(f'Failed to resolve {val.full_name_unambiguous} against blacklist {self.val_blacklist}')
+                print(f'Failed to resolve {package_local_name(val)} against blacklist {self.val_blacklist}')
 
         return super(ExpandVisitor, self).visit_expr_val(val)
 

python/dazl/damlast/pb_parse.py

@@ -3,12 +3,11 @@
 
 
 from .daml_lf_1 import *
-from ..model.types import ModuleRef, PackageId, TypeReference
 
 
 # noinspection PyPep8Naming,PyMethodMayBeStatic
 class ProtobufParser:
-    def __init__(self, current_package: 'PackageId'):
+    def __init__(self, current_package: 'PackageRef'):
         from typing import List
         self.current_package = current_package
         self.interned_strings = []  # type: List[str]
@@ -24,17 +23,17 @@ def parse_ModuleRef(self, pb) -> 'Optional[ModuleRef]':
         if sum_name is None:
             return None
         elif sum_name == 'self':
-            return ModuleRef(self.current_package, module_name.segments)
+            return ModuleRef(self.current_package, module_name)
         elif sum_name == 'package_id_str':
-            return ModuleRef(pb.package_ref.package_id_str, module_name.segments)
+            return ModuleRef(pb.package_ref.package_id_str, module_name)
         elif sum_name == 'package_id_interned_str':
             return ModuleRef(
-                self.interned_strings[pb.package_ref.package_id_interned_str], module_name.segments)
+                self.interned_strings[pb.package_ref.package_id_interned_str], module_name)
         else:
             raise ValueError(f'unknown sum type value: {sum_name!r}')
 
-    def parse_TypeConName(self, pb) -> 'TypeReference':
-        return TypeReference(
+    def parse_TypeConName(self, pb) -> 'TypeConName':
+        return TypeConName(
             self.parse_ModuleRef(pb.module),
             self._resolve_dotted_name(pb.name_dname, pb.name_interned_dname).segments)