victorycode-sdk 1.0.0__py3-none-any.whl

victorycode_sdk/models/play_clip_list_item_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 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 PlayClipListItemDto(BaseModel):
+    """
+    PlayClipListItemDto
+    """ # 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": [[]]})
+    __properties: ClassVar[List[str]] = ["playId", "playNumber", "clip", "attributes", "events"]
+
+    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 PlayClipListItemDto 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 PlayClipListItemDto 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")
+        })
+        return _obj
+
+

victorycode_sdk/models/pro_scoring_play_dto.py

@@ -0,0 +1,202 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from victorycode_sdk.models.scoring_play_player_involved_dto import ScoringPlayPlayerInvolvedDto
+from victorycode_sdk.models.scoring_summary_pro_team_dto import ScoringSummaryProTeamDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProScoringPlayDto(BaseModel):
+    """
+    ProScoringPlayDto
+    """ # noqa: E501
+    drive_number: Optional[Union[StrictFloat, StrictInt]] = Field(alias="driveNumber")
+    drive_plays_count: Union[StrictFloat, StrictInt] = Field(alias="drivePlaysCount")
+    drive_yards: Optional[Union[StrictFloat, StrictInt]] = Field(alias="driveYards")
+    drive_time_of_possession: Optional[StrictStr] = Field(alias="driveTimeOfPossession")
+    play_id: StrictStr = Field(alias="playId")
+    team_id: StrictStr = Field(alias="teamId")
+    team: ScoringSummaryProTeamDto
+    period: Optional[Union[StrictFloat, StrictInt]]
+    game_clock: Optional[StrictStr] = Field(alias="gameClock")
+    scoring_type: StrictStr = Field(alias="scoringType")
+    scoring_method: StrictStr = Field(alias="scoringMethod")
+    try_type: Optional[StrictStr] = Field(alias="tryType")
+    try_method: Optional[StrictStr] = Field(alias="tryMethod")
+    scoring_yardage: Union[StrictFloat, StrictInt] = Field(alias="scoringYardage")
+    players_involved: List[ScoringPlayPlayerInvolvedDto] = Field(alias="playersInvolved")
+    away_team_score: Union[StrictFloat, StrictInt] = Field(alias="awayTeamScore")
+    home_team_score: Union[StrictFloat, StrictInt] = Field(alias="homeTeamScore")
+    scoring_text: StrictStr = Field(alias="scoringText")
+    __properties: ClassVar[List[str]] = ["driveNumber", "drivePlaysCount", "driveYards", "driveTimeOfPossession", "playId", "teamId", "team", "period", "gameClock", "scoringType", "scoringMethod", "tryType", "tryMethod", "scoringYardage", "playersInvolved", "awayTeamScore", "homeTeamScore", "scoringText"]
+
+    @field_validator('scoring_type')
+    def scoring_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['TOUCHDOWN', 'FIELD_GOAL', 'SAFETY']):
+            raise ValueError("must be one of enum values ('TOUCHDOWN', 'FIELD_GOAL', 'SAFETY')")
+        return value
+
+    @field_validator('scoring_method')
+    def scoring_method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['RUN', 'PASS', 'FIELD_GOAL', 'KICKOFF', 'PUNT', 'EXTRA_POINT', 'TWO_POINT_CONVERSION', 'NO_PLAY', 'UNIDENTIFIABLE']):
+            raise ValueError("must be one of enum values ('RUN', 'PASS', 'FIELD_GOAL', 'KICKOFF', 'PUNT', 'EXTRA_POINT', 'TWO_POINT_CONVERSION', 'NO_PLAY', 'UNIDENTIFIABLE')")
+        return value
+
+    @field_validator('try_type')
+    def try_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['EXTRA_POINT', 'TWO_POINT_CONVERSION']):
+            raise ValueError("must be one of enum values ('EXTRA_POINT', 'TWO_POINT_CONVERSION')")
+        return value
+
+    @field_validator('try_method')
+    def try_method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['RUN', 'PASS', 'FIELD_GOAL', 'KICKOFF', 'PUNT', 'EXTRA_POINT', 'TWO_POINT_CONVERSION', 'NO_PLAY', 'UNIDENTIFIABLE']):
+            raise ValueError("must be one of enum values ('RUN', 'PASS', 'FIELD_GOAL', 'KICKOFF', 'PUNT', 'EXTRA_POINT', 'TWO_POINT_CONVERSION', 'NO_PLAY', 'UNIDENTIFIABLE')")
+        return value
+
+    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 ProScoringPlayDto 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 team
+        if self.team:
+            _dict['team'] = self.team.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in players_involved (list)
+        _items = []
+        if self.players_involved:
+            for _item_players_involved in self.players_involved:
+                _items.append(_item_players_involved.to_dict() if _item_players_involved is not None else None)
+            _dict['playersInvolved'] = _items
+        # set to None if drive_number (nullable) is None
+        # and model_fields_set contains the field
+        if self.drive_number is None and "drive_number" in self.model_fields_set:
+            _dict['driveNumber'] = None
+
+        # set to None if drive_yards (nullable) is None
+        # and model_fields_set contains the field
+        if self.drive_yards is None and "drive_yards" in self.model_fields_set:
+            _dict['driveYards'] = None
+
+        # set to None if drive_time_of_possession (nullable) is None
+        # and model_fields_set contains the field
+        if self.drive_time_of_possession is None and "drive_time_of_possession" in self.model_fields_set:
+            _dict['driveTimeOfPossession'] = None
+
+        # set to None if period (nullable) is None
+        # and model_fields_set contains the field
+        if self.period is None and "period" in self.model_fields_set:
+            _dict['period'] = None
+
+        # set to None if game_clock (nullable) is None
+        # and model_fields_set contains the field
+        if self.game_clock is None and "game_clock" in self.model_fields_set:
+            _dict['gameClock'] = None
+
+        # set to None if try_type (nullable) is None
+        # and model_fields_set contains the field
+        if self.try_type is None and "try_type" in self.model_fields_set:
+            _dict['tryType'] = None
+
+        # set to None if try_method (nullable) is None
+        # and model_fields_set contains the field
+        if self.try_method is None and "try_method" in self.model_fields_set:
+            _dict['tryMethod'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProScoringPlayDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "driveNumber": obj.get("driveNumber"),
+            "drivePlaysCount": obj.get("drivePlaysCount"),
+            "driveYards": obj.get("driveYards"),
+            "driveTimeOfPossession": obj.get("driveTimeOfPossession"),
+            "playId": obj.get("playId"),
+            "teamId": obj.get("teamId"),
+            "team": ScoringSummaryProTeamDto.from_dict(obj["team"]) if obj.get("team") is not None else None,
+            "period": obj.get("period"),
+            "gameClock": obj.get("gameClock"),
+            "scoringType": obj.get("scoringType"),
+            "scoringMethod": obj.get("scoringMethod"),
+            "tryType": obj.get("tryType"),
+            "tryMethod": obj.get("tryMethod"),
+            "scoringYardage": obj.get("scoringYardage"),
+            "playersInvolved": [ScoringPlayPlayerInvolvedDto.from_dict(_item) for _item in obj["playersInvolved"]] if obj.get("playersInvolved") is not None else None,
+            "awayTeamScore": obj.get("awayTeamScore"),
+            "homeTeamScore": obj.get("homeTeamScore"),
+            "scoringText": obj.get("scoringText")
+        })
+        return _obj
+
+

victorycode_sdk/models/receiving_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.receiving_stats_dto import ReceivingStatsDto
+from victorycode_sdk.models.receiving_totals_dto import ReceivingTotalsDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ReceivingSectionDto(BaseModel):
+    """
+    ReceivingSectionDto
+    """ # noqa: E501
+    players: List[ReceivingStatsDto]
+    totals: ReceivingTotalsDto
+    __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 ReceivingSectionDto 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 ReceivingSectionDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "players": [ReceivingStatsDto.from_dict(_item) for _item in obj["players"]] if obj.get("players") is not None else None,
+            "totals": ReceivingTotalsDto.from_dict(obj["totals"]) if obj.get("totals") is not None else None
+        })
+        return _obj
+
+

victorycode_sdk/models/receiving_stats_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 ReceivingStatsDto(BaseModel):
+    """
+    ReceivingStatsDto
+    """ # noqa: E501
+    player_name: StrictStr = Field(alias="playerName", json_schema_extra={"examples": ["DeVonta Smith"]})
+    jersey_number: Union[StrictFloat, StrictInt] = Field(alias="jerseyNumber", json_schema_extra={"examples": [6]})
+    player_id: StrictStr = Field(alias="playerId", json_schema_extra={"examples": ["wr6"]})
+    receptions: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [4]})
+    yards: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [55]})
+    avg: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [13.8]})
+    touchdowns: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    long: Union[StrictFloat, StrictInt] = Field(description="Longest reception in yards", json_schema_extra={"examples": [28]})
+    targets: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [4]})
+    __properties: ClassVar[List[str]] = ["playerName", "jerseyNumber", "playerId", "receptions", "yards", "avg", "touchdowns", "long", "targets"]
+
+    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 ReceivingStatsDto 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 ReceivingStatsDto 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"),
+            "receptions": obj.get("receptions"),
+            "yards": obj.get("yards"),
+            "avg": obj.get("avg"),
+            "touchdowns": obj.get("touchdowns"),
+            "long": obj.get("long"),
+            "targets": obj.get("targets")
+        })
+        return _obj
+
+

victorycode_sdk/models/receiving_totals_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
+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 ReceivingTotalsDto(BaseModel):
+    """
+    ReceivingTotalsDto
+    """ # noqa: E501
+    receptions: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [4]})
+    yards: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [55]})
+    avg: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [13.8]})
+    touchdowns: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [0]})
+    long: Union[StrictFloat, StrictInt] = Field(description="Longest reception in yards", json_schema_extra={"examples": [28]})
+    targets: Union[StrictFloat, StrictInt] = Field(json_schema_extra={"examples": [4]})
+    __properties: ClassVar[List[str]] = ["receptions", "yards", "avg", "touchdowns", "long", "targets"]
+
+    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 ReceivingTotalsDto 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 ReceivingTotalsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "receptions": obj.get("receptions"),
+            "yards": obj.get("yards"),
+            "avg": obj.get("avg"),
+            "touchdowns": obj.get("touchdowns"),
+            "long": obj.get("long"),
+            "targets": obj.get("targets")
+        })
+        return _obj
+
+