crypticorn 2.4.5__py3-none-any.whl → 2.4.6__py3-none-any.whl

crypticorn/pay/client/models/payment.py

@@ -18,67 +18,35 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Any, ClassVar, Dict, List, Union
+from crypticorn.pay.client.models.payment_status import PaymentStatus
+from crypticorn.pay.client.models.services import Services
 from typing import Optional, Set
 from typing_extensions import Self
 
 
 class Payment(BaseModel):
     """
-    Model representing a single payment.
+    Combined payment model across all services
     """  # noqa: E501
 
-    payment_id: StrictInt = Field(description="Unique payment identifier")
-    invoice_id: Optional[StrictInt] = None
-    payment_status: StrictStr = Field(description="Current payment status")
-    pay_address: StrictStr = Field(description="Payment destination address")
-    payin_extra_id: Optional[StrictStr] = None
-    price_amount: Union[StrictFloat, StrictInt] = Field(
-        description="Original price amount"
-    )
-    price_currency: StrictStr = Field(description="Original price currency")
-    pay_amount: Union[StrictFloat, StrictInt] = Field(description="Amount to pay")
-    actually_paid: Union[StrictFloat, StrictInt] = Field(
-        description="Actually paid amount"
-    )
-    pay_currency: StrictStr = Field(description="Payment currency")
-    order_id: Optional[StrictStr] = None
-    order_description: Optional[StrictStr] = None
-    purchase_id: Optional[StrictInt] = None
-    outcome_amount: Optional[Union[StrictFloat, StrictInt]] = None
-    outcome_currency: Optional[StrictStr] = None
-    payout_hash: Optional[StrictStr] = None
-    payin_hash: Optional[StrictStr] = None
-    created_at: StrictStr = Field(description="Payment creation timestamp")
-    updated_at: StrictStr = Field(description="Payment last update timestamp")
-    type: StrictStr = Field(description="Type of payment (e.g., crypto2crypto)")
-    payment_extra_ids: Optional[List[StrictInt]] = None
-    parent_payment_id: Optional[StrictInt] = None
-    origin_type: Optional[StrictStr] = None
+    id: StrictStr = Field(description="Payment ID")
+    product_id: StrictStr = Field(description="Product ID")
+    var_date: StrictInt = Field(description="Payment date in seconds", alias="date")
+    amount: Union[StrictFloat, StrictInt] = Field(description="Payment amount")
+    currency: StrictStr = Field(description="Payment currency")
+    status: PaymentStatus
+    service: Services = Field(description="Payment service")
+    market: StrictStr = Field(description="Payment market")
     __properties: ClassVar[List[str]] = [
-        "payment_id",
-        "invoice_id",
-        "payment_status",
-        "pay_address",
-        "payin_extra_id",
-        "price_amount",
-        "price_currency",
-        "pay_amount",
-        "actually_paid",
-        "pay_currency",
-        "order_id",
-        "order_description",
-        "purchase_id",
-        "outcome_amount",
-        "outcome_currency",
-        "payout_hash",
-        "payin_hash",
-        "created_at",
-        "updated_at",
-        "type",
-        "payment_extra_ids",
-        "parent_payment_id",
-        "origin_type",
+        "id",
+        "product_id",
+        "date",
+        "amount",
+        "currency",
+        "status",
+        "service",
+        "market",
     ]
 
     model_config = ConfigDict(
@@ -118,78 +86,6 @@ class Payment(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # set to None if invoice_id (nullable) is None
-        # and model_fields_set contains the field
-        if self.invoice_id is None and "invoice_id" in self.model_fields_set:
-            _dict["invoice_id"] = None
-
-        # set to None if payin_extra_id (nullable) is None
-        # and model_fields_set contains the field
-        if self.payin_extra_id is None and "payin_extra_id" in self.model_fields_set:
-            _dict["payin_extra_id"] = None
-
-        # set to None if order_id (nullable) is None
-        # and model_fields_set contains the field
-        if self.order_id is None and "order_id" in self.model_fields_set:
-            _dict["order_id"] = None
-
-        # set to None if order_description (nullable) is None
-        # and model_fields_set contains the field
-        if (
-            self.order_description is None
-            and "order_description" in self.model_fields_set
-        ):
-            _dict["order_description"] = None
-
-        # set to None if purchase_id (nullable) is None
-        # and model_fields_set contains the field
-        if self.purchase_id is None and "purchase_id" in self.model_fields_set:
-            _dict["purchase_id"] = None
-
-        # set to None if outcome_amount (nullable) is None
-        # and model_fields_set contains the field
-        if self.outcome_amount is None and "outcome_amount" in self.model_fields_set:
-            _dict["outcome_amount"] = None
-
-        # set to None if outcome_currency (nullable) is None
-        # and model_fields_set contains the field
-        if (
-            self.outcome_currency is None
-            and "outcome_currency" in self.model_fields_set
-        ):
-            _dict["outcome_currency"] = None
-
-        # set to None if payout_hash (nullable) is None
-        # and model_fields_set contains the field
-        if self.payout_hash is None and "payout_hash" in self.model_fields_set:
-            _dict["payout_hash"] = None
-
-        # set to None if payin_hash (nullable) is None
-        # and model_fields_set contains the field
-        if self.payin_hash is None and "payin_hash" in self.model_fields_set:
-            _dict["payin_hash"] = None
-
-        # set to None if payment_extra_ids (nullable) is None
-        # and model_fields_set contains the field
-        if (
-            self.payment_extra_ids is None
-            and "payment_extra_ids" in self.model_fields_set
-        ):
-            _dict["payment_extra_ids"] = None
-
-        # set to None if parent_payment_id (nullable) is None
-        # and model_fields_set contains the field
-        if (
-            self.parent_payment_id is None
-            and "parent_payment_id" in self.model_fields_set
-        ):
-            _dict["parent_payment_id"] = None
-
-        # set to None if origin_type (nullable) is None
-        # and model_fields_set contains the field
-        if self.origin_type is None and "origin_type" in self.model_fields_set:
-            _dict["origin_type"] = None
-
         return _dict
 
     @classmethod
@@ -203,29 +99,14 @@ class Payment(BaseModel):
 
         _obj = cls.model_validate(
             {
-                "payment_id": obj.get("payment_id"),
-                "invoice_id": obj.get("invoice_id"),
-                "payment_status": obj.get("payment_status"),
-                "pay_address": obj.get("pay_address"),
-                "payin_extra_id": obj.get("payin_extra_id"),
-                "price_amount": obj.get("price_amount"),
-                "price_currency": obj.get("price_currency"),
-                "pay_amount": obj.get("pay_amount"),
-                "actually_paid": obj.get("actually_paid"),
-                "pay_currency": obj.get("pay_currency"),
-                "order_id": obj.get("order_id"),
-                "order_description": obj.get("order_description"),
-                "purchase_id": obj.get("purchase_id"),
-                "outcome_amount": obj.get("outcome_amount"),
-                "outcome_currency": obj.get("outcome_currency"),
-                "payout_hash": obj.get("payout_hash"),
-                "payin_hash": obj.get("payin_hash"),
-                "created_at": obj.get("created_at"),
-                "updated_at": obj.get("updated_at"),
-                "type": obj.get("type"),
-                "payment_extra_ids": obj.get("payment_extra_ids"),
-                "parent_payment_id": obj.get("parent_payment_id"),
-                "origin_type": obj.get("origin_type"),
+                "id": obj.get("id"),
+                "product_id": obj.get("product_id"),
+                "date": obj.get("date"),
+                "amount": obj.get("amount"),
+                "currency": obj.get("currency"),
+                "status": obj.get("status"),
+                "service": obj.get("service"),
+                "market": obj.get("market"),
             }
         )
         return _obj

crypticorn/pay/client/models/product_create.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+Payment API
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from crypticorn.pay.client.models.scope import Scope
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class ProductCreate(BaseModel):
+    """
+    Model for creating a product
+    """  # noqa: E501
+
+    name: StrictStr = Field(description="Product name")
+    price: Union[StrictFloat, StrictInt] = Field(description="Product price")
+    scopes: Optional[List[Scope]] = None
+    duration: StrictInt = Field(
+        description="Product duration in days. 0 means unlimited."
+    )
+    description: StrictStr = Field(description="Product description")
+    is_active: StrictBool = Field(description="Product is active")
+    __properties: ClassVar[List[str]] = [
+        "name",
+        "price",
+        "scopes",
+        "duration",
+        "description",
+        "is_active",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductCreate from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if scopes (nullable) is None
+        # and model_fields_set contains the field
+        if self.scopes is None and "scopes" in self.model_fields_set:
+            _dict["scopes"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductCreate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "name": obj.get("name"),
+                "price": obj.get("price"),
+                "scopes": obj.get("scopes"),
+                "duration": obj.get("duration"),
+                "description": obj.get("description"),
+                "is_active": obj.get("is_active"),
+            }
+        )
+        return _obj

crypticorn/pay/client/models/product_read.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+Payment API
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from crypticorn.pay.client.models.scope import Scope
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class ProductRead(BaseModel):
+    """
+    Model for reading a product
+    """  # noqa: E501
+
+    name: StrictStr = Field(description="Product name")
+    price: Union[StrictFloat, StrictInt] = Field(description="Product price")
+    scopes: Optional[List[Scope]] = None
+    duration: StrictInt = Field(
+        description="Product duration in days. 0 means unlimited."
+    )
+    description: StrictStr = Field(description="Product description")
+    is_active: StrictBool = Field(description="Product is active")
+    id: StrictStr = Field(description="UID of the product")
+    __properties: ClassVar[List[str]] = [
+        "name",
+        "price",
+        "scopes",
+        "duration",
+        "description",
+        "is_active",
+        "id",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductRead from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if scopes (nullable) is None
+        # and model_fields_set contains the field
+        if self.scopes is None and "scopes" in self.model_fields_set:
+            _dict["scopes"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductRead from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "name": obj.get("name"),
+                "price": obj.get("price"),
+                "scopes": obj.get("scopes"),
+                "duration": obj.get("duration"),
+                "description": obj.get("description"),
+                "is_active": obj.get("is_active"),
+                "id": obj.get("id"),
+            }
+        )
+        return _obj

crypticorn/pay/client/models/product_sub_read.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+Payment API
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class ProductSubRead(BaseModel):
+    """
+    Model for reading a product subscription
+    """  # noqa: E501
+
+    user_id: StrictStr = Field(description="User ID")
+    product_id: StrictStr = Field(description="Product ID")
+    access_from: StrictInt = Field(description="Access from timestamp in milliseconds")
+    access_until: StrictInt = Field(
+        description="Access until timestamp in milliseconds. 0 means unlimited."
+    )
+    id: StrictStr = Field(description="UID of the product subscription")
+    __properties: ClassVar[List[str]] = [
+        "user_id",
+        "product_id",
+        "access_from",
+        "access_until",
+        "id",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductSubRead from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductSubRead from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "user_id": obj.get("user_id"),
+                "product_id": obj.get("product_id"),
+                "access_from": obj.get("access_from"),
+                "access_until": obj.get("access_until"),
+                "id": obj.get("id"),
+            }
+        )
+        return _obj

crypticorn/pay/client/models/product_update.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+Payment API
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from crypticorn.pay.client.models.scope import Scope
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class ProductUpdate(BaseModel):
+    """
+    Model for updating a product
+    """  # noqa: E501
+
+    name: Optional[StrictStr] = None
+    price: Optional[Union[StrictFloat, StrictInt]] = None
+    scopes: Optional[List[Scope]] = None
+    duration: Optional[StrictInt] = None
+    description: Optional[StrictStr] = None
+    is_active: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = [
+        "name",
+        "price",
+        "scopes",
+        "duration",
+        "description",
+        "is_active",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ProductUpdate from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if name (nullable) is None
+        # and model_fields_set contains the field
+        if self.name is None and "name" in self.model_fields_set:
+            _dict["name"] = None
+
+        # set to None if price (nullable) is None
+        # and model_fields_set contains the field
+        if self.price is None and "price" in self.model_fields_set:
+            _dict["price"] = None
+
+        # set to None if scopes (nullable) is None
+        # and model_fields_set contains the field
+        if self.scopes is None and "scopes" in self.model_fields_set:
+            _dict["scopes"] = None
+
+        # set to None if duration (nullable) is None
+        # and model_fields_set contains the field
+        if self.duration is None and "duration" in self.model_fields_set:
+            _dict["duration"] = None
+
+        # set to None if description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict["description"] = None
+
+        # set to None if is_active (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_active is None and "is_active" in self.model_fields_set:
+            _dict["is_active"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProductUpdate from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "name": obj.get("name"),
+                "price": obj.get("price"),
+                "scopes": obj.get("scopes"),
+                "duration": obj.get("duration"),
+                "description": obj.get("description"),
+                "is_active": obj.get("is_active"),
+            }
+        )
+        return _obj