afp-sdk 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

afp/api/trading.py

@@ -1,25 +1,28 @@
 import secrets
-from datetime import datetime
+import warnings
+from datetime import datetime, timedelta
 from decimal import Decimal
-from typing import Generator
+from typing import Generator, Iterable
 
 from web3 import Web3
 
 from .. import hashing, validators
+from ..constants import DEFAULT_BATCH_SIZE
 from ..decorators import refresh_token_on_expiry
-from ..enums import OrderType
+from ..enums import OrderSide, OrderState, OrderType, TradeState
 from ..schemas import (
     ExchangeProduct,
+    ExchangeProductFilter,
     Intent,
     IntentData,
     MarketDepthData,
+    OHLCVItem,
     Order,
+    OrderFilter,
     OrderCancellationData,
     OrderFill,
     OrderFillFilter,
-    OrderSide,
     OrderSubmission,
-    TradeState,
 )
 from .base import ExchangeAPI
 
@@ -61,6 +64,7 @@ class Trading(ExchangeAPI):
         ----------
         product : afp.schemas.ExchangeProduct
         side : str
+            One of `BID` and `ASK`.
         limit_price : decimal.Decimal
         quantity : decimal.Decimal
         max_trading_fee_rate : decimal.Decimal
@@ -87,7 +91,7 @@ class Trading(ExchangeAPI):
             ),
             quantity=quantity,
             max_trading_fee_rate=max_trading_fee_rate,
-            side=getattr(OrderSide, side.upper()),
+            side=OrderSide(side.upper()),
             good_until_time=good_until_time,
             nonce=self._generate_nonce(),
         )
@@ -161,14 +165,34 @@ class Trading(ExchangeAPI):
         )
         return self._exchange.submit_order(submission)
 
-    def products(self) -> list[ExchangeProduct]:
+    def products(
+        self,
+        batch: int = 1,
+        batch_size: int = DEFAULT_BATCH_SIZE,
+        newest_first: bool = True,
+    ) -> list[ExchangeProduct]:
         """Retrieves the products approved for trading on the exchange.
 
+        If there are more than `batch_size` number of products then they can be queried
+        in batches.
+
+        Parameters
+        ----------
+        batch : int, optional
+            1-based index of the batch of products.
+        batch_size : int, optional
+            The maximum number of products in one batch.
+        newest_first : bool, optional
+            Whether to sort products in descending or ascending order by creation time.
+
         Returns
         -------
         list of afp.schemas.ExchangeProduct
         """
-        return self._exchange.get_approved_products()
+        filter = ExchangeProductFilter(
+            batch=batch, batch_size=batch_size, newest_first=newest_first
+        )
+        return self._exchange.get_approved_products(filter)
 
     def product(self, product_id: str) -> ExchangeProduct:
         """Retrieves a product for trading by its ID.
@@ -211,53 +235,133 @@ class Trading(ExchangeAPI):
         return self._exchange.get_order_by_id(value)
 
     @refresh_token_on_expiry
-    def open_orders(self, product_id: str | None = None) -> list[Order]:
-        """Retrieves all open and partially filled limit orders that have been submitted
-        by the authenticated account.
+    def orders(
+        self,
+        *,
+        product_id: str | None = None,
+        intent_account_id: str | None = None,
+        type_: str | None = None,
+        states: Iterable[str] = (),
+        side: str | None = None,
+        start: datetime | None = None,
+        end: datetime | None = None,
+        batch: int = 1,
+        batch_size: int = DEFAULT_BATCH_SIZE,
+        newest_first: bool = True,
+    ) -> list[Order]:
+        """Retrieves the authenticated account's orders that match the given parameters.
+
+        If there are more than `batch_size` number of orders then they can be queried
+        in batches.
 
         Parameters
         ----------
         product_id : str, optional
+        intent_account_id : str, optional
+            Defaults to the address of the authenticated account.
+        type_ : str, optional
+            One of `LIMIT_ORDER` and `CANCEL_ORDER`.
+        states : iterable of str
+            Any of `RECEIVED`, `PENDING`, `OPEN`, `COMPLETED` and `REJECTED`.
+        side : str, optional
+            One of `BID` and `ASK`.
+        start : datetime.datetime, optional
+        end : datetime.datetime, optional
+        batch : int, optional
+            1-based index of the batch of orders.
+        batch_size : int, optional
+            The maximum number of orders in one batch.
+        newest_first : bool, optional
+            Whether to sort orders in descending or ascending order by creation time.
 
         Returns
         -------
-        list of afp.schemas.Order
+        list of afp.schemas.OrderFill
         """
-        return self._exchange.get_open_orders(product_id)
+        if intent_account_id is None:
+            intent_account_id = self._authenticator.address
+
+        filter = OrderFilter(
+            intent_account_id=intent_account_id,
+            product_id=product_id,
+            type=None if type_ is None else OrderType(type_.upper()),
+            states=[OrderState(state.upper()) for state in states],
+            side=None if side is None else OrderSide(side.upper()),
+            start=start,
+            end=end,
+            batch=batch,
+            batch_size=batch_size,
+            newest_first=newest_first,
+        )
+        return self._exchange.get_orders(filter)
+
+    @refresh_token_on_expiry
+    def open_orders(self, product_id: str | None = None) -> list[Order]:
+        """Deprecated alias of Trading.orders(type_="LIMIT_ORDER", states=("OPEN", "PARTIAL"))."""
+        warnings.warn(
+            "Trading.open_orders() is deprecated. Use "
+            'Trading.orders(type_="LIMIT_ORDER", states=("OPEN", "PARTIAL")) instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.orders(
+            type_="limit_order", states=("open", "partial"), product_id=product_id
+        )
 
     @refresh_token_on_expiry
     def order_fills(
         self,
         *,
         product_id: str | None = None,
-        margin_account_id: str | None = None,
+        intent_account_id: str | None = None,
         intent_hash: str | None = None,
         start: datetime | None = None,
         end: datetime | None = None,
+        trade_states: Iterable[str] = (),
+        batch: int = 1,
+        batch_size: int = DEFAULT_BATCH_SIZE,
+        newest_first: bool = True,
     ) -> list[OrderFill]:
         """Retrieves the authenticated account's order fills that match the given
         parameters.
 
+        If there are more than `batch_size` number of order fills then they can be
+        queried in batches.
+
         Parameters
         ----------
         product_id : str, optional
-        margin_account_id : str, optional
+        intent_account_id : str, optional
+            Defaults to the address of the authenticated account.
         intent_hash : str, optional
         start : datetime.datetime, optional
         end : datetime.datetime, optional
+        trade_states : iterable of str
+            Any of `PENDING`, `CLEARED` and `REJECTED`.
+        batch : int, optional
+            1-based index of the batch of order fills.
+        batch_size : int, optional
+            The maximum number of order fills in one batch.
+        newest_first : bool, optional
+            Whether to sort order fills in descending or ascending order by creation time.
 
         Returns
         -------
         list of afp.schemas.OrderFill
         """
+        if intent_account_id is None:
+            intent_account_id = self._authenticator.address
+
         filter = OrderFillFilter(
-            intent_account_id=self._authenticator.address,
+            intent_account_id=intent_account_id,
             product_id=product_id,
-            margin_account_id=margin_account_id,
             intent_hash=intent_hash,
             start=start,
             end=end,
-            trade_state=None,
+            trade_states=[TradeState(state.upper()) for state in trade_states],
+            batch=batch,
+            batch_size=batch_size,
+            newest_first=newest_first,
         )
         return self._exchange.get_order_fills(filter)
 
@@ -266,34 +370,49 @@ class Trading(ExchangeAPI):
         self,
         *,
         product_id: str | None = None,
-        margin_account_id: str | None = None,
+        intent_account_id: str | None = None,
         intent_hash: str | None = None,
+        trade_states: Iterable[str] = ("PENDING",),
     ) -> Generator[OrderFill, None, None]:
         """Subscribes to the authenticated account's new order fills that match the
         given parameters.
 
-        Returns a generator that yields new order fills as they are published by the
-        exchange. A new order fill gets publised as soon as there is a match in the
-        order book, before the trade is submitted to clearing.
+        Returns a generator that yields order fills as they are published by the
+        exchange.
+
+        If `trade_states` includes `PENDING` (the default value) then a new order fill
+        is yielded as soon as there is a match in the order book, before the trade is
+        submitted to clearing.
+
+        If `trade_states` is empty or more than one trade state is specified then
+        updates to order fills are yielded at every state transition.
 
         Parameters
         ----------
         product_id : str, optional
-        margin_account_id : str, optional
+        intent_account_id : str, optional
+            Defaults to the address of the authenticated account.
         intent_hash : str, optional
+        trade_states: iterable of str
+            Any of `PENDING`, `CLEARED` and `REJECTED`.
 
         Yields
         -------
         afp.schemas.OrderFill
         """
+        if intent_account_id is None:
+            intent_account_id = self._authenticator.address
+
         filter = OrderFillFilter(
-            intent_account_id=self._authenticator.address,
+            intent_account_id=intent_account_id,
             product_id=product_id,
-            margin_account_id=margin_account_id,
             intent_hash=intent_hash,
             start=None,
             end=None,
-            trade_state=TradeState.PENDING,
+            trade_states=[TradeState(state.upper()) for state in trade_states],
+            batch=None,
+            batch_size=None,
+            newest_first=None,
         )
         yield from self._exchange.iter_order_fills(filter)
 
@@ -339,3 +458,71 @@ class Trading(ExchangeAPI):
         """
         value = validators.validate_hexstr32(product_id)
         yield from self._exchange.iter_market_depth_data(value)
+
+    def ohlcv(
+        self,
+        product_id: str,
+        start: datetime | None = None,
+        interval: timedelta = timedelta(minutes=5),
+    ) -> list[OHLCVItem]:
+        """Retrieves Open-High-Low-Close-Volume time series data for the given product.
+
+        Parameters
+        ----------
+        product_id : str
+        start : datetime
+            Defaults to 1 day ago.
+        interval : timedelta
+            The distance between 2 data points. Gets rounded to a multiple of 5 seconds.
+            Defaults to 5 minutes.
+
+        Returns
+        -------
+        list of afp.schemas.OHLCVItem
+
+        Raises
+        ------
+        afp.exceptions.NotFoundError
+            If no such product exists.
+        """
+        if start is None:
+            start = datetime.now() - timedelta(days=1)
+
+        product_id = validators.validate_hexstr32(product_id)
+        start_timestamp = int(start.timestamp())
+        interval_secs = int(validators.validate_timedelta(interval).total_seconds())
+        return self._exchange.get_time_series_data(
+            product_id, start_timestamp, interval_secs
+        )
+
+    def iter_ohlcv(
+        self, product_id: str, interval: timedelta = timedelta(seconds=5)
+    ) -> Generator[OHLCVItem, None, None]:
+        """Subscribes to Open-High-Low-Close-Volume time series data updates for the
+        given product.
+
+        Returns a generator that yields OHLCV data points as they are published
+        by the exhange.
+
+        Parameters
+        ----------
+        product_id : str
+        interval : timedelta
+            The distance between 2 data points. Gets rounded to a multiple of 5 seconds.
+            Defaults to 5 seconds.
+
+        Yields
+        -------
+        afp.schemas.OHLCVItem
+
+        Raises
+        ------
+        afp.exceptions.NotFoundError
+            If no such product exists.
+        """
+        product_id = validators.validate_hexstr32(product_id)
+        start_timestamp = int(datetime.now().timestamp())
+        interval_secs = int(validators.validate_timedelta(interval).total_seconds())
+        yield from self._exchange.iter_time_series_data(
+            product_id, start_timestamp, interval_secs
+        )

afp/constants.py

@@ -1,4 +1,5 @@
 import os
+from importlib import metadata
 from types import SimpleNamespace
 
 
@@ -6,10 +7,12 @@ def _int_or_none(value: str | None) -> int | None:
     return int(value) if value is not None else None
 
 
-USER_AGENT = "afp-sdk"
+# Venue API constants
+USER_AGENT = "afp-sdk/{}".format(metadata.version("afp-sdk"))
+DEFAULT_BATCH_SIZE = 50
 DEFAULT_EXCHANGE_API_VERSION = 1
 
-# Constants from clearing/contracts/lib/constants.sol
+# Clearing System constants
 RATE_MULTIPLIER = 10**4
 FEE_RATE_MULTIPLIER = 10**6
 FULL_PRECISION_MULTIPLIER = 10**18

afp/enums.py

@@ -4,12 +4,14 @@ from enum import StrEnum
 class ListingState(StrEnum):
     PRIVATE = "PRIVATE"
     PUBLIC = "PUBLIC"
+    READ_ONLY = "READ_ONLY"
     DELISTED = "DELISTED"
 
 
 class OrderType(StrEnum):
     LIMIT_ORDER = "LIMIT_ORDER"
     CANCEL_ORDER = "CANCEL_ORDER"
+    EXCHANGE_INITIATED_CANCELLATION = "EXCHANGE_INITIATED_CANCELLATION"
 
 
 class OrderState(StrEnum):

afp/exchange.py

@@ -16,11 +16,14 @@ from .exceptions import (
 from .schemas import (
     ExchangeParameters,
     ExchangeProduct,
+    ExchangeProductFilter,
     ExchangeProductListingSubmission,
     ExchangeProductUpdateSubmission,
     LoginSubmission,
     MarketDepthData,
+    OHLCVItem,
     Order,
+    OrderFilter,
     OrderFill,
     OrderFillFilter,
     OrderSubmission,
@@ -51,8 +54,12 @@ class ExchangeClient:
         return ExchangeParameters(**response.json())
 
     # GET /products
-    def get_approved_products(self) -> list[ExchangeProduct]:
-        response = self._send_request("GET", "/products")
+    def get_approved_products(
+        self, filter: ExchangeProductFilter
+    ) -> list[ExchangeProduct]:
+        response = self._send_request(
+            "GET", "/products", params=filter.model_dump(exclude_none=True)
+        )
         return [ExchangeProduct(**item) for item in response.json()["products"]]
 
     # GET /products/{product_id}
@@ -86,9 +93,9 @@ class ExchangeClient:
         return Order(**response.json())
 
     # GET /orders
-    def get_open_orders(self, product_id: str | None = None) -> list[Order]:
+    def get_orders(self, filter: OrderFilter) -> list[Order]:
         response = self._send_request(
-            "GET", "/orders", params=({"product_id": product_id} if product_id else {})
+            "GET", "/orders", params=filter.model_dump(exclude_none=True)
         )
         return [Order(**item) for item in response.json()["orders"]]
 
@@ -132,6 +139,30 @@ class ExchangeClient:
         for line in response.iter_lines():
             yield MarketDepthData.model_validate_json(line)
 
+    # GET /time-series/{product_id}
+    def get_time_series_data(
+        self, product_id: str, start: int, interval: int
+    ) -> list[OHLCVItem]:
+        response = self._send_request(
+            "GET",
+            f"/time-series/{product_id}",
+            params=dict(start=start, interval=interval),
+        )
+        return [OHLCVItem(**item) for item in response.json()["data"]]
+
+    # GET /stream/time-series/{product_id}
+    def iter_time_series_data(
+        self, product_id: str, start: int, interval: int
+    ) -> Generator[OHLCVItem, None, None]:
+        response = self._send_request(
+            "GET",
+            f"/stream/time-series/{product_id}",
+            params=dict(start=start, interval=interval),
+            stream=True,
+        )
+        for line in response.iter_lines():
+            yield OHLCVItem.model_validate_json(line)
+
     def _send_request(
         self,
         method: str,
@@ -167,11 +198,19 @@ class ExchangeClient:
                 raise AuthorizationError(http_error) from http_error
             if http_error.response.status_code == requests.codes.NOT_FOUND:
                 raise NotFoundError(http_error) from http_error
-
-            try:
-                reason = response.json()["detail"]
-            except (json.JSONDecodeError, KeyError):
-                reason = response.text
-            raise ValidationError(reason) from http_error
+            if http_error.response.status_code == requests.codes.BAD_REQUEST:
+                try:
+                    reason = response.json()["detail"]
+                except (json.JSONDecodeError, KeyError):
+                    reason = http_error
+                raise ValidationError(reason) from http_error
+            if http_error.response.status_code == requests.codes.UNPROCESSABLE:
+                try:
+                    reason = ", ".join(err["msg"] for err in response.json()["detail"])
+                except (json.JSONDecodeError, KeyError, TypeError):
+                    reason = http_error
+                raise ValidationError(reason) from http_error
+
+            raise ExchangeError(http_error) from http_error
 
         return response

afp/schemas.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from decimal import Decimal
 from functools import partial
-from typing import Annotated, Any
+from typing import Annotated, Any, Literal
 
 import inflection
 from pydantic import (
@@ -12,6 +12,7 @@ from pydantic import (
     ConfigDict,
     Field,
     PlainSerializer,
+    computed_field,
 )
 
 from . import validators
@@ -40,6 +41,33 @@ class Model(BaseModel):
         return super().model_dump_json(by_alias=by_alias, **kwargs)
 
 
+class PaginationFilter(Model):
+    batch: Annotated[None | int, Field(gt=0, exclude=True)]
+    batch_size: Annotated[None | int, Field(gt=0, exclude=True)]
+    newest_first: Annotated[None | bool, Field(exclude=True)]
+
+    @computed_field
+    @property
+    def page(self) -> None | int:
+        return self.batch
+
+    @computed_field
+    @property
+    def page_size(self) -> None | int:
+        return self.batch_size
+
+    @computed_field
+    @property
+    def sort(self) -> None | Literal["ASC", "DESC"]:
+        match self.newest_first:
+            case None:
+                return None
+            case True:
+                return "DESC"
+            case False:
+                return "ASC"
+
+
 # Authentication
 
 
@@ -78,6 +106,10 @@ class ExchangeProduct(Model):
         return self.id
 
 
+class ExchangeProductFilter(PaginationFilter):
+    pass
+
+
 class IntentData(Model):
     trading_protocol_id: str
     product_id: str
@@ -106,6 +138,21 @@ class Order(Model):
     intent: Intent
 
 
+class OrderFilter(PaginationFilter):
+    intent_account_id: str
+    product_id: None | Annotated[str, AfterValidator(validators.validate_hexstr32)]
+    type: None | OrderType
+    states: Annotated[list[OrderState], Field(exclude=True)]
+    side: None | OrderSide
+    start: None | Timestamp
+    end: None | Timestamp
+
+    @computed_field
+    @property
+    def state(self) -> str | None:
+        return ",".join(self.states) if self.states else None
+
+
 class OrderCancellationData(Model):
     intent_hash: Annotated[str, AfterValidator(validators.validate_hexstr32)]
     nonce: int
@@ -137,16 +184,18 @@ class OrderFill(Model):
     price: Decimal
 
 
-class OrderFillFilter(Model):
+class OrderFillFilter(PaginationFilter):
     intent_account_id: str
     product_id: None | Annotated[str, AfterValidator(validators.validate_hexstr32)]
-    margin_account_id: (
-        None | Annotated[str, AfterValidator(validators.validate_address)]
-    )
     intent_hash: None | Annotated[str, AfterValidator(validators.validate_hexstr32)]
     start: None | Timestamp
     end: None | Timestamp
-    trade_state: None | TradeState
+    trade_states: Annotated[list[TradeState], Field(exclude=True)]
+
+    @computed_field
+    @property
+    def trade_state(self) -> str | None:
+        return ",".join(self.trade_states) if self.trade_states else None
 
 
 class MarketDepthItem(Model):
@@ -160,6 +209,15 @@ class MarketDepthData(Model):
     asks: list[MarketDepthItem]
 
 
+class OHLCVItem(Model):
+    timestamp: Timestamp
+    open: Decimal
+    high: Decimal
+    low: Decimal
+    close: Decimal
+    volume: int
+
+
 # Clearing API
 
 

{afp_sdk-0.5.1.dist-info → afp_sdk-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: afp-sdk
-Version: 0.5.1
+Version: 0.5.3
 Summary: Autonomous Futures Protocol Python SDK
 Keywords: autonity,web3,trading,crypto,prediction,forecast,markets
 License-Expression: MIT

{afp_sdk-0.5.1.dist-info → afp_sdk-0.5.3.dist-info}/RECORD

@@ -5,7 +5,7 @@ afp/api/admin.py,sha256=6TiWCo0SB41CtXYTkTYYGQY7MrdB6OMTyU3-0J0V_7o,2170
 afp/api/base.py,sha256=5X1joEwFX4gxYUDCSTvp_hSFCfLZCktnW-UtZFxDquk,4471
 afp/api/margin_account.py,sha256=sC1DF7J3QTHR7cXcRjTG33oZswVy6qr9xnevQbrQ-ew,15256
 afp/api/product.py,sha256=2N4bPBahuw19GcBbBL20oQ5RFRuUxa5LOZzmN7hs39U,10156
-afp/api/trading.py,sha256=exQQ3LJA6XCbRAUBuYVjSJ5PHFi4COyqDORxC37LLfQ,10379
+afp/api/trading.py,sha256=y5Q2KApEpUau9R8G9KUqOdm4ymhw9Hbu9d2dkG80AsQ,17262
 afp/auth.py,sha256=sV_9E6CgRWV1xYoppc4IdrnqNo5ZNDBIp6QF3fQbMWE,2055
 afp/bindings/__init__.py,sha256=_n9xoogYi8AAlSx_PE-wjnwP1ujVyDUwoRM0BSm243U,1271
 afp/bindings/auctioneer_facet.py,sha256=4p906zdU2lUsqpWlsiLE3dlxTPrlNpqk8DtjiQUWJ8M,23919
@@ -22,16 +22,16 @@ afp/bindings/product_registry.py,sha256=-_h786jzMCsaTqqnoxpmVgBkGf45eCUMthp_Pkqr
 afp/bindings/system_viewer.py,sha256=0FivdhpfXMrBesXcHkfO9uELyr7GiRmGe36xS5sURGE,41094
 afp/bindings/trading_protocol.py,sha256=ZloF3REbjFq9v0UGVsM0_Lk0EhfWJKdeJ0PzVEnyZo0,39573
 afp/config.py,sha256=_WKywiuty8poE1A0v46uBe1JGpfCzRlxCPamKennfpE,699
-afp/constants.py,sha256=XIph4R0Tx-BPw_NZJgWUtb7NdS9sYzEciFRSStm3VMs,1840
+afp/constants.py,sha256=EvDhLpKBOsc8OHGm1paiUAdAetPGD4nyi13coB8rd14,1930
 afp/decorators.py,sha256=SEUQtbgPGc4iVPtBQV2eiCejcDAVImmXcI0uPXFhtJA,2774
-afp/enums.py,sha256=U5b_3RteMiVJozp4WYAKzUfPXI1RdJLEK19jAg-LN8Q,588
+afp/enums.py,sha256=9JhwdLcTNhyKabKdrALAlCeL3C5XfeXYSSSXSCsuTzE,688
 afp/exceptions.py,sha256=frdS-EH84K0fOf92RgRgNkTe3VII2m36XNCS8eyXLLM,390
-afp/exchange.py,sha256=MXQ-RhcI76l6bA9_IDTUq0RQGfwxBisrRhl6eC_yH4I,5983
+afp/exchange.py,sha256=QQAfglOzsxo_T0BUOFAkxI2wUbda1sKStMXUO9IcDbw,7498
 afp/hashing.py,sha256=gBCWN93-ydRPlgnnorSvDQlylcnglrAypRDb-1K-20I,1949
 afp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-afp/schemas.py,sha256=M6qr0GhCeT7KevzOso5dIhydYzaYx78Rs66IWdadJO8,5284
+afp/schemas.py,sha256=zyZOPvAdDnXp60kqYqX-OoWnKvRLPZT7at0A0MHlurc,6746
 afp/validators.py,sha256=zQvPu3HDu6ADnEE72EJlS5hc1-xfru78Mzd74s1u_EM,1841
-afp_sdk-0.5.1.dist-info/licenses/LICENSE,sha256=ZdaKItgc2ppfqta2OJV0oHpSJiK87PUxmUkUo-_0SB8,1065
-afp_sdk-0.5.1.dist-info/WHEEL,sha256=lh7MMMfiuFQLQaR9J7pNBODdWf-aa5UOeuuDAol3xps,79
-afp_sdk-0.5.1.dist-info/METADATA,sha256=RM6EyQq2W_ZlrkRtYcGf85pZg7S15poSNJq7CUEHz0w,6354
-afp_sdk-0.5.1.dist-info/RECORD,,
+afp_sdk-0.5.3.dist-info/licenses/LICENSE,sha256=ZdaKItgc2ppfqta2OJV0oHpSJiK87PUxmUkUo-_0SB8,1065
+afp_sdk-0.5.3.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+afp_sdk-0.5.3.dist-info/METADATA,sha256=__Jo9oroNSkI1O9-vAOSA2HrSEONWX95AB4nLKkrjg0,6354
+afp_sdk-0.5.3.dist-info/RECORD,,

{afp_sdk-0.5.1.dist-info → afp_sdk-0.5.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.20
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any