dazl 8.7.0__tar.gz → 8.8.0__tar.gz

dazl-8.8.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.3
+Name: dazl
+Version: 8.8.0
+Summary: high-level Ledger API client for Daml ledgers
+License: Apache-2.0
+Keywords: daml,blockchain,dlt,distributed ledger,digital asset
+Author: Davin K. Tanabe
+Author-email: davin.tanabe@digitalasset.com
+Requires-Python: >=3.10.0,<4.0.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: pygments
+Provides-Extra: tls-testing
+Requires-Dist: attrs (>=22.2.0)
+Requires-Dist: googleapis_common_protos (>=1,<2)
+Requires-Dist: grpcio (>=1.72.0,<2.0.0)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: protobuf (>=6)
+Requires-Dist: pyOpenSSL ; extra == "tls-testing"
+Requires-Dist: pygments ; extra == "pygments"
+Requires-Dist: python-dateutil (>=2.8.1)
+Requires-Dist: semver
+Requires-Dist: typing_extensions
+Project-URL: Homepage, https://github.com/digital-asset/dazl-client
+Project-URL: Repository, https://github.com/digital-asset/dazl-client
+Description-Content-Type: text/markdown
+
+Daml Python bindings (formerly known as dazl)
+=============================================
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/digital-asset/dazl-client/blob/main/LICENSE)
+<a href="https://circleci.com/gh/digital-asset/dazl-client">
+<img src="https://circleci.com/gh/digital-asset/dazl-client.svg?style=svg">
+</a>
+
+Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+
+
+Rich Python bindings for accessing Canton 2.x Ledger API-based applications. It is not intended for use with Canton 3.x.
+
+Documentation
+-------------
+The user documentation is available online [here](https://digital-asset.github.io/dazl-client).
+
+Installation
+------------
+If you just want to use the library, you can install it locally with `pip`:
+```sh
+pip install --user dazl
+```
+
+Requirements
+------------
+* Python 3.10+
+* Go 1.23
+* [Daml SDK](https://www.daml.com)
+    * Daml 2: 2.10 or later
+
+Examples
+--------
+
+All of the examples below assume you imported `dazl`, and are running a ledger with the default scenario generated with `daml new`.
+
+Connect to the ledger and submit a single command:
+
+```py
+import asyncio
+import dazl
+
+async def main():
+    async with dazl.connect(url='http://localhost:6865', act_as='Alice') as client:
+        contract = { 'issuer' : 'Alice', 'owner' : 'Alice', 'name' : 'hello world!' }
+        await client.create('Main:Asset', contract)
+
+asyncio.run(main())
+```
+
+Connect to the ledger as a single party, print all contracts, and close:
+
+```py
+import asyncio
+import dazl
+from dazl.ledgerutil import ACS
+
+async def main():
+    async with dazl.connect(url='http://localhost:6865', read_as='Alice') as conn:
+        async with ACS(conn, {"*": {}}) as acs:
+            snapshot = await acs.read()
+
+    print(snapshot)
+
+asyncio.run(main())
+```
+
+Building locally
+----------------
+
+You will need additional dependencies to build locally:
+
+* Direnv (https://direnv.net/)
+* Nix (https://nixos.org/download/)
+
+Once you have these prerequisites in place:
+
+```sh
+make build
+```
+
+Tests
+-----
+
+Tests in the Daml Python bindings are written using [pytest](https://docs.pytest.org/en/latest/). You can run them by doing:
+
+```sh
+make test
+```
+
+Support
+-------
+
+The Daml Python bindings library are supported under the Daml Enterprise license. If you do not have a Daml Enterprise license and are in need of support, have questions or just want to engage in friendly conversation anything Daml, contact us on our [Daml Community Forum](https://discuss.daml.com).
+

dazl-8.8.0/pyproject.toml

@@ -0,0 +1,91 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+[tool.poetry]
+name = "dazl"
+version = "8.8.0"
+description = "high-level Ledger API client for Daml ledgers"
+license = "Apache-2.0"
+authors = ["Davin K. Tanabe <davin.tanabe@digitalasset.com>"]
+readme = 'README.md'
+repository = "https://github.com/digital-asset/dazl-client"
+homepage = "https://github.com/digital-asset/dazl-client"
+keywords = ["daml", "blockchain", "dlt", "distributed ledger", "digital asset"]
+packages = [{ include = "dazl", from = "python" }, { include = "_dazl", from = "python" }]
+
+[tool.poetry.dependencies]
+python = "^3.10.0"
+attrs = ">=22.2.0"
+googleapis_common_protos = "^1"
+grpcio = "^1.72.0"
+httpx = "^0.27.0"
+protobuf = ">=6"
+pygments = { version = "*", optional = true }
+pyOpenSSL = { version = "*", optional = true }
+python-dateutil = ">=2.8.1"
+semver = "*"
+typing_extensions = { version = "*" }
+
+[tool.poetry.extras]
+pygments = ["pygments"]
+tls-testing = ["pyOpenSSL"]
+
+[tool.poetry.scripts]
+dazl = 'dazl.cli:main'
+
+[tool.poetry.group.dev.dependencies]
+black = "*"
+grpc-stubs = "*"
+grpcio-tools = "^1.72.0"
+isort = "^5"
+jinja2 = "^3"
+mypy = "*"
+openapi-python-client = "*"
+pyjwt = "*"
+pytest = "*"
+pytest-asyncio = "*"
+rich = "^13.7.0"
+setuptools = "*"
+sphinx = "*"
+sphinx-autobuild = "*"
+sphinx-markdown-builder = "*"
+types-protobuf = "*"
+types-pyOpenSSL = "*"
+types-requests = "*"
+types-setuptools = "*"
+watchdog = "*"
+types-pyyaml = "^6.0.12.20250402"
+pyyaml = "^6.0.2"
+
+[tool.black]
+line-length = 100
+
+[tool.isort]
+add_imports = ["from __future__ import annotations"]
+combine_as_imports = true
+combine_star = true
+force_sort_within_sections = true
+group_by_package = true
+include_trailing_comma = true
+line_length = 100
+multi_line_output = 3
+
+[tool.mypy]
+cache_dir = '.cache/mypy'
+#disallow_untyped_defs = true
+namespace_packages = true
+
+[[tool.mypy.overrides]]
+module = ['google._upb.*', 'google.protobuf.pyext.*', 'google.rpc.*', 'google.rpc.status_pb2.*', 'grpc._cython.*', 'grpc.aio.*', 'grpc_tools.*', 'psutil.*', 'pygments.*', 'semver.*']
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+cache_dir = ".cache/pytest"
+log_cli = true
+log_cli_level = "DEBUG"
+junit_family = "xunit1"
+testpaths = ["python/tests/structure", "python/tests/unit"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

dazl-8.8.0/python/_dazl/__main__.py

@@ -0,0 +1,37 @@
+# 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
+
+import argparse
+from pathlib import Path
+
+parser = argparse.ArgumentParser("_dazl")
+parser.add_argument("-T", "--temp-dir")
+parser.add_argument("--log-level", default="info")
+
+subparsers = parser.add_subparsers(dest="command")
+
+update_parser = subparsers.add_parser("update")
+update_parser.add_argument("protopack")
+
+generate_api_parser = subparsers.add_parser("generate-api")
+generate_api_parser.add_argument("openapi_dir", help="Directory containing OpenAPI specifications")
+
+args = parser.parse_args()
+
+from . import _logging
+
+_logging.initialize(args.log_level)
+
+if args.command == "update":
+    from . import update
+
+    update.update(Path(args.protopack))
+elif args.command == "generate-api":
+    from . import generate_api
+
+    generate_api.generate_api_clients(
+        Path(args.openapi_dir),
+        Path(__file__).parent.parent / "dazl" / "_gen_api",
+    )

dazl-8.8.0/python/_dazl/generate_api.py

@@ -0,0 +1,289 @@
+# 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
+
+import logging
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+
+from .codegen.python_header import HEADER
+
+logger = logging.getLogger("_dazl.generate_api")
+
+__all__ = ["generate_api_clients"]
+
+
+def _add_copyright_headers(directory: Path) -> None:
+    for py_file in directory.rglob("*.py"):
+        content = py_file.read_text()
+        if not content.startswith("# Copyright"):
+            py_file.write_text(HEADER + content)
+            logger.debug(f"Added copyright header to {py_file}")
+
+
+def _fix_missing_response_models(directory: Path) -> None:
+    openapi_dir = directory / "openapi"
+    models_dir = openapi_dir / "models"
+    api_dir = openapi_dir / "api" / "default"
+
+    response_file = models_dir / "list_vetted_packages_response.py"
+    response_content = (
+        HEADER
+        + '''from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.vetted_package import VettedPackage
+
+
+T = TypeVar("T", bound="ListVettedPackagesResponse")
+
+
+@_attrs_define
+class ListVettedPackagesResponse:
+    """
+    Attributes:
+        next_page_token (str): Pagination token to fetch the next page.
+        vetted_packages (list[VettedPackage]): List of vetted packages.
+    """
+
+    next_page_token: str
+    vetted_packages: list[VettedPackage]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        next_page_token = self.next_page_token
+
+        vetted_packages = []
+        for vetted_packages_item_data in self.vetted_packages:
+            vetted_packages_item = vetted_packages_item_data.to_dict()
+            vetted_packages.append(vetted_packages_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "nextPageToken": next_page_token,
+                "vettedPackages": vetted_packages,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.vetted_package import VettedPackage
+
+        d = dict(src_dict)
+        next_page_token = d.pop("nextPageToken", "")
+
+        vetted_packages = []
+        _vetted_packages = d.pop("vettedPackages", [])
+        for vetted_packages_item_data in _vetted_packages:
+            vetted_packages_item = VettedPackage.from_dict(vetted_packages_item_data)
+            vetted_packages.append(vetted_packages_item)
+
+        list_vetted_packages_response = cls(
+            next_page_token=next_page_token,
+            vetted_packages=vetted_packages,
+        )
+
+        list_vetted_packages_response.additional_properties = d
+        return list_vetted_packages_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties
+'''
+    )
+    response_file.write_text(response_content)
+    logger.debug(f"Created {response_file}")
+
+    api_file = api_dir / "get_v2_package_vetting.py"
+    if api_file.exists():
+        content = api_file.read_text()
+
+        content = content.replace(
+            "from ...models.list_vetted_packages_request import ListVettedPackagesRequest\nfrom ...types import Response",
+            "from ...models.list_vetted_packages_request import ListVettedPackagesRequest\nfrom ...models.list_vetted_packages_response import ListVettedPackagesResponse\nfrom ...types import Response",
+        )
+
+        content = content.replace(
+            "def _parse_response(\n    *, client: AuthenticatedClient | Client, response: httpx.Response\n) -> JsCantonError | str:\n    if response.status_code == 400:\n        response_400 = response.text\n        return response_400\n\n    response_default = JsCantonError.from_dict(response.json())\n\n    return response_default",
+            "def _parse_response(\n    *, client: AuthenticatedClient | Client, response: httpx.Response\n) -> ListVettedPackagesResponse | JsCantonError | str:\n    if response.status_code == 200:\n        response_200 = ListVettedPackagesResponse.from_dict(response.json())\n        return response_200\n\n    if response.status_code == 400:\n        response_400 = response.text\n        return response_400\n\n    response_default = JsCantonError.from_dict(response.json())\n\n    return response_default",
+        )
+
+        content = content.replace(
+            "Response[JsCantonError | str]",
+            "Response[ListVettedPackagesResponse | JsCantonError | str]",
+        )
+
+        content = content.replace(
+            ") -> JsCantonError | str | None:",
+            ") -> ListVettedPackagesResponse | JsCantonError | str | None:",
+        )
+
+        content = content.replace(
+            "    Returns:\n        JsCantonError | str",
+            "    Returns:\n        ListVettedPackagesResponse | JsCantonError | str",
+        )
+
+        api_file.write_text(content)
+        logger.debug(f"Fixed {api_file}")
+
+    init_file = models_dir / "__init__.py"
+    if init_file.exists():
+        content = init_file.read_text()
+
+        content = content.replace(
+            "from .list_vetted_packages_request import ListVettedPackagesRequest\nfrom .map_int_field import MapIntField",
+            "from .list_vetted_packages_request import ListVettedPackagesRequest\nfrom .list_vetted_packages_response import ListVettedPackagesResponse\nfrom .map_int_field import MapIntField",
+        )
+
+        content = content.replace(
+            '    "ListVettedPackagesRequest",\n    "MapIntField",',
+            '    "ListVettedPackagesRequest",\n    "ListVettedPackagesResponse",\n    "MapIntField",',
+        )
+
+        init_file.write_text(content)
+        logger.debug(f"Updated {init_file}")
+
+
+def _fix_post_packages_multipart(directory: Path) -> None:
+    openapi_dir = directory / "openapi"
+    api_dir = openapi_dir / "api" / "default"
+    api_file = api_dir / "post_v2_packages.py"
+
+    if not api_file.exists():
+        logger.warning(f"File {api_file} not found, skipping multipart fix")
+        return
+
+    content = api_file.read_text()
+
+    old_get_kwargs = '''    _kwargs["content"] = body.payload
+
+    headers["Content-Type"] = "application/octet-stream"'''
+
+    new_get_kwargs = """    _kwargs["files"] = {"darFile": (body.file_name or "package.dar", body.payload, body.mime_type or "application/octet-stream")}"""
+
+    if old_get_kwargs in content:
+        content = content.replace(old_get_kwargs, new_get_kwargs)
+        api_file.write_text(content)
+        logger.debug(f"Fixed {api_file} to use multipart/form-data")
+    else:
+        logger.warning(f"Could not find expected content in {api_file}, multipart fix not applied")
+
+
+def _format_generated_code(directory: Path) -> None:
+    venv_bin = Path(sys.executable).parent
+    isort_exe = venv_bin / "isort"
+    black_exe = venv_bin / "black"
+
+    try:
+        subprocess.run(
+            [str(isort_exe), str(directory)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        logger.debug("Successfully ran isort")
+    except subprocess.CalledProcessError as e:
+        logger.warning(f"isort failed: {e.stderr}")
+
+    try:
+        subprocess.run(
+            [str(black_exe), str(directory)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        logger.debug("Successfully ran black")
+    except subprocess.CalledProcessError as e:
+        logger.warning(f"black failed: {e.stderr}")
+
+
+def generate_api_clients(openapi_specs_dir: Path, output_dir: Path) -> None:
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    spec_file = openapi_specs_dir / "ledger-api" / "openapi.yaml"
+    if not spec_file.exists():
+        logger.error(f"Ledger API spec not found at {spec_file}")
+        return
+
+    logger.info(f"Generating Ledger API client from {spec_file}")
+
+    venv_bin = Path(sys.executable).parent
+    openapi_client_exe = venv_bin / "openapi-python-client"
+
+    if not openapi_client_exe.exists():
+        logger.error(f"openapi-python-client not found at {openapi_client_exe}")
+        return
+
+    client_output_dir = output_dir / "openapi"
+
+    try:
+        subprocess.run(
+            [
+                str(openapi_client_exe),
+                "generate",
+                "--path",
+                str(spec_file),
+                "--output-path",
+                str(client_output_dir),
+                "--meta",
+                "none",
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        logger.info("Successfully generated Ledger API client")
+
+        _add_copyright_headers(client_output_dir)
+        logger.info("Added copyright headers to generated files")
+
+        _fix_missing_response_models(output_dir)
+        logger.info("Fixed missing response models")
+
+        _fix_post_packages_multipart(output_dir)
+        logger.info("Fixed POST /v2/packages to use multipart/form-data")
+
+        _format_generated_code(output_dir)
+        logger.info("Formatted generated files")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to generate client: {e.stderr}")
+        return
+
+    init_file = output_dir / "__init__.py"
+    init_file.write_text(
+        "# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.\n"
+        "# SPDX-License-Identifier: Apache-2.0\n"
+        "\n"
+        "from __future__ import annotations\n"
+        "\n"
+        "from .openapi.client import AuthenticatedClient, Client\n"
+        "\n"
+        '__all__ = ["Client", "AuthenticatedClient"]\n'
+    )

dazl-8.8.0/python/dazl/__init__.py

@@ -0,0 +1,60 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+This module contains the Python API for interacting with the Ledger API.
+"""
+from __future__ import annotations
+
+__all__ = [
+    "connect",
+    "Command",
+    "Connection",
+    "ContractData",
+    "ContractId",
+    "CreateAndExerciseCommand",
+    "CreateCommand",
+    "DazlError",
+    "ExerciseByKeyCommand",
+    "ExerciseCommand",
+    "LOG",
+    "Party",
+    "__version__",
+    "frozendict",
+]
+
+from ._logging import LOG
+from .ledger import (
+    Command,
+    Connection,
+    CreateAndExerciseCommand,
+    CreateCommand,
+    ExerciseByKeyCommand,
+    ExerciseCommand,
+    connect,
+)
+from .prim import ContractData, ContractId, DazlError, FrozenDict as frozendict, Party
+
+# Large Protobuf message support
+
+# These methods are undocumented, but is required to read even moderately sized DALF's.
+try:
+    # For Protobuf libraries version 4 or later (using upb)
+    # noinspection PyPackageRequirements,PyUnresolvedReferences,PyProtectedMember
+    from google._upb._message import SetAllowOversizeProtos
+
+    SetAllowOversizeProtos(True)
+except ImportError:
+    pass
+
+try:
+    # For Protobuf libraries version 3 or earlier (using upb)
+    # noinspection PyPackageRequirements,PyUnresolvedReferences,PyProtectedMember
+    from google.protobuf.pyext import _message
+
+    _message.SetAllowOversizeProtos(True)
+except ImportError:
+    pass
+
+
+__version__ = "8.8.0"

dazl-8.8.0/python/dazl/_gen_api/__init__.py

@@ -0,0 +1,8 @@
+# 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 .openapi.client import AuthenticatedClient, Client
+
+__all__ = ["Client", "AuthenticatedClient"]

dazl-8.8.0/python/dazl/_gen_api/openapi/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# fmt: off
+# isort: skip_file
+"""A client library for accessing JSON Ledger API HTTP endpoints"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

dazl-8.8.0/python/dazl/_gen_api/openapi/api/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# fmt: off
+# isort: skip_file
+"""Contains methods for accessing the API"""

dazl-8.8.0/python/dazl/_gen_api/openapi/api/default/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2017-2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# fmt: off
+# isort: skip_file
+"""Contains endpoint functions for accessing the API"""