kalshi-python-async 3.0.0__py3-none-any.whl

kalshi_python_async/models/get_tags_for_series_categories_response.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetTagsForSeriesCategoriesResponse(BaseModel):
+    """
+    GetTagsForSeriesCategoriesResponse
+    """ # noqa: E501
+    tags_by_categories: Dict[str, List[StrictStr]] = Field(description="Mapping of series categories to their associated tags")
+    __properties: ClassVar[List[str]] = ["tags_by_categories"]
+
+    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 GetTagsForSeriesCategoriesResponse 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 GetTagsForSeriesCategoriesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "tags_by_categories": obj.get("tags_by_categories")
+        })
+        return _obj
+
+

kalshi_python_async/models/get_trades_response.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from kalshi_python_async.models.trade import Trade
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetTradesResponse(BaseModel):
+    """
+    GetTradesResponse
+    """ # noqa: E501
+    trades: List[Trade]
+    cursor: StrictStr
+    __properties: ClassVar[List[str]] = ["trades", "cursor"]
+
+    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 GetTradesResponse 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 trades (list)
+        _items = []
+        if self.trades:
+            for _item_trades in self.trades:
+                if _item_trades:
+                    _items.append(_item_trades.to_dict())
+            _dict['trades'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetTradesResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "trades": [Trade.from_dict(_item) for _item in obj["trades"]] if obj.get("trades") is not None else None,
+            "cursor": obj.get("cursor")
+        })
+        return _obj
+
+

kalshi_python_async/models/get_user_data_timestamp_response.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GetUserDataTimestampResponse(BaseModel):
+    """
+    GetUserDataTimestampResponse
+    """ # noqa: E501
+    as_of_time: datetime = Field(description="Timestamp when user data was last updated.")
+    __properties: ClassVar[List[str]] = ["as_of_time"]
+
+    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 GetUserDataTimestampResponse 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 GetUserDataTimestampResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "as_of_time": obj.get("as_of_time")
+        })
+        return _obj
+
+

kalshi_python_async/models/incentive_program.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class IncentiveProgram(BaseModel):
+    """
+    IncentiveProgram
+    """ # noqa: E501
+    id: StrictStr = Field(description="Unique identifier for the incentive program")
+    market_ticker: StrictStr = Field(description="The ticker symbol of the market associated with this incentive program")
+    incentive_type: StrictStr = Field(description="Type of incentive program")
+    start_date: datetime = Field(description="Start date of the incentive program")
+    end_date: datetime = Field(description="End date of the incentive program")
+    period_reward: StrictInt = Field(description="Total reward for the period in centi-cents")
+    paid_out: StrictBool = Field(description="Whether the incentive has been paid out")
+    discount_factor_bps: Optional[StrictInt] = Field(default=None, description="Discount factor in basis points (optional)")
+    target_size: Optional[StrictInt] = Field(default=None, description="Target size for the incentive program (optional)")
+    __properties: ClassVar[List[str]] = ["id", "market_ticker", "incentive_type", "start_date", "end_date", "period_reward", "paid_out", "discount_factor_bps", "target_size"]
+
+    @field_validator('incentive_type')
+    def incentive_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['liquidity', 'volume']):
+            raise ValueError("must be one of enum values ('liquidity', 'volume')")
+        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 IncentiveProgram 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 discount_factor_bps (nullable) is None
+        # and model_fields_set contains the field
+        if self.discount_factor_bps is None and "discount_factor_bps" in self.model_fields_set:
+            _dict['discount_factor_bps'] = None
+
+        # set to None if target_size (nullable) is None
+        # and model_fields_set contains the field
+        if self.target_size is None and "target_size" in self.model_fields_set:
+            _dict['target_size'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IncentiveProgram from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "market_ticker": obj.get("market_ticker"),
+            "incentive_type": obj.get("incentive_type"),
+            "start_date": obj.get("start_date"),
+            "end_date": obj.get("end_date"),
+            "period_reward": obj.get("period_reward"),
+            "paid_out": obj.get("paid_out"),
+            "discount_factor_bps": obj.get("discount_factor_bps"),
+            "target_size": obj.get("target_size")
+        })
+        return _obj
+
+

kalshi_python_async/models/live_data.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LiveData(BaseModel):
+    """
+    LiveData
+    """ # noqa: E501
+    type: StrictStr = Field(description="Type of live data")
+    details: Dict[str, Any] = Field(description="Live data details as a flexible object")
+    milestone_id: StrictStr = Field(description="Milestone ID")
+    __properties: ClassVar[List[str]] = ["type", "details", "milestone_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 LiveData 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 LiveData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "details": obj.get("details"),
+            "milestone_id": obj.get("milestone_id")
+        })
+        return _obj
+
+

kalshi_python_async/models/lookup_point.py

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from kalshi_python_async.models.ticker_pair import TickerPair
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LookupPoint(BaseModel):
+    """
+    LookupPoint
+    """ # noqa: E501
+    event_ticker: StrictStr = Field(description="Event ticker for the lookup point.")
+    market_ticker: StrictStr = Field(description="Market ticker for the lookup point.")
+    selected_markets: List[TickerPair] = Field(description="Markets that were selected for this lookup.")
+    last_queried_ts: datetime = Field(description="Timestamp when this lookup was last queried.")
+    __properties: ClassVar[List[str]] = ["event_ticker", "market_ticker", "selected_markets", "last_queried_ts"]
+
+    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 LookupPoint 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 selected_markets (list)
+        _items = []
+        if self.selected_markets:
+            for _item_selected_markets in self.selected_markets:
+                if _item_selected_markets:
+                    _items.append(_item_selected_markets.to_dict())
+            _dict['selected_markets'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of LookupPoint from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "event_ticker": obj.get("event_ticker"),
+            "market_ticker": obj.get("market_ticker"),
+            "selected_markets": [TickerPair.from_dict(_item) for _item in obj["selected_markets"]] if obj.get("selected_markets") is not None else None,
+            "last_queried_ts": obj.get("last_queried_ts")
+        })
+        return _obj
+
+

kalshi_python_async/models/lookup_tickers_for_market_in_multivariate_event_collection_request.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Kalshi Trade API Manual Endpoints
+
+    Manually defined OpenAPI spec for endpoints being migrated to spec-first approach
+
+    The version of the OpenAPI document: 3.0.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
+from typing import Any, ClassVar, Dict, List
+from kalshi_python_async.models.ticker_pair import TickerPair
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LookupTickersForMarketInMultivariateEventCollectionRequest(BaseModel):
+    """
+    LookupTickersForMarketInMultivariateEventCollectionRequest
+    """ # noqa: E501
+    selected_markets: List[TickerPair] = Field(description="List of selected markets that act as parameters to determine which market is produced.")
+    __properties: ClassVar[List[str]] = ["selected_markets"]
+
+    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 LookupTickersForMarketInMultivariateEventCollectionRequest 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 selected_markets (list)
+        _items = []
+        if self.selected_markets:
+            for _item_selected_markets in self.selected_markets:
+                if _item_selected_markets:
+                    _items.append(_item_selected_markets.to_dict())
+            _dict['selected_markets'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of LookupTickersForMarketInMultivariateEventCollectionRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "selected_markets": [TickerPair.from_dict(_item) for _item in obj["selected_markets"]] if obj.get("selected_markets") is not None else None
+        })
+        return _obj
+
+