algokit-subscriber 1.0.1__tar.gz

algokit_subscriber-1.0.1/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.3
+Name: algokit-subscriber
+Version: 1.0.1
+Summary: 
+Author: Algorand Foundation
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: py-algorand-sdk (>=2.9.1,<3.0.0)
+Description-Content-Type: text/markdown
+
+<div align="center">
+<a href="https://github.com/algorandfoundation/algokit-subscriber-py"><img src="https://bafybeidbb3a7cgn3unoz4oouk2jme4eavqgqtnskfr4bqhbjku3s52de4a.ipfs.w3s.link/algokit-subscriber-logo.png" width=60%></a>
+</div>
+
+<p align="center">
+    <a target="_blank" href="https://algorandfoundation.github.io/algokit-subscriber-py/"><img src="https://img.shields.io/badge/docs-repository-74dfdc?logo=github&style=flat.svg" /></a>
+    <a target="_blank" href="https://algorand.co/algokit"><img src="https://img.shields.io/badge/learn-AlgoKit-74dfdc?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-subscriber-py"><img src="https://img.shields.io/github/stars/algorandfoundation/algokit-subscriber-py?color=74dfdc&logo=star&style=flat" /></a>
+    <a target="_blank" href="https://algorand.co/algokit"><img  src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Falgorandfoundation%2Falgokit-subscriber-py&countColor=%2374dfdc&style=flat" /></a>
+</p>
+
+---
+
+This library a simple, but flexible / configurable Algorand transaction subscription / indexing mechanism. It allows you to quickly create Python services that follow or subscribe to the Algorand Blockchain.
+
+> pip install algokit_subscriber
+
+[Documentation](./docs/index.md)
+
+## Quick start
+
+```python
+# Create subscriber
+subscriber = AlgorandSubscriber(
+  {
+    "filters": [
+      {
+        "name": "filter1",
+        "filter": {
+          "type": "pay",
+          "sender": "ABC...",
+        },
+      },
+    ],
+    # ... other options (use intellisense to explore)
+  },
+  algod,
+  optional_indexer
+);
+
+# Set up subscription(s)
+def on_filter1(transaction, event_name):
+    ...
+
+subscriber.on("filter1", on_filter1)
+
+# Either: Start the subscriber (if in long-running process)
+subscriber.start();
+
+# OR: Poll the subscriber (if in cron job / periodic lambda)
+subscriber.pollOnce();
+```
+
+## Key features
+
+- **Notification _and_ indexing** - You have fine-grained control over the syncing behaviour and can control the number of rounds to sync at a time, the pattern of syncing i.e. start from the beginning of the chain, or start from the tip; drop stale records if your service can't keep up or keep syncing from where you are up to; etc.
+- **Low latency processing** - When your service has caught up to the tip of the chain it can optionally wait for new rounds so you have a low latency reaction to a new round occurring
+- **Watermarking and resilience** - You can create reliable syncing / indexing services through a simple round watermarking capability that allows you to create resilient syncing services that can recover from an outage
+- **Extensive subscription filtering** - You can filter by transaction type, sender, receiver, note prefix, apps (ID, creation, on complete, ARC-4 method signature, call arguments, ARC-28 events), assets (ID, creation, amount transferred range), transfers (amount transferred range) and balance changes (algo and assets)
+- **ARC-28 event subscription support** - You can subscribe to ARC-28 events for a smart contract
+- **Balance change support** - Subscribed transactions will have all algo and asset balance changes calculated for you and you can also subscribe to balance changes that meet certain criteria
+- **First-class inner transaction support** - Your filter will find arbitrarily nested inner transactions and return that transaction (indexer can't do this!)
+- **State-proof support** - You can subscribe to state proof transactions
+- **Simple programming model** - It's really easy to use and consume through easy to use, type-safe methods and objects and subscribed transactions have a comprehensive and familiar model type with all relevant/useful information about that transaction (including things like transaction id, round number, created asset/app id, app logs, etc.) modelled on the indexer data model (which is used regardless of whether the transactions come from indexer or algod so it's a consistent experience)
+- **Easy to deploy** - You have full control over how you want to deploy and use the subscriber; it will work with whatever persistence (e.g. sql, no-sql, etc.), queuing/messaging (e.g. queues, topics, buses, web hooks, web sockets) and compute (e.g. serverless periodic lambdas, continually running containers, virtual machines, etc.) services you want to use
+- **Fast initial index** - There is an indexer catch up mode that allows you to use indexer to catch up to the tip of the chain in seconds or minutes rather than days; alternatively, if you prefer to just use algod and not indexer that option is available too!
+
+## Balance change notes
+
+The balance change semantics work mostly as expected, however the sematics around asset creation and destruction warrants further clarification.
+
+When an asset is created, the full asset supply is attributed to the asset creators account.
+
+The balance change for an asset create transaction will be as below:
+
+```py
+{
+  "address": "VIDHG4SYANCP2GUQXXSFSNBPJWS4TAQSI3GH4GYO54FSYPDIBYPMSF7HBY", # The asset creator
+  "asset_id": 2391, # The created asset id
+  "amount": 100000, # Full asset supply of the created asset
+  "roles": [BalanceChangeroles.AssetCreator]
+}
+```
+
+When an asset is destroyed, the full asset supply must be in the asset creators account and the asset manager must send the destroy transaction.
+Unfortunately we cannot determine the asset creator or full asset supply from the transaction data. As a result the balance change will always be attributed to the asset manager and will have a 0 amount.
+If you need to account for the asset supply being destroyed from the creators account, you'll need to handle this separately.
+
+The balance change for an asset destroy transaction will be as below:
+
+```python
+{
+  "address": "PIDHG4SYANCP2GUQXXSFSNBPJWS4TAQSI3GH4GYO54FSYPDIBYPMSF7HBY", # The asset destroyer, which will always be the asset manager
+  "assetId": 2391, # The destroyed asset id
+  "amount": 0, # This value will always be 0
+  "roles": [BalanceChangeroles.AssetDestroyer]
+}
+```
+
+## Examples
+
+### Data History Museum index
+
+The following code, when algod is pointed to TestNet, will find all transactions emitted by the [Data History Museum](https://datahistory.org) since the beginning of time in _seconds_ and then find them in real-time as they emerge on the chain.
+
+The watermark is stored in-memory so this particular example is not resilient to restarts. To change that you can implement proper persistence of the watermark. There is [an example that uses the file system](./examples/data-history-museum/) to demonstrate this.
+
+```python
+algorand = AlgorandClient.testnet()
+
+# The watermark is used to track how far the subscriber has processed transactions
+watermark = 0
+
+def get_watermark() -> int:
+    return watermark
+
+def set_watermark(new_watermark: int) -> None:
+    global watermark
+    watermark = new_watermark
+
+subscriber = AlgorandSubscriber(
+    # algod is used to get the latest transactions once the subscriber has caught up to the network
+    algod_client=algorand.client.algod,
+    config={
+        "filters": [
+            {
+                "name": "dhm-asset",
+                "filter": {
+                    # Match asset configuration transactions
+                    "type": "acfg",
+                    # Data History Museum creator account on TestNet
+                    "sender": "ER7AMZRPD5KDVFWTUUVOADSOWM4RQKEEV2EDYRVSA757UHXOIEKGMBQIVU",
+                },
+            }
+        ],
+        "frequency_in_seconds": 5,
+        "max_rounds_to_sync": 100,
+        "sync_behaviour": "catchup-with-indexer",
+        "watermark_persistence": {"get": get_watermark, "set": set_watermark},
+    },
+    # indexer is used to get historical transactions
+    indexer_client=algorand.client.indexer,
+)
+
+def process_dhm_assets(transactions: list[SubscribedTransaction], filter_name: str) -> None:
+    print(f"Received {len(transactions)} asset changes")
+    # ... do stuff with the transactions
+
+# Attach our callback to the 'dhm-asset' filter
+subscriber.on_batch("dhm-asset", process_dhm_assets)
+
+def handle_error(error: Exception) -> None:
+    print(f"An error occurred: {error}")
+
+# Attach the error handler
+subscriber.on_error(handle_error)
+
+# Start the subscriber
+subscriber.start()
+```
+
+### USDC real-time monitoring
+
+The following code, when algod is pointed to MainNet, will find all transfers of [USDC](https://www.circle.com/en/usdc-multichain/algorand) that are greater than $1 and it will poll every 1s for new transfers.
+
+```python
+from algokit_subscriber import AlgorandSubscriber
+from algokit_subscriber.types import SubscribedTransaction
+from algokit_utils import AlgorandClient
+
+algorand = AlgorandClient.mainnet()
+
+# The watermark is used to track how far the subscriber has processed transactions
+watermark = 0
+
+def get_watermark() -> int:
+    return watermark
+
+def set_watermark(new_watermark: int) -> None:
+    global watermark
+    watermark = new_watermark
+
+subscriber = AlgorandSubscriber(
+    algod_client=algorand.client.algod,
+    config={
+        "filters": [
+            {
+                "name": "usdc",
+                "filter": {
+                    "type": "axfer",
+                    "asset_id": 31566704,  # MainNet: USDC
+                    "min_amount": 1_000_000,  # $1
+                },
+            }
+        ],
+        "wait_for_block_when_at_tip": True,
+        "sync_behaviour": "skip-sync-newest",
+        "watermark_persistence": {"get": get_watermark, "set": set_watermark},
+    },
+)
+
+def process_usdc_transfer(transfer: SubscribedTransaction, filter_name: str) -> None:
+    asset_transfer = transfer.get("asset-transfer-transaction", {})
+    amount = asset_transfer.get("amount", 0) / 1_000_000
+    print(
+        f"{transfer['sender']} sent {asset_transfer.get('receiver')} "
+        f"USDC${amount:.2f} in transaction {transfer['id']}"
+    )
+
+# Attach our callback to the 'usdc' filter
+subscriber.on("usdc", process_usdc_transfer)
+
+def handle_error(error: Exception) -> None:
+    print(f"An error occurred: {error}")
+
+# Attach the error handler
+subscriber.on_error(handle_error)
+
+# Start the subscriber
+subscriber.start()
+```
+

algokit_subscriber-1.0.1/README.md

@@ -0,0 +1,221 @@
+<div align="center">
+<a href="https://github.com/algorandfoundation/algokit-subscriber-py"><img src="https://bafybeidbb3a7cgn3unoz4oouk2jme4eavqgqtnskfr4bqhbjku3s52de4a.ipfs.w3s.link/algokit-subscriber-logo.png" width=60%></a>
+</div>
+
+<p align="center">
+    <a target="_blank" href="https://algorandfoundation.github.io/algokit-subscriber-py/"><img src="https://img.shields.io/badge/docs-repository-74dfdc?logo=github&style=flat.svg" /></a>
+    <a target="_blank" href="https://algorand.co/algokit"><img src="https://img.shields.io/badge/learn-AlgoKit-74dfdc?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-subscriber-py"><img src="https://img.shields.io/github/stars/algorandfoundation/algokit-subscriber-py?color=74dfdc&logo=star&style=flat" /></a>
+    <a target="_blank" href="https://algorand.co/algokit"><img  src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Falgorandfoundation%2Falgokit-subscriber-py&countColor=%2374dfdc&style=flat" /></a>
+</p>
+
+---
+
+This library a simple, but flexible / configurable Algorand transaction subscription / indexing mechanism. It allows you to quickly create Python services that follow or subscribe to the Algorand Blockchain.
+
+> pip install algokit_subscriber
+
+[Documentation](./docs/index.md)
+
+## Quick start
+
+```python
+# Create subscriber
+subscriber = AlgorandSubscriber(
+  {
+    "filters": [
+      {
+        "name": "filter1",
+        "filter": {
+          "type": "pay",
+          "sender": "ABC...",
+        },
+      },
+    ],
+    # ... other options (use intellisense to explore)
+  },
+  algod,
+  optional_indexer
+);
+
+# Set up subscription(s)
+def on_filter1(transaction, event_name):
+    ...
+
+subscriber.on("filter1", on_filter1)
+
+# Either: Start the subscriber (if in long-running process)
+subscriber.start();
+
+# OR: Poll the subscriber (if in cron job / periodic lambda)
+subscriber.pollOnce();
+```
+
+## Key features
+
+- **Notification _and_ indexing** - You have fine-grained control over the syncing behaviour and can control the number of rounds to sync at a time, the pattern of syncing i.e. start from the beginning of the chain, or start from the tip; drop stale records if your service can't keep up or keep syncing from where you are up to; etc.
+- **Low latency processing** - When your service has caught up to the tip of the chain it can optionally wait for new rounds so you have a low latency reaction to a new round occurring
+- **Watermarking and resilience** - You can create reliable syncing / indexing services through a simple round watermarking capability that allows you to create resilient syncing services that can recover from an outage
+- **Extensive subscription filtering** - You can filter by transaction type, sender, receiver, note prefix, apps (ID, creation, on complete, ARC-4 method signature, call arguments, ARC-28 events), assets (ID, creation, amount transferred range), transfers (amount transferred range) and balance changes (algo and assets)
+- **ARC-28 event subscription support** - You can subscribe to ARC-28 events for a smart contract
+- **Balance change support** - Subscribed transactions will have all algo and asset balance changes calculated for you and you can also subscribe to balance changes that meet certain criteria
+- **First-class inner transaction support** - Your filter will find arbitrarily nested inner transactions and return that transaction (indexer can't do this!)
+- **State-proof support** - You can subscribe to state proof transactions
+- **Simple programming model** - It's really easy to use and consume through easy to use, type-safe methods and objects and subscribed transactions have a comprehensive and familiar model type with all relevant/useful information about that transaction (including things like transaction id, round number, created asset/app id, app logs, etc.) modelled on the indexer data model (which is used regardless of whether the transactions come from indexer or algod so it's a consistent experience)
+- **Easy to deploy** - You have full control over how you want to deploy and use the subscriber; it will work with whatever persistence (e.g. sql, no-sql, etc.), queuing/messaging (e.g. queues, topics, buses, web hooks, web sockets) and compute (e.g. serverless periodic lambdas, continually running containers, virtual machines, etc.) services you want to use
+- **Fast initial index** - There is an indexer catch up mode that allows you to use indexer to catch up to the tip of the chain in seconds or minutes rather than days; alternatively, if you prefer to just use algod and not indexer that option is available too!
+
+## Balance change notes
+
+The balance change semantics work mostly as expected, however the sematics around asset creation and destruction warrants further clarification.
+
+When an asset is created, the full asset supply is attributed to the asset creators account.
+
+The balance change for an asset create transaction will be as below:
+
+```py
+{
+  "address": "VIDHG4SYANCP2GUQXXSFSNBPJWS4TAQSI3GH4GYO54FSYPDIBYPMSF7HBY", # The asset creator
+  "asset_id": 2391, # The created asset id
+  "amount": 100000, # Full asset supply of the created asset
+  "roles": [BalanceChangeroles.AssetCreator]
+}
+```
+
+When an asset is destroyed, the full asset supply must be in the asset creators account and the asset manager must send the destroy transaction.
+Unfortunately we cannot determine the asset creator or full asset supply from the transaction data. As a result the balance change will always be attributed to the asset manager and will have a 0 amount.
+If you need to account for the asset supply being destroyed from the creators account, you'll need to handle this separately.
+
+The balance change for an asset destroy transaction will be as below:
+
+```python
+{
+  "address": "PIDHG4SYANCP2GUQXXSFSNBPJWS4TAQSI3GH4GYO54FSYPDIBYPMSF7HBY", # The asset destroyer, which will always be the asset manager
+  "assetId": 2391, # The destroyed asset id
+  "amount": 0, # This value will always be 0
+  "roles": [BalanceChangeroles.AssetDestroyer]
+}
+```
+
+## Examples
+
+### Data History Museum index
+
+The following code, when algod is pointed to TestNet, will find all transactions emitted by the [Data History Museum](https://datahistory.org) since the beginning of time in _seconds_ and then find them in real-time as they emerge on the chain.
+
+The watermark is stored in-memory so this particular example is not resilient to restarts. To change that you can implement proper persistence of the watermark. There is [an example that uses the file system](./examples/data-history-museum/) to demonstrate this.
+
+```python
+algorand = AlgorandClient.testnet()
+
+# The watermark is used to track how far the subscriber has processed transactions
+watermark = 0
+
+def get_watermark() -> int:
+    return watermark
+
+def set_watermark(new_watermark: int) -> None:
+    global watermark
+    watermark = new_watermark
+
+subscriber = AlgorandSubscriber(
+    # algod is used to get the latest transactions once the subscriber has caught up to the network
+    algod_client=algorand.client.algod,
+    config={
+        "filters": [
+            {
+                "name": "dhm-asset",
+                "filter": {
+                    # Match asset configuration transactions
+                    "type": "acfg",
+                    # Data History Museum creator account on TestNet
+                    "sender": "ER7AMZRPD5KDVFWTUUVOADSOWM4RQKEEV2EDYRVSA757UHXOIEKGMBQIVU",
+                },
+            }
+        ],
+        "frequency_in_seconds": 5,
+        "max_rounds_to_sync": 100,
+        "sync_behaviour": "catchup-with-indexer",
+        "watermark_persistence": {"get": get_watermark, "set": set_watermark},
+    },
+    # indexer is used to get historical transactions
+    indexer_client=algorand.client.indexer,
+)
+
+def process_dhm_assets(transactions: list[SubscribedTransaction], filter_name: str) -> None:
+    print(f"Received {len(transactions)} asset changes")
+    # ... do stuff with the transactions
+
+# Attach our callback to the 'dhm-asset' filter
+subscriber.on_batch("dhm-asset", process_dhm_assets)
+
+def handle_error(error: Exception) -> None:
+    print(f"An error occurred: {error}")
+
+# Attach the error handler
+subscriber.on_error(handle_error)
+
+# Start the subscriber
+subscriber.start()
+```
+
+### USDC real-time monitoring
+
+The following code, when algod is pointed to MainNet, will find all transfers of [USDC](https://www.circle.com/en/usdc-multichain/algorand) that are greater than $1 and it will poll every 1s for new transfers.
+
+```python
+from algokit_subscriber import AlgorandSubscriber
+from algokit_subscriber.types import SubscribedTransaction
+from algokit_utils import AlgorandClient
+
+algorand = AlgorandClient.mainnet()
+
+# The watermark is used to track how far the subscriber has processed transactions
+watermark = 0
+
+def get_watermark() -> int:
+    return watermark
+
+def set_watermark(new_watermark: int) -> None:
+    global watermark
+    watermark = new_watermark
+
+subscriber = AlgorandSubscriber(
+    algod_client=algorand.client.algod,
+    config={
+        "filters": [
+            {
+                "name": "usdc",
+                "filter": {
+                    "type": "axfer",
+                    "asset_id": 31566704,  # MainNet: USDC
+                    "min_amount": 1_000_000,  # $1
+                },
+            }
+        ],
+        "wait_for_block_when_at_tip": True,
+        "sync_behaviour": "skip-sync-newest",
+        "watermark_persistence": {"get": get_watermark, "set": set_watermark},
+    },
+)
+
+def process_usdc_transfer(transfer: SubscribedTransaction, filter_name: str) -> None:
+    asset_transfer = transfer.get("asset-transfer-transaction", {})
+    amount = asset_transfer.get("amount", 0) / 1_000_000
+    print(
+        f"{transfer['sender']} sent {asset_transfer.get('receiver')} "
+        f"USDC${amount:.2f} in transaction {transfer['id']}"
+    )
+
+# Attach our callback to the 'usdc' filter
+subscriber.on("usdc", process_usdc_transfer)
+
+def handle_error(error: Exception) -> None:
+    print(f"An error occurred: {error}")
+
+# Attach the error handler
+subscriber.on_error(handle_error)
+
+# Start the subscriber
+subscriber.start()
+```

algokit_subscriber-1.0.1/pyproject.toml

@@ -0,0 +1,176 @@
+[tool.poetry]
+name = "algokit-subscriber"
+version = "1.0.1"
+description = ""
+authors = ["Algorand Foundation"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+py-algorand-sdk = "^2.9.1"
+
+[tool.poetry.group.dev.dependencies]
+algokit-utils = "^4.1.0"
+mypy = "^1.17.1"
+ruff = "^0.12.8"
+pytest = "^8.4.1"
+pre-commit = "^4.2.0"
+black = "^25.1.0"
+pytest-cov = "^6.2.1"
+sphinx = "^8.2.3"
+furo = "^2024.1.29"
+myst-parser = "^4.0.0"
+sphinx-autodoc2 = "^0.5.0"
+sphinx-copybutton = "^0.5.2"
+sphinx-autobuild = "^2024.4.16"
+sphinx-mermaid = "^0.0.8"
+poethepoet = "^0.36.0"
+pytest-sugar = "^1.0.0"
+pip-audit = "^2.9.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+# TODO: eventually bring this down to 120
+line-length = 280
+lint.select = [
+    # all possible codes as of this ruff version are listed here,
+    # ones we don't want/need are commented out to make it clear
+    # which have been omitted on purpose vs which ones get added
+    # in new ruff releases and should be considered for enabling
+    "F",   # pyflakes
+    "E",
+    "W",   # pycodestyle
+    "C90", # mccabe
+    "I",   # isort
+    "N",   # PEP8 naming
+    "UP",  # pyupgrade
+    "YTT", # flake8-2020
+    "ANN", # flake8-annotations
+    # "S",    # flake8-bandit
+    # "BLE",  # flake8-blind-except
+    "FBT", # flake8-boolean-trap
+    "B",   # flake8-bugbear
+    "A",   # flake8-builtins
+    # "COM",  # flake8-commas
+    "C4",  # flake8-comprehensions
+    "DTZ", # flake8-datetimez
+    "T10", # flake8-debugger
+    # "DJ",   # flake8-django
+    # "EM",   # flake8-errmsg
+    # "EXE",  # flake8-executable
+    "ISC", # flake8-implicit-str-concat
+    "ICN", # flake8-import-conventions
+    # "G",    # flake8-logging-format
+    # "INP",  # flake8-no-pep420
+    "PIE", # flake8-pie
+    "T20", # flake8-print
+    "PYI", # flake8-pyi
+    "PT",  # flake8-pytest-style
+    "Q",   # flake8-quotes
+    "RSE", # flake8-raise
+    "RET", # flake8-return
+    "SLF", # flake8-self
+    "SIM", # flake8-simplify
+    "TID", # flake8-tidy-imports
+    "TCH", # flake8-type-checking
+    "ARG", # flake8-unused-arguments
+    "PTH", # flake8-use-pathlib
+    "ERA", # eradicate
+    # "PD",   # pandas-vet
+    "PGH", # pygrep-hooks
+    "PL",  # pylint
+    # "TRY",  # tryceratops
+    # "NPY",  # NumPy-specific rules
+    "RUF", # Ruff-specific rules
+]
+lint.ignore = [
+    "RET505", # allow else after return
+    "SIM108", # allow if-else in place of ternary
+    "E111",   # indentation is not a multiple of four
+    "E117",   # over-indented
+    "ISC001", # single line implicit string concatenation
+    "ISC002", # multi line implicit string concatenation
+    "Q000",   # bad quotes inline string
+    "Q001",   # bad quotes multiline string
+    "Q002",   # bad quotes docstring
+    "Q003",   # avoidable escaped quotes
+    "W191",   # indentation contains tabs
+    "ERA001", # commented out code
+]
+# Exclude a variety of commonly ignored directories.
+extend-exclude = ["docs", ".git", ".mypy_cache", ".ruff_cache"]
+# Assume Python 3.12.
+target-version = "py312"
+
+[tool.ruff.lint.flake8-annotations]
+allow-star-arg-any = true
+suppress-none-returning = true
+
+[tool.mypy]
+files = ["src", "examples"]
+exclude = ["dist", "tests"]
+python_version = "3.12"
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unused_configs = true
+warn_unreachable = true
+warn_return_any = true
+strict = true
+disallow_untyped_decorators = true
+disallow_any_generics = false
+implicit_reexport = false
+show_error_codes = true
+
+[tool.pytest.ini_options]
+pythonpath = ["src", "tests"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["E501", "T201", "PLR2004", "F811"]
+"examples/*" = ["T201"]
+
+[tool.poe.tasks]
+docs-test = { shell = "sphinx-build -b doctest docs docs/_build -W --keep-going -n -E" }
+docs-clear = { shell = "rm -rf docs/_build" }
+docs-build = { shell = "poetry run poe docs-clear && sphinx-build docs docs/_build -W --keep-going -n -E" }
+docs-dev = { shell = "poetry run poe docs-build && sphinx-autobuild docs docs/_build" }
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:tool.poetry.version"]
+build_command = "pip install build && python -m build"
+commit_message = "{version}\n\n[skip ci] Automatically generated by python-semantic-release"
+tag_format = "v{version}"
+allow_zero_version = false
+
+[tool.semantic_release.branches.main]
+match = "main"
+prerelease_token = "beta"
+prerelease = false
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = [
+    "build",
+    "chore",
+    "ci",
+    "docs",
+    "feat",
+    "fix",
+    "perf",
+    "style",
+    "refactor",
+    "test",
+]
+minor_tags = ["feat"]
+patch_tags = ["fix", "perf", "docs"]
+
+[tool.semantic_release.publish]
+dist_glob_patterns = [
+    "dist/*",
+    "stubs/dist/*",
+] # order here is important to ensure compiler wheel is published first
+upload_to_vcs_release = true
+
+[tool.semantic_release.remote.token]
+env = "GITHUB_TOKEN"

algokit_subscriber-1.0.1/src/algokit_subscriber/__init__.py

@@ -0,0 +1,28 @@
+from .subscriber import AlgorandSubscriber
+from .subscription import get_subscribed_transactions
+from .types.arc28 import Arc28EventGroup
+from .types.event_emitter import EventListener
+from .types.subscription import (
+    AlgorandSubscriberConfig,
+    BalanceChange,
+    BalanceChangeRole,
+    NamedTransactionFilter,
+    SubscribedTransaction,
+    TransactionSubscriptionParams,
+    TransactionSubscriptionResult,
+)
+
+__all__ = [
+    "AlgorandSubscriber",
+    "AlgorandSubscriberConfig",
+    "Arc28EventGroup",
+    "BalanceChange",
+    "BalanceChangeRole",
+    "EventListener",
+    "NamedTransactionFilter",
+    "SubscribedTransaction",
+    "TransactionFilter",
+    "TransactionSubscriptionParams",
+    "TransactionSubscriptionResult",
+    "get_subscribed_transactions",
+]