victorycode-sdk 1.0.0__py3-none-any.whl

victorycode_sdk/models/fetch_team_response_dto.py

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from victorycode_sdk.models.classification import Classification
+from victorycode_sdk.models.mascot import Mascot
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FetchTeamResponseDto(BaseModel):
+    """
+    FetchTeamResponseDto
+    """ # noqa: E501
+    id: StrictStr = Field(alias="_id", json_schema_extra={"examples": ["69c0bf178817c85a7d11b716"]})
+    name: StrictStr = Field(json_schema_extra={"examples": ["JAK"]})
+    short_name: StrictStr = Field(alias="shortName", json_schema_extra={"examples": ["JA"]})
+    sport: StrictStr = Field(json_schema_extra={"examples": ["FOOTBALL"]})
+    city: StrictStr = Field(json_schema_extra={"examples": ["Kathmandu"]})
+    state: StrictStr = Field(json_schema_extra={"examples": ["Alaska"]})
+    mascots: Mascot
+    classification: List[Classification] = Field(json_schema_extra={"examples": [[{"_id": "69b13dc5172b65400e926b31", "name": "GRANT_CLS_315"}]]})
+    created_at: StrictStr = Field(alias="createdAt", json_schema_extra={"examples": ["2026-03-23T04:18:31.588Z"]})
+    updated_at: StrictStr = Field(alias="updatedAt", json_schema_extra={"examples": ["2026-03-23T04:18:31.588Z"]})
+    __properties: ClassVar[List[str]] = ["_id", "name", "shortName", "sport", "city", "state", "mascots", "classification", "createdAt", "updatedAt"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FetchTeamResponseDto 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 mascots
+        if self.mascots:
+            _dict['mascots'] = self.mascots.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in classification (list)
+        _items = []
+        if self.classification:
+            for _item_classification in self.classification:
+                _items.append(_item_classification.to_dict() if _item_classification is not None else None)
+            _dict['classification'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FetchTeamResponseDto 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"),
+            "name": obj.get("name"),
+            "shortName": obj.get("shortName"),
+            "sport": obj.get("sport"),
+            "city": obj.get("city"),
+            "state": obj.get("state"),
+            "mascots": Mascot.from_dict(obj["mascots"]) if obj.get("mascots") is not None else None,
+            "classification": [Classification.from_dict(_item) for _item in obj["classification"]] if obj.get("classification") is not None else None,
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt")
+        })
+        return _obj
+
+

victorycode_sdk/models/fumble_section_dto.py

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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
+from typing import Any, ClassVar, Dict, List
+from victorycode_sdk.models.fumble_stats_dto import FumbleStatsDto
+from victorycode_sdk.models.fumble_totals_dto import FumbleTotalsDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FumbleSectionDto(BaseModel):
+    """
+    FumbleSectionDto
+    """ # noqa: E501
+    players: List[FumbleStatsDto]
+    totals: FumbleTotalsDto
+    __properties: ClassVar[List[str]] = ["players", "totals"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FumbleSectionDto 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 players (list)
+        _items = []
+        if self.players:
+            for _item_players in self.players:
+                _items.append(_item_players.to_dict() if _item_players is not None else None)
+            _dict['players'] = _items
+        # override the default output from pydantic by calling `to_dict()` of totals
+        if self.totals:
+            _dict['totals'] = self.totals.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FumbleSectionDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "players": [FumbleStatsDto.from_dict(_item) for _item in obj["players"]] if obj.get("players") is not None else None,
+            "totals": FumbleTotalsDto.from_dict(obj["totals"]) if obj.get("totals") is not None else None
+        })
+        return _obj
+
+

victorycode_sdk/models/fumble_stats_dto.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FumbleStatsDto(BaseModel):
+    """
+    FumbleStatsDto
+    """ # noqa: E501
+    player_name: StrictStr = Field(alias="playerName", json_schema_extra={"examples": ["Josh Jacobs"]})
+    jersey_number: Union[StrictFloat, StrictInt] = Field(alias="jerseyNumber", json_schema_extra={"examples": [8]})
+    player_id: StrictStr = Field(alias="playerId", json_schema_extra={"examples": ["rb26"]})
+    fumbles: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [1]})
+    lost: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    recovered: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    __properties: ClassVar[List[str]] = ["playerName", "jerseyNumber", "playerId", "fumbles", "lost", "recovered"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FumbleStatsDto 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 FumbleStatsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "playerName": obj.get("playerName"),
+            "jerseyNumber": obj.get("jerseyNumber"),
+            "playerId": obj.get("playerId"),
+            "fumbles": obj.get("fumbles"),
+            "lost": obj.get("lost"),
+            "recovered": obj.get("recovered")
+        })
+        return _obj
+
+

victorycode_sdk/models/fumble_totals_dto.py

@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FumbleTotalsDto(BaseModel):
+    """
+    FumbleTotalsDto
+    """ # noqa: E501
+    fumbles: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [1]})
+    lost: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    recovered: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    __properties: ClassVar[List[str]] = ["fumbles", "lost", "recovered"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FumbleTotalsDto 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 FumbleTotalsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fumbles": obj.get("fumbles"),
+            "lost": obj.get("lost"),
+            "recovered": obj.get("recovered")
+        })
+        return _obj
+
+

victorycode_sdk/models/game_all_play_list_item_dto.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from victorycode_sdk.models.play_attributes_list_dto import PlayAttributesListDto
+from victorycode_sdk.models.play_clip_list_details_dto import PlayClipListDetailsDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class GameAllPlayListItemDto(BaseModel):
+    """
+    GameAllPlayListItemDto
+    """ # noqa: E501
+    play_id: StrictStr = Field(alias="playId", json_schema_extra={"examples": ["play-id"]})
+    play_number: Union[StrictFloat, StrictInt] = Field(alias="playNumber", json_schema_extra={"examples": [1]})
+    clip: PlayClipListDetailsDto
+    attributes: PlayAttributesListDto
+    events: List[Dict[str, Any]] = Field(json_schema_extra={"examples": [[]]})
+    video_id: StrictStr = Field(alias="videoId", json_schema_extra={"examples": ["video-id"]})
+    __properties: ClassVar[List[str]] = ["playId", "playNumber", "clip", "attributes", "events", "videoId"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of GameAllPlayListItemDto 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 clip
+        if self.clip:
+            _dict['clip'] = self.clip.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GameAllPlayListItemDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "playId": obj.get("playId"),
+            "playNumber": obj.get("playNumber"),
+            "clip": PlayClipListDetailsDto.from_dict(obj["clip"]) if obj.get("clip") is not None else None,
+            "attributes": PlayAttributesListDto.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "events": obj.get("events"),
+            "videoId": obj.get("videoId")
+        })
+        return _obj
+
+

victorycode_sdk/models/game_box_score_meta_dto.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Victory Code Client API
+
+    Client APIs for Tactix partners: authenticate, upload game video, and retrieve games, plays, game recaps and team metadata.
+
+    The version of the OpenAPI document: 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class GameBoxScoreMetaDto(BaseModel):
+    """
+    GameBoxScoreMetaDto
+    """ # noqa: E501
+    game_id: StrictStr = Field(alias="gameId", json_schema_extra={"examples": ["69e726ec40948bc7f421f3ba"]})
+    game_title: StrictStr = Field(alias="gameTitle", json_schema_extra={"examples": ["Green Bay Packers vs Philadelphia Eagles"]})
+    video_id: StrictStr = Field(alias="videoId", json_schema_extra={"examples": ["69e726ec40948bc7f421f3ba"]})
+    view_type: StrictStr = Field(alias="viewType", json_schema_extra={"examples": ["All-22 Sideline"]})
+    home_team: StrictStr = Field(alias="homeTeam", json_schema_extra={"examples": ["Green Bay Packers"]})
+    away_team: StrictStr = Field(alias="awayTeam", json_schema_extra={"examples": ["Philadelphia Eagles"]})
+    home_score: Union[StrictFloat, StrictInt] = Field(alias="homeScore", json_schema_extra={"examples": [20]})
+    away_score: Union[StrictFloat, StrictInt] = Field(alias="awayScore", json_schema_extra={"examples": [34]})
+    generated_at: StrictStr = Field(description="ISO 8601 timestamp", alias="generatedAt", json_schema_extra={"examples": ["2025-07-14T10:30:00.000Z"]})
+    __properties: ClassVar[List[str]] = ["gameId", "gameTitle", "videoId", "viewType", "homeTeam", "awayTeam", "homeScore", "awayScore", "generatedAt"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of GameBoxScoreMetaDto 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 GameBoxScoreMetaDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "gameId": obj.get("gameId"),
+            "gameTitle": obj.get("gameTitle"),
+            "videoId": obj.get("videoId"),
+            "viewType": obj.get("viewType"),
+            "homeTeam": obj.get("homeTeam"),
+            "awayTeam": obj.get("awayTeam"),
+            "homeScore": obj.get("homeScore"),
+            "awayScore": obj.get("awayScore"),
+            "generatedAt": obj.get("generatedAt")
+        })
+        return _obj
+
+