dazl 8.5.0__tar.gz → 8.7.0__tar.gz

{dazl-8.5.0 → dazl-8.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dazl
-Version: 8.5.0
+Version: 8.7.0
 Summary: high-level Ledger API client for Daml ledgers
 License: Apache-2.0
 Keywords: daml,blockchain,dlt,distributed ledger,digital asset

{dazl-8.5.0 → dazl-8.7.0}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [tool.poetry]
 name = "dazl"
-version = "8.5.0"
+version = "8.7.0"
 description = "high-level Ledger API client for Daml ledgers"
 license = "Apache-2.0"
 authors = ["Davin K. Tanabe <davin.tanabe@digitalasset.com>"]

{dazl-8.5.0 → dazl-8.7.0}/python/dazl/__init__.py

@@ -57,4 +57,4 @@ except ImportError:
     pass
 
 
-__version__ = "8.5.0"
+__version__ = "8.7.0"

{dazl-8.5.0 → dazl-8.7.0}/python/dazl/damlast/daml_lf_1.py

@@ -2215,6 +2215,8 @@ class BuiltinFunction(_IntEnum):
     SUB_DECIMAL = 1
     MUL_DECIMAL = 2
     DIV_DECIMAL = 3
+    MOD_DECIMAL = 4
+    EXP_DECIMAL = 5
     ROUND_DECIMAL = 6
     ADD_NUMERIC = 107
     SUB_NUMERIC = 108
@@ -2481,22 +2483,22 @@ class DefTemplate:
 
     # Optional pre-condition that the template argument must satisfy.
     # When present, it has type `Bool` and the template parameter in scope.
-    precond: Expr
+    precond: Optional[Expr]
 
     # The signatories of the contract. They have type `List Party` and the
     # template parameter in scope.
-    signatories: Expr
+    signatories: Optional[Expr]
 
     # The agreement text associated with the contract. It has type `Text` and
     # the template parameter in scope.
-    agreement: Expr
+    agreement: Optional[Expr]
 
     # The choices available in the resulting contract.
     choices: Sequence[TemplateChoice]
 
     # The observers of the contract. They have type `List Party` and the
     # template parameter in scope.
-    observers: Expr
+    observers: Optional[Expr]
 
     location: Location
 

{dazl-8.5.0 → dazl-8.7.0}/python/dazl/damlast/daml_types.py

@@ -38,6 +38,7 @@ __all__ = [
     "Any",
     "TypeRep",
     "Map",
+    "BigNumeric",
     # Type.Struct
     "struct",
     # Type.ForAll (intentionally omitted)
@@ -209,6 +210,10 @@ def Map(k: Type, v: Type) -> Type:
     return _prim_type(PrimType.GENMAP, k, v)
 
 
+# DAML's arbitrary-precision numeric type (``BigNumeric``).
+BigNumeric = _prim_type(PrimType.BIGNUMERIC)
+
+
 # endregion
 
 # region Type.Forall

{dazl-8.5.0 → dazl-8.7.0}/python/dazl/damlast/parse.py

@@ -19,20 +19,32 @@ import time
 from typing import Optional
 
 from .._gen.com.daml.daml_lf_1_17.daml_lf_pb2 import ArchivePayload
+from .._gen.com.daml.daml_lf_2_1 import daml_lf2_pb2
 from .daml_lf_1 import Archive, PackageRef
-from .pb_parse import ProtobufParser
+from .pb_parse import ProtobufParserFactory
 
 __all__ = ["parse_archive", "parse_archive_payload"]
 
 
-def parse_archive(package_id: PackageRef, archive_bytes: bytes) -> Archive:
+def parse_archive(
+    package_id: PackageRef, archive_bytes: bytes, sdk_version: Optional[str]
+) -> Archive:
     """
     Convert ``bytes`` into an :class:`Archive`.
     """
+
+    parser = ProtobufParserFactory.create_parser(package_id, sdk_version=sdk_version)
+
     archive_pb = parse_archive_payload(package_id, archive_bytes)
 
-    parser = ProtobufParser(package_id)
-    package = parser.parse_Package(archive_pb.daml_lf_1)
+    if archive_pb.HasField("daml_lf_1"):
+        package = parser.parse_Package(archive_pb.daml_lf_1)
+    elif archive_pb.HasField("daml_lf_2"):
+        package_pb = daml_lf2_pb2.Package()
+        package_pb.ParseFromString(archive_pb.daml_lf_2)
+        package = parser.parse_Package(package_pb)
+    else:
+        raise ValueError("Archive payload does not contain daml_lf_1 or daml_lf_2")
 
     return Archive(package_id, package)
 

dazl-8.7.0/python/dazl/damlast/parse_factory/pb_parse_base.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Sequence
+
+from .. import daml_lf_1 as lf
+
+__all__ = ["ProtobufParserBase"]
+
+
+class ProtobufParserBase(ABC):
+    """
+    Abstract base class for all DAML-LF protobuf parsers.
+
+    Defines the interface that version-specific parsers must implement.
+    Each parser converts version-specific protobuf messages to the common AST (daml_lf_1).
+    """
+
+    def __init__(self, current_package: lf.PackageRef) -> None:
+        self.current_package = current_package
+        self.current_module: Optional[lf.ModuleRef] = None
+        self.interned_strings: list[str] = []
+        self.interned_dotted_names: list[Sequence[str]] = []
+        self.interned_types: list[lf.Type] = []
+
+    # Core parsing methods
+    @abstractmethod
+    def parse_Package(self, pb: Any) -> lf.Package:
+        """Parse a Package protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Module(self, pb: Any) -> lf.Module:
+        """Parse a Module protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_DefDataType(self, pb: Any) -> lf.DefDataType:
+        """Parse a DefDataType protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_DefTemplate(self, pb: Any) -> lf.DefTemplate:
+        """Parse a DefTemplate protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_DefInterface(self, pb: Any) -> lf.DefInterface:
+        """Parse a DefInterface protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_DefTypeSyn(self, pb: Any) -> lf.DefTypeSyn:
+        """Parse a DefTypeSyn protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_DefValue(self, pb: Any) -> lf.DefValue:
+        """Parse a DefValue protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Expr(self, pb: Any) -> lf.Expr:
+        """Parse an Expr protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Type(self, pb: Any) -> lf.Type:
+        """Parse a Type protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Kind(self, pb: Any) -> lf.Kind:
+        """Parse a Kind protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Update(self, pb: Any) -> lf.Update:
+        """Parse an Update protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Scenario(self, pb: Any) -> lf.Scenario:
+        """Parse a Scenario protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Case(self, pb: Any) -> lf.Case:
+        """Parse a Case protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Block(self, pb: Any) -> lf.Block:
+        """Parse a Block protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Pure(self, pb: Any) -> lf.Pure:
+        """Parse a Pure protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_Location(self, pb: Any) -> lf.Location:
+        """Parse a Location protobuf message."""
+        ...
+
+    @abstractmethod
+    def parse_TemplateChoice(self, pb: Any) -> lf.TemplateChoice:
+        """Parse a TemplateChoice protobuf message."""
+        ...
+
+    # Helper methods that may be common across versions
+    def _resolve_string(self, direct: str, interned: int) -> str:
+        """Resolve a string that may be direct or interned."""
+        if direct:
+            return direct
+        return self.interned_strings[interned]
+
+    def _resolve_string_seq(self, direct: Sequence[str], interned: Optional[int]) -> Sequence[str]:
+        """Resolve a sequence of strings that may be direct or interned."""
+        if direct:
+            return tuple(direct)
+        if interned is not None:
+            return self.interned_dotted_names[interned]
+        return ()
+
+    def _resolve_dotted_name(self, direct: Any, interned: int) -> lf.DottedName:
+        """Resolve a DottedName that may be direct or interned."""
+        if direct and hasattr(direct, "segments"):
+            return lf.DottedName(segments=direct.segments)
+        return lf.DottedName(segments=self.interned_dotted_names[interned])

dazl-8.5.0/python/dazl/damlast/pb_parse.py → dazl-8.7.0/python/dazl/damlast/parse_factory/pb_v1.py

@@ -5,14 +5,15 @@ from __future__ import annotations
 
 from typing import Optional, Sequence
 
-from . import daml_lf_1 as lf
-from .._gen.com.daml.daml_lf_1_17 import daml_lf_1_pb2 as pblf
+from .. import daml_lf_1 as lf
+from ..._gen.com.daml.daml_lf_1_17 import daml_lf_1_pb2 as pblf
+from .pb_parse_base import ProtobufParserBase
 
-__all__ = ["ProtobufParser"]
+__all__ = ["ProtobufParser117"]
 
 
 # noinspection PyPep8Naming,PyMethodMayBeStatic
-class ProtobufParser:
+class ProtobufParser117(ProtobufParserBase):
     def __init__(self, current_package: lf.PackageRef) -> None:
         self.current_package = current_package
         self.current_module = None  # type: Optional[lf.ModuleRef]
@@ -1095,8 +1096,8 @@ class ProtobufParser:
             )
         )
 
-    def _copy(self) -> ProtobufParser:
-        p = ProtobufParser(self.current_package)
+    def _copy(self) -> ProtobufParser117:
+        p = ProtobufParser117(self.current_package)
         p.current_module = self.current_module
         p.interned_strings = self.interned_strings
         p.interned_dotted_names = self.interned_dotted_names