fabric-chaincode-python 2.5.2__py3-none-any.whl

fabric_chaincode_python-2.5.2.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: fabric-chaincode-python
+Version: 2.5.2
+Summary: Hyperledger Fabric chaincode shim and contract API for Python (experimental)
+Home-page: https://github.com/kmilodenisglez/fabric-chaincode-python/
+Download-URL: https://github.com/kmilodenisglez/fabric-chaincode-python/
+Author: Hyperledger Community
+License: Apache License v2.0
+Keywords: Hyperledger,Fabric,Chaincode,Python
+Platform: any
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: grpcio<2.0.0,>=1.83.1
+Requires-Dist: grpclib>=0.4.3
+Requires-Dist: protobuf<8.0.0,>=5.27.0
+Requires-Dist: hyperledger-fabric-protos<0.4.0,>=0.3.7.dev1
+Requires-Dist: jsonschema>=4.0.0
+Dynamic: author
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: platform
+
+# Hyperledger Fabric Chaincode Python
+
+![GitHub License](https://img.shields.io/github/license/hyperledger/fabric-chaincode-python)
+[![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/14928/badge)](https://bestpractices.coreinfrastructure.org/projects/14928)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/hyperledger/fabric-chaincode-python/badge)](https://scorecard.dev/viewer/?uri=github.com/hyperledger/fabric-chaincode-python)
+
+[![Python Version](https://img.shields.io/pypi/pyversions/fabric-chaincode-python.svg)](https://pypi.org/project/fabric-chaincode-python/)
+[![GitHub Actions](https://github.com/hyperledger/fabric-chaincode-python/workflows/CI/badge.svg)](https://github.com/hyperledger/fabric-chaincode-python/actions?query=workflow%3ACI)
+[![GitHub Release](https://img.shields.io/github/v/release/hyperledger/fabric-chaincode-python.svg)](https://github.com/hyperledger/fabric-chaincode-python/releases)
+
+This is a Python based implementation of Hyperledger Fabric chaincode shim and contract
+API, which enables development of smart contracts using the Python language. Chaincodes
+(smart contracts) written in Python run inside Hyperledger Fabric peers.
+
+## Documentation
+
+- [API documentation](https://hyperledger.github.io/fabric-chaincode-python/)
+- [Full Hyperledger Fabric documentation](https://hyperledger-fabric.readthedocs.io/)
+- [Samples repository](https://github.com/hyperledger/fabric-samples)
+
+## Project structure
+
+```
+src/
+├── fabric_contract_api/   Python Contract API
+└── fabric_shim/           Python chaincode shim (Fabric 2.x)
+```
+
+- **fabric_contract_api** - Contains the Python contract API used to write smart contracts with the high-level contract programming model.
+- **fabric_shim** - Contains the Python classes that implement the chaincode shim API and the way to communicate with Fabric peers.
+
+## Building and testing
+
+Make sure you have the following prereqs installed:
+
+- [Python](https://www.python.org/) 3.11 or later
+- [pip](https://pip.pypa.io/en/stable/)
+
+Create a virtual environment and install the development dependencies:
+
+```
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e . -r requirements-dev.txt
+```
+
+Run the unit tests:
+
+```
+pytest tests/
+```
+
+## Contributing
+
+We welcome contributions to the Hyperledger Fabric project in many forms. If you are
+interested in contributing updates to this project, please start with the
+[contributing guide](CONTRIBUTING.md).
+
+There is also a [release guide](RELEASING.md) describing the process for publishing new
+versions.
+
+## Community
+
+- [Hyperledger Community](https://www.hyperledger.org/community)
+- [Hyperledger mailing lists and archives](http://lists.hyperledger.org/)
+- [Hyperledger Chat](http://chat.hyperledger.org/channel/fabric)
+- [Hyperledger Fabric Wiki](https://wiki.hyperledger.org/display/Fabric)
+- [Hyperledger Code of Conduct](CODE_OF_CONDUCT.md)
+
+## License <a name="license"></a>
+
+Hyperledger Project source code files are made available under the Apache License,
+Version 2.0 (Apache-2.0), located in the [LICENSE](LICENSE) file. Hyperledger Project
+documentation files are made available under the Creative Commons Attribution 4.0
+International License (CC-BY-4.0), available at
+http://creativecommons.org/licenses/by/4.0/.

fabric_chaincode_python-2.5.2.dist-info/RECORD

@@ -0,0 +1,40 @@
+fabric_chaincode_python-2.5.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fabric_chaincode_python-2.5.2.dist-info/licenses/NOTICE,sha256=UFpjAW402B5KR7CekkKG5kO1lk18Rpe7j1yUuf6aQ5I,802
+src/__init__.py,sha256=Kv2_IpzZI0qfnp4UUo6luBDpjqMEyGnubeANvvCrw34,80
+src/version.py,sha256=VflimvOZJOtOSVy8q3PhPH7b4fPixTKblABNuzKDWYw,57
+src/fabric_contract_api/__init__.py,sha256=H3TbY8h7CuX5H3hh5c9vR5eBgYroJSkONh5fudPZdec,1683
+src/fabric_contract_api/contractapi/__init__.py,sha256=SePH6lw7y6V1GqOEdqn6OUGP0ha7xGfiAUd2tJbyq8k,1037
+src/fabric_contract_api/contractapi/contract.py,sha256=icXjFRcD8-eN12GgLRwZUQ-Oj12pj5sZXbqwoR4UxGo,4689
+src/fabric_contract_api/contractapi/contract_chaincode.py,sha256=TJ0KdeQN7DlUGOKyP60Q5KiUB0bfe_enL68do7wns8o,21079
+src/fabric_contract_api/contractapi/system_contract.py,sha256=0KqwejjrN6yfDH5dAC8g4H9rFccyFeiXaqLyZ8OmL90,1358
+src/fabric_contract_api/contractapi/transaction_context.py,sha256=MsgNoOkRuqlEyz0NvSBaB4ooYuPeKKEjt0tdZ-9zAgk,5314
+src/fabric_contract_api/contractapi/utils/__init__.py,sha256=D2oclgtHy4iS6sS0ZZWK0ZIIuktOSESaX0i6m21aTDM,171
+src/fabric_contract_api/contractapi/utils/undefined_interface.py,sha256=Fzp5TgDKOCMgSuHjpn_eQnfwwbxWo64LGHIAB4AfRnw,1030
+src/fabric_contract_api/internal/__init__.py,sha256=gFdvT7EUdXJJxW5F7XAD5xAoPyzTge0Om8x4E8qJ8DU,874
+src/fabric_contract_api/internal/contract_function.py,sha256=cCre6XAQQeCpuDcF7AWfQIeheFmJiJpPcSp4s9Xtb5g,17161
+src/fabric_contract_api/internal/transaction_handler.py,sha256=6Uh4MSxe399s1ZlA0nzCM8qRPoUPQqapMZ7OVZ76cqQ,4758
+src/fabric_contract_api/internal/types.py,sha256=vredtncoulWBPWKK1MAN5j2NVludChQAPgZjYx4DQtQ,5272
+src/fabric_contract_api/internal/types_handler.py,sha256=7HTgWHp1ycESJjDiQ0XKQujWBmZz7iC1voE96LpKw44,7726
+src/fabric_contract_api/internal/utils.py,sha256=HCPcVb4mti4plOBkJKQvyjWdhdjVd-UKrjTnfHxtGpo,1690
+src/fabric_contract_api/metadata/__init__.py,sha256=K7Lc8q92CaSL8OLEMqlQKMT_DoMEfkvgJRnrr8vBoWs,1086
+src/fabric_contract_api/metadata/metadata.py,sha256=w6NoM_l5Mtu3LBw-ls1GeFQAU8PFMsjEQxmTixnsTeQ,15339
+src/fabric_contract_api/metadata/schema.py,sha256=ulinuYNX8tGxtmozi2_73LYRRmnTShQ6toHOun2wJMo,8426
+src/fabric_contract_api/serializer/__init__.py,sha256=LwRs7Ypdi3oa9ASFpiNP2HGONN2zIIIJlxWgft50vis,231
+src/fabric_contract_api/serializer/json_transaction_serializer.py,sha256=ntountwf_IPnDOT_wLW80gDiHsDFEw1sEEjWNsAyTAo,14293
+src/fabric_contract_api/serializer/transaction_serializer.py,sha256=tBsLrftnW_ViWtTvwfBQR5__Ep9uopNLvt00oLIMpiI,1586
+src/fabric_shim/__init__.py,sha256=tnNC6uHPZZRziNtt4D4MAqnkqtJUUsdl31ezw33gCyU,118
+src/fabric_shim/chaincode.py,sha256=cG9-cWEJz_xQhz9GnbidCIrJO8eOPECxxtHmxHVsexA,223
+src/fabric_shim/handler.py,sha256=vIEvVl5meJOKIWUvGwCgFwOMXZiwwLXymZOx8_w_Rfo,14320
+src/fabric_shim/interfaces.py,sha256=O6BNRzcnyuSbAT-viDW69uM3krg5uZn_XcWOs813Z0k,4821
+src/fabric_shim/iterators.py,sha256=qjEOcAhT44rE_g10mPYZR32KG7riRf3CvIvOfqYcXNY,3596
+src/fabric_shim/logger.py,sha256=bG7Ffen4LvQtgnYPFEpFccsWs81t4zqqeqn9ZeirH6E,38
+src/fabric_shim/logging.py,sha256=UCRQsikez_badFYMYy3zugs3elGUTOYw5fLhLt-HzB4,1858
+src/fabric_shim/msg_queue_handler.py,sha256=4JqSqMSbX010Ls_6dHtbmGR3LwPdkq1z55CW5kJoaW4,3111
+src/fabric_shim/response.py,sha256=4P0013ULz7SMqTXBWKHTqQR62WRXBex9wgpU_Oqn1ZU,1826
+src/fabric_shim/server.py,sha256=A6tdyqyNi46Aqd-C1n4kxy16Zfqbfh-beBqOuztgwqo,5429
+src/fabric_shim/stub.py,sha256=2ITTZyoMLUfB2f7Wjb4wCt1PIBJ-GlnkGjgRLh9wQmE,15389
+src/fabric_shim/utils.py,sha256=bmySQ0bEh3xKqAZydwBS1VtAcUmOhT98pxr9xWO2xxQ,1223
+fabric_chaincode_python-2.5.2.dist-info/METADATA,sha256=fxttBSxUbJPty0NtZ-k9tpnSPcApxKRyhokpYnGrH3k,4144
+fabric_chaincode_python-2.5.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fabric_chaincode_python-2.5.2.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+fabric_chaincode_python-2.5.2.dist-info/RECORD,,

fabric_chaincode_python-2.5.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fabric_chaincode_python-2.5.2.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

fabric_chaincode_python-2.5.2.dist-info/licenses/NOTICE

@@ -0,0 +1,18 @@
+Fabric Chaincode for Python
+Copyright 2023-2026 The Hyperledger Fabric Contributors
+
+This product includes software developed at
+Hyperledger (https://www.hyperledger.org/) and the
+Linux Foundation Decentralized Trust (https://www.lfdecentralizedtrust.org/).
+
+This product is licensed under the Apache License, Version 2.0 (the "License");
+you may not use this product except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.

fabric_chaincode_python-2.5.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/__init__.py

@@ -0,0 +1,5 @@
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from .version import VERSION  # noqa

src/fabric_contract_api/__init__.py

@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Hyperledger Fabric Contract API for Python.
+
+This package provides a high-level, contract-oriented programming model on
+top of the low-level :mod:`fabric_shim` chaincode shim.  It is the Python
+equivalent of Hyperledger's ``fabric-contract-api-go``.
+
+Public surface (mirrors the Go layout)::
+
+    fabric_contract_api.contractapi            # Contract, ContractChaincode, ...
+    fabric_contract_api.serializer            # TransactionSerializer, JSONSerializer
+    fabric_contract_api.metadata              # Metadata types & schema helpers
+    fabric_contract_api.internal              # Introspection & type validation helpers
+
+The most useful imports for application developers are::
+
+    from fabric_contract_api.contractapi import Contract, ContractChaincode
+    from fabric_contract_api.contractapi import TransactionContext, TransactionContextInterface
+"""
+
+from .contractapi import (  # noqa: F401  (re-exported for convenience)
+    Contract,
+    ContractChaincode,
+    ContractInterface,
+    EvaluationContractInterface,
+    IgnoreContractInterface,
+    SystemContract,
+    SystemContractName,
+    TransactionContext,
+    TransactionContextInterface,
+    SettableTransactionContextInterface,
+)
+from .serializer import (  # noqa: F401
+    TransactionSerializer,
+    JSONSerializer,
+)
+
+__all__ = [
+    "Contract",
+    "ContractChaincode",
+    "ContractInterface",
+    "EvaluationContractInterface",
+    "IgnoreContractInterface",
+    "SystemContract",
+    "SystemContractName",
+    "TransactionContext",
+    "TransactionContextInterface",
+    "SettableTransactionContextInterface",
+    "TransactionSerializer",
+    "JSONSerializer",
+]

src/fabric_contract_api/contractapi/__init__.py

@@ -0,0 +1,29 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Contract API package for :mod:`fabric_contract_api`.
+
+Mirrors Go's ``contractapi`` package.  Provides the high-level building
+blocks for declaring and running contracts:
+
+* :class:`Contract` — base class for application contracts.
+* :class:`ContractChaincode` — chaincode adapter that dispatches to
+  registered contracts.
+* :class:`TransactionContext` and :class:`TransactionContextInterface` —
+  per-transaction context passed to contract functions.
+* :class:`SystemContract` — built-in contract that exposes chaincode
+  metadata.
+"""
+
+from .contract import (  # noqa: F401
+    Contract,
+    ContractInterface,
+    EvaluationContractInterface,
+    IgnoreContractInterface,
+)
+from .contract_chaincode import ContractChaincode  # noqa: F401
+from .system_contract import SystemContract, SystemContractName  # noqa: F401
+from .transaction_context import (  # noqa: F401
+    ClientIdentity,
+    SettableTransactionContextInterface,
+    TransactionContext,
+    TransactionContextInterface,
+)

src/fabric_contract_api/contractapi/contract.py

@@ -0,0 +1,141 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Contract base classes and interfaces.
+
+This is the Python equivalent of Go's ``contractapi/contract.go``.  It
+defines:
+
+* :class:`ContractInterface` — the :class:`abc.ABC` every contract must
+  implement.
+* :class:`IgnoreContractInterface` — optional interface for contracts that
+  want to mark certain public methods as not callable from the outside.
+* :class:`EvaluationContractInterface` — optional interface that lets a
+  contract declare which transactions are "evaluate" (i.e. read-only queries).
+* :class:`Contract` — a concrete base class with sensible defaults that
+  application contracts can subclass (or embed) to quickly satisfy the
+  interfaces.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any, List, Optional
+
+from ..metadata import InfoMetadata
+from .transaction_context import (
+    SettableTransactionContextInterface,
+    TransactionContext,
+)
+
+
+class ContractInterface(abc.ABC):
+    """Interface that every contract must implement."""
+
+    @abc.abstractmethod
+    def get_info(self) -> InfoMetadata:
+        """Return the info block used in the metadata."""
+
+    @abc.abstractmethod
+    def get_unknown_transaction(self) -> Optional[Any]:
+        """Return the unknown-transaction callable, or ``None``."""
+
+    @abc.abstractmethod
+    def get_before_transaction(self) -> Optional[Any]:
+        """Return the before-transaction callable, or ``None``."""
+
+    @abc.abstractmethod
+    def get_after_transaction(self) -> Optional[Any]:
+        """Return the after-transaction callable, or ``None``."""
+
+    @abc.abstractmethod
+    def get_name(self) -> str:
+        """Return the name of the contract."""
+
+    @abc.abstractmethod
+    def get_transaction_context_handler(self) -> SettableTransactionContextInterface:
+        """Return the transaction-context class to use."""
+
+
+class IgnoreContractInterface(abc.ABC):
+    """Optional interface for marking methods as not-callable."""
+
+    @abc.abstractmethod
+    def get_ignored_functions(self) -> List[str]:
+        """Return the list of method names that should be excluded."""
+
+
+class EvaluationContractInterface(abc.ABC):
+    """Optional interface for marking methods as evaluate (read-only)."""
+
+    @abc.abstractmethod
+    def get_evaluate_transactions(self) -> List[str]:
+        """Return the list of method names tagged as evaluate."""
+
+
+class Contract(ContractInterface):
+    """Default contract base class.
+
+    Subclass this to define your own contract.  You only need to override
+    the methods that are interesting to you::
+
+        class MyContract(Contract):
+            Name = "MyContract"
+
+            def my_transaction(self, ctx, key: str) -> str:
+                ...
+
+    The following attributes are set as plain instance/class attributes so
+    they can be easily overridden:
+
+    * :attr:`Name` — the contract name.
+    * :attr:`Info` — a :class:`metadata.InfoMetadata` describing the contract.
+    * :attr:`UnknownTransaction` — callable for unknown-transaction handling.
+    * :attr:`BeforeTransaction` — callable invoked before each transaction.
+    * :attr:`AfterTransaction` — callable invoked after each transaction.
+    * :attr:`TransactionContextHandler` — the transaction-context class.
+    """
+
+    Name: str = ""
+    Info: Optional[InfoMetadata] = None
+    UnknownTransaction: Optional[Any] = None
+    BeforeTransaction: Optional[Any] = None
+    AfterTransaction: Optional[Any] = None
+    TransactionContextHandler: Optional[type] = None
+
+    def __init__(self) -> None:
+        # Each Contract instance gets its own InfoMetadata so subclasses don't
+        # accidentally share state via the class-level attribute.
+        if self.Info is None:
+            self.Info = InfoMetadata()
+
+    def get_info(self) -> InfoMetadata:
+        if self.Info is None:
+            self.Info = InfoMetadata()
+        return self.Info
+
+    def get_unknown_transaction(self) -> Optional[Any]:
+        return self.UnknownTransaction
+
+    def get_before_transaction(self) -> Optional[Any]:
+        return self.BeforeTransaction
+
+    def get_after_transaction(self) -> Optional[Any]:
+        return self.AfterTransaction
+
+    def get_name(self) -> str:
+        return self.Name
+
+    def get_transaction_context_handler(self) -> SettableTransactionContextInterface:
+        if self.TransactionContextHandler is None:
+            return TransactionContext()
+        handler = self.TransactionContextHandler
+        if isinstance(handler, type):
+            return handler()
+        return handler
+
+
+__all__ = [
+    "Contract",
+    "ContractInterface",
+    "EvaluationContractInterface",
+    "IgnoreContractInterface",
+]