chainstream-sdk 0.1.0__py3-none-any.whl

chainstream/openapi_client/models/create_red_packet_reply.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateRedPacketReply(BaseModel):
+    """
+    CreateRedPacketReply
+    """ # noqa: E501
+    tx_serialize: StrictStr = Field(description="DTO.RED_PACKET.SERIALIZED_TX", alias="txSerialize")
+    share_id: StrictStr = Field(description="DTO.RED_PACKET.SHARE_ID", alias="shareId")
+    __properties: ClassVar[List[str]] = ["txSerialize", "shareId"]
+
+    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 CreateRedPacketReply 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 CreateRedPacketReply from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "txSerialize": obj.get("txSerialize"),
+            "shareId": obj.get("shareId")
+        })
+        return _obj
+
+

chainstream/openapi_client/models/create_token_input.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateTokenInput(BaseModel):
+    """
+    CreateTokenInput
+    """ # noqa: E501
+    dex: StrictStr = Field(description="DTO.DEX.IDENTIFIER")
+    user_address: Annotated[str, Field(min_length=8, strict=True, max_length=64)] = Field(description="DTO.DEX.WALLET", alias="userAddress")
+    priority_fee: Optional[StrictStr] = Field(default=None, description="DTO.DEX.BASE.PRIORITY_FEE", alias="priorityFee")
+    name: Annotated[str, Field(min_length=1, strict=True, max_length=32)] = Field(description="DTO.DEX.MINT.NAME")
+    symbol: Annotated[str, Field(min_length=1, strict=True, max_length=10)] = Field(description="DTO.DEX.MINT.SYMBOL")
+    uri: Optional[StrictStr] = Field(default=None, description="DTO.DEX.MINT.URI")
+    image: Optional[StrictStr] = Field(default=None, description="DTO.DEX.MINT.IMAGE")
+    extra: Optional[Dict[str, Any]] = Field(default=None, description="DTO.DEX.MINT.EXTRA")
+    __properties: ClassVar[List[str]] = ["dex", "userAddress", "priorityFee", "name", "symbol", "uri", "image", "extra"]
+
+    @field_validator('dex')
+    def dex_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['raydium', 'pumpfun', 'moonshot', 'candy', 'launchpad']):
+            raise ValueError("must be one of enum values ('raydium', 'pumpfun', 'moonshot', 'candy', 'launchpad')")
+        return value
+
+    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 CreateTokenInput 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 CreateTokenInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dex": obj.get("dex"),
+            "userAddress": obj.get("userAddress"),
+            "priorityFee": obj.get("priorityFee"),
+            "name": obj.get("name"),
+            "symbol": obj.get("symbol"),
+            "uri": obj.get("uri"),
+            "image": obj.get("image"),
+            "extra": obj.get("extra")
+        })
+        return _obj
+
+

chainstream/openapi_client/models/create_token_reply.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CreateTokenReply(BaseModel):
+    """
+    CreateTokenReply
+    """ # noqa: E501
+    serialized_tx: StrictStr = Field(description="DTO.DEX.CREATE_TOKEN.SERIALIZED_TX", alias="serializedTx")
+    mint_address: StrictStr = Field(description="DTO.DEX.CREATE_TOKEN.MINT_ADDRESS", alias="mintAddress")
+    __properties: ClassVar[List[str]] = ["serializedTx", "mintAddress"]
+
+    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 CreateTokenReply 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 CreateTokenReply from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "serializedTx": obj.get("serializedTx"),
+            "mintAddress": obj.get("mintAddress")
+        })
+        return _obj
+
+

chainstream/openapi_client/models/dev_token_dto.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from chainstream.openapi_client.models.token_market_data import TokenMarketData
+from chainstream.openapi_client.models.token_metadata import TokenMetadata
+from chainstream.openapi_client.models.token_stat import TokenStat
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DevTokenDTO(BaseModel):
+    """
+    DevTokenDTO
+    """ # noqa: E501
+    address: StrictStr = Field(description="DTO.DEV_TOKEN.ADDRESS")
+    metadata: TokenMetadata = Field(description="DTO.DEV_TOKEN.METADATA")
+    market_data: TokenMarketData = Field(description="DTO.DEV_TOKEN.MARKET_DATA", alias="marketData")
+    stats: TokenStat = Field(description="DTO.DEV_TOKEN.STATS")
+    __properties: ClassVar[List[str]] = ["address", "metadata", "marketData", "stats"]
+
+    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 DevTokenDTO 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of metadata
+        if self.metadata:
+            _dict['metadata'] = self.metadata.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of market_data
+        if self.market_data:
+            _dict['marketData'] = self.market_data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of stats
+        if self.stats:
+            _dict['stats'] = self.stats.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DevTokenDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "address": obj.get("address"),
+            "metadata": TokenMetadata.from_dict(obj["metadata"]) if obj.get("metadata") is not None else None,
+            "marketData": TokenMarketData.from_dict(obj["marketData"]) if obj.get("marketData") is not None else None,
+            "stats": TokenStat.from_dict(obj["stats"]) if obj.get("stats") is not None else None
+        })
+        return _obj
+
+

chainstream/openapi_client/models/dex_dto.py

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DexDTO(BaseModel):
+    """
+    DexDTO
+    """ # noqa: E501
+    program_address: Optional[StrictStr] = Field(default=None, description="DTO.DEX.PROGRAM_ADDRESS", alias="programAddress")
+    protocol_family: Optional[StrictStr] = Field(default=None, description="DTO.DEX.PROTOCOL_FAMILY", alias="protocolFamily")
+    image: Optional[StrictStr] = Field(default=None, description="DTO.DEX.IMAGE")
+    chain: StrictStr = Field(description="DTO.DEX.CHAIN")
+    __properties: ClassVar[List[str]] = ["programAddress", "protocolFamily", "image", "chain"]
+
+    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 DexDTO 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 DexDTO from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "programAddress": obj.get("programAddress"),
+            "protocolFamily": obj.get("protocolFamily"),
+            "image": obj.get("image"),
+            "chain": obj.get("chain")
+        })
+        return _obj
+
+

chainstream/openapi_client/models/dex_page.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    Dex Aggregator API
+
+    Dex Aggregator API ⚡️
+
+    The version of the OpenAPI document: 1.0
+    Contact: ai@sx.ai
+    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 chainstream.openapi_client.models.dex_dto import DexDTO
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DexPage(BaseModel):
+    """
+    DexPage
+    """ # noqa: E501
+    has_next: Optional[StrictBool] = Field(default=False, description="DTO.PAGE.HAS_NEXT", alias="hasNext")
+    has_prev: Optional[StrictBool] = Field(default=False, description="DTO.PAGE.HAS_PREV", alias="hasPrev")
+    start_cursor: Optional[StrictStr] = Field(default=None, description="DTO.PAGE.START_CURSOR", alias="startCursor")
+    end_cursor: Optional[StrictStr] = Field(default=None, description="DTO.PAGE.END_CURSOR", alias="endCursor")
+    total: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="DTO.PAGE.TOTAL")
+    data: List[DexDTO] = Field(description="DTO.DEX.PAGE.DATA")
+    __properties: ClassVar[List[str]] = ["hasNext", "hasPrev", "startCursor", "endCursor", "total", "data"]
+
+    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 DexPage 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+        _items = []
+        if self.data:
+            for _item_data in self.data:
+                if _item_data:
+                    _items.append(_item_data.to_dict())
+            _dict['data'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of DexPage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "hasNext": obj.get("hasNext") if obj.get("hasNext") is not None else False,
+            "hasPrev": obj.get("hasPrev") if obj.get("hasPrev") is not None else False,
+            "startCursor": obj.get("startCursor"),
+            "endCursor": obj.get("endCursor"),
+            "total": obj.get("total"),
+            "data": [DexDTO.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
+        })
+        return _obj
+
+