ddapi 0.12.0__tar.gz → 0.12.2__tar.gz

{ddapi-0.12.0 → ddapi-0.12.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: ddapi
-Version: 0.12.0
+Version: 0.12.2
 Summary: DDnet api
 Home-page: https://github.com/ByFox213/ddapi
 Author: ByFox
 License: MIT
 Project-URL: Github, https://github.com/ByFox213/ddapi
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/__init__.py

@@ -1,7 +1,8 @@
 """the module is made for the convenience of users to download and use"""
+
 from .main import DDnetApi, DDstats, Status
 from .scheme import *  # noqa: F403
 
-__version__ = "0.12.0"
+__version__ = "0.12.2"
 __author__ = "ByFox"
 __LICENSE__ = "MIT"

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/api.py

@@ -17,10 +17,10 @@ except ImportError:
 
 class API(ABC):
     def __init__(
-            self,
-            session: ClientSession = None,
-            autoclose: bool = True,
-            json_loads: Any = DEFAULT_JSON_DECODER
+        self,
+        session: ClientSession = None,
+        autoclose: bool = True,
+        json_loads: Any = DEFAULT_JSON_DECODER,
     ):
         self.__session = session
         self.json_loads = json_loads
@@ -49,17 +49,10 @@ class API(ABC):
     async def _get(self, url: str) -> Optional[dict]:
         """Send a GET request to the given URL and return the response as JSON."""
         async with self.__session.get(url) as req:
-            return (
-                await req.json(loads=self.json_loads)
-                if req.status == 200
-                else None
-            )
+            return await req.json(loads=self.json_loads) if req.status == 200 else None
 
     async def _generate_model_instance(
-            self,
-            url: str,
-            model: Type[T],
-            k: Optional[str] = None
+        self, url: str, model: Type[T], k: Optional[str] = None
     ) -> Optional[T]:
         """Generate a model instance from the given URL and optional keyword arguments.
 

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/main.py

@@ -2,17 +2,34 @@ from enum import StrEnum
 from urllib.parse import quote
 
 from .api import API
-from .scheme import DDPlayer, DDStatus, ReleasesMaps, Query, QueryMap, QueryMapper, \
-    Master, DMap, DProfile, SMap, Maps, Player, Info, BannedMaster, List, ListData, \
-    ListPl, ListPlData, MasterTw, ServerTwOne, Charts, ChartEnum, Stats
-
-__all__ = (
-    "MasterEnum",
-    "DDnetApi",
-    "DDstats",
-    "Status"
+from .scheme import (
+    DDPlayer,
+    DDStatus,
+    ReleasesMaps,
+    Query,
+    QueryMap,
+    QueryMapper,
+    Master,
+    DMap,
+    DProfile,
+    SMap,
+    Maps,
+    Player,
+    Info,
+    BannedMaster,
+    List,
+    ListData,
+    ListPl,
+    ListPlData,
+    MasterTw,
+    ServerTwOne,
+    Charts,
+    ChartEnum,
+    Stats,
 )
 
+__all__ = ("MasterEnum", "DDnetApi", "DDstats", "Status")
+
 
 class MasterEnum(StrEnum):
     master1 = "1"
@@ -33,28 +50,22 @@ class DDnetApi(API):
     async def player(self, player: str) -> DDPlayer:
         """Fetch player data from the API and return it as a dictionary."""
         return await self._generate_model_instance(
-            f"https://{self.domain}/players/?json2={quote(player)}",
-            DDPlayer
+            f"https://{self.domain}/players/?json2={quote(player)}", DDPlayer
         )
 
     async def status(self) -> DDStatus:
         return await self._generate_model_instance(
-            f"https://{self.domain}/status/json/stats.json",
-            DDStatus
+            f"https://{self.domain}/status/json/stats.json", DDStatus
         )
 
     async def releases_map(self) -> ReleasesMaps:
         return await self._generate_model_instance(
-            f"https://{self.domain}/releases/maps.json",
-            ReleasesMaps,
-            "maps"
+            f"https://{self.domain}/releases/maps.json", ReleasesMaps, "maps"
         )
 
     async def query(self, player: str) -> Query:
         return await self._generate_model_instance(
-            f"https://{self.domain}/players/?query={quote(player)}",
-            Query,
-            "players"
+            f"https://{self.domain}/players/?query={quote(player)}", Query, "players"
         )
 
     async def query_map(self, map_name: str) -> QueryMap:
@@ -73,14 +84,12 @@ class DDnetApi(API):
 
     async def master(self, number: MasterEnum = MasterEnum.master1) -> Master:
         return await self._generate_model_instance(
-            f"https://master{number}.{self.domain}/ddnet/15/servers.json",
-            Master
+            f"https://master{number}.{self.domain}/ddnet/15/servers.json", Master
         )
 
     async def map(self, map_name: str) -> DMap:
         return await self._generate_model_instance(
-            f"https://{self.domain}/maps/?json={quote(map_name)}",
-            DMap
+            f"https://{self.domain}/maps/?json={quote(map_name)}", DMap
         )
 
 
@@ -97,27 +106,23 @@ class DDstats(API):
         return await self._generate_model_instance(
             f"https://{self.domain}/profile/json?player={quote(player_name)}",
             DProfile,
-            "profile"
+            "profile",
         )
 
     async def map(self, map_name: str) -> SMap:
         return await self._generate_model_instance(
-            f"https://{self.domain}/map/json?map={quote(map_name)}",
-            SMap
+            f"https://{self.domain}/map/json?map={quote(map_name)}", SMap
         )
 
     async def maps(self) -> Maps:
         return await self._generate_model_instance(
-            f"https://{self.domain}/maps/json",
-            Maps,
-            "maps"
+            f"https://{self.domain}/maps/json", Maps, "maps"
         )
 
     async def player(self, player_name: str) -> Player:
         """Fetch player data from the API and return it as a dictionary."""
         return await self._generate_model_instance(
-            f"https://{self.domain}/player/json?player={quote(player_name)}",
-            Player
+            f"https://{self.domain}/player/json?player={quote(player_name)}", Player
         )
 
 
@@ -132,62 +137,48 @@ class Status(API):
 
     async def info(self) -> Info:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/info",
-            Info
+            f"https://api.{self.domain}/info", Info
         )
 
     async def master_bans(self) -> BannedMaster:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/master/bans/list",
-            BannedMaster,
-            "servers"
+            f"https://api.{self.domain}/master/bans/list", BannedMaster, "servers"
         )
 
     async def map_list(self) -> List:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/map/list",
-            List,
-            "data"
+            f"https://api.{self.domain}/map/list", List, "data"
         )
 
     async def map(self, name: str) -> ListData:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/map/name/{quote(name)}",
-            ListData
+            f"https://api.{self.domain}/map/name/{quote(name)}", ListData
         )
 
     async def gametype_list(self) -> List:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/gametype/list",
-            List,
-            "data"
+            f"https://api.{self.domain}/gametype/list", List, "data"
         )
 
     async def gametype(self, name: str) -> ListData:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/gametype/name/{quote(name)}",
-            ListData
+            f"https://api.{self.domain}/gametype/name/{quote(name)}", ListData
         )
 
     async def version_list(self) -> List:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/version/list",
-            List,
-            "data"
+            f"https://api.{self.domain}/version/list", List, "data"
         )
 
     async def version(self, name: str) -> ListData:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/version/name/{quote(name)}",
-            ListData
+            f"https://api.{self.domain}/version/name/{quote(name)}", ListData
         )
 
     async def server_list(self) -> MasterTw:
         """Fetch player data from the API and return it as a dictionary."""
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/server/list",
-            MasterTw,
-            "servers"
+            f"https://api.{self.domain}/server/list", MasterTw, "servers"
         )
 
     async def server(self, ip: str, port: int | str) -> ServerTwOne:
@@ -197,15 +188,12 @@ class Status(API):
         )
 
     async def server_charts(
-            self,
-            ip: str,
-            port: int | str,
-            chart: ChartEnum = ChartEnum.day
+        self, ip: str, port: int | str, chart: ChartEnum = ChartEnum.day
     ) -> Charts:
         return await self._generate_model_instance(
             f"https://api.{self.domain}/server/{quote(ip)}/{port}/chart/{chart}",
             Charts,
-            "charts"
+            "charts",
         )
 
     async def server_history(self, ip: str, port: int | str) -> None:
@@ -218,28 +206,22 @@ class Status(API):
 
     async def clan_list(self) -> ListPl:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/clan/list",
-            ListPl,
-            "data"
+            f"https://api.{self.domain}/clan/list", ListPl, "data"
         )
 
     async def clan(self, name: str) -> ListPlData:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/clan/name/{quote(name)}",
-            ListPlData
+            f"https://api.{self.domain}/clan/name/{quote(name)}", ListPlData
         )
 
     async def player_list(self) -> ListPl:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/player/list",
-            ListPl,
-            "data"
+            f"https://api.{self.domain}/player/list", ListPl, "data"
         )
 
     async def player(self, name: str) -> ListPlData:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/player/name/{quote(name)}",
-            ListPlData
+            f"https://api.{self.domain}/player/name/{quote(name)}", ListPlData
         )
 
     async def player_history(self, name: str) -> None:
@@ -248,8 +230,7 @@ class Status(API):
 
     async def stats(self) -> Stats:
         return await self._generate_model_instance(
-            f"https://api.{self.domain}/stats",
-            Stats
+            f"https://api.{self.domain}/stats", Stats
         )
 
     async def stats_players(self, t: str) -> None:

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/scheme/__init__.py

@@ -1,4 +1,3 @@
-from .base import *  # noqa: F403
 from .ddnet import *  # noqa: F403
 from .ddstats_tw import *  # noqa: F403
 from .status_tw import *  # noqa: F403

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/scheme/ddnet.py

@@ -5,17 +5,43 @@ from typing import Optional, Any
 
 from pydantic import BaseModel, Field
 
-from .base import DDType
-
 rm_list = ["DD-Persian", "/vDQMHSss8W", ""]
 
 
+class DRank(BaseModel):
+    points: Optional[int] = None
+    rank: Optional[int] = None
+
+
 class DPoints(BaseModel):
     total: int
     points: Optional[int] = Field(default=None)
     rank: Optional[int] = Field(default=None)
 
 
+class DData(BaseModel):
+    points: Optional[DPoints] = Field(default=None)
+    team_rank: Optional[DRank] = Field(default=None)
+    rank: Optional[DRank] = Field(default=None)
+    maps: Optional[dict] = Field(default=None)
+
+
+class DDType(BaseModel):
+    Novice: Optional[DData] = None
+    Moderate: Optional[DData] = None
+    Brutal: Optional[DData] = None
+    Insane: Optional[DData] = None
+    Dummy: Optional[DData] = None
+    DDmaX_Easy: Optional[DData] = Field(default=None, validation_alias="DDmaX.Easy")
+    DDmaX_Next: Optional[DData] = Field(default=None, validation_alias="DDmaX.Next")
+    DDmaX_Nut: Optional[DData] = Field(default=None, validation_alias="DDmaX.Nut")
+    DDmaX_Pro: Optional[DData] = Field(default=None, validation_alias="DDmaX.Pro")
+    Oldschool: Optional[DData] = Field(default=None)
+    Race: Optional[DData] = None
+    Solo: Optional[DData] = None
+    total: Optional[DData] = None
+
+
 class MaxFinishes(BaseModel):
     rank: int
     player: str
@@ -65,11 +91,6 @@ class DMap(BaseModel):
     max_finishes: list[MaxFinishes]
 
 
-class DRank(BaseModel):
-    points: Optional[int] = None
-    rank: Optional[int] = None
-
-
 class FirstFinish(BaseModel):
     timestamp: float
     map: str
@@ -89,13 +110,6 @@ class FavoritePartner(BaseModel):
     finishes: int
 
 
-class DData(BaseModel):
-    points: Optional[DPoints] = Field(default=None)
-    team_rank: Optional[DRank] = Field(default=None)
-    rank: Optional[DRank] = Field(default=None)
-    maps: Optional[dict] = Field(default=None)
-
-
 class Activity(BaseModel):
     date: str
     hours_played: int
@@ -221,17 +235,20 @@ class Master(BaseModel):
                     count_clients=i.count_client,
                     address=i.addresses[0],
                     game_type=i.info.game_type,
-                    name=i.info.name
+                    name=i.info.name,
                 )
                 if isinstance(i.addresses, list)
                 else CountServers(
                     count_clients=i.count_client,
                     address=i.addresses,
                     game_type=i.info.game_type,
-                    name=i.info.name
+                    name=i.info.name,
                 )
                 for i in self.servers
-            ), key=lambda x: x.count_clients, reverse=True)
+            ),
+            key=lambda x: x.count_clients,
+            reverse=True,
+        )
 
     @property
     def count_clients(self) -> int:

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi/scheme/ddstats_tw.py

@@ -4,14 +4,28 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
-from .base import DDType
-
 
 class PData(BaseModel):
     rank: int
     points: int
 
 
+class PPoints(BaseModel):
+    Novice: Optional[PData] = None
+    Moderate: Optional[PData] = None
+    Brutal: Optional[PData] = None
+    Insane: Optional[PData] = None
+    Dummy: Optional[PData] = None
+    DDmaX_Easy: Optional[PData] = Field(default=None, validation_alias="DDmaX.Easy")
+    DDmaX_Next: Optional[PData] = Field(default=None, validation_alias="DDmaX.Next")
+    DDmaX_Nut: Optional[PData] = Field(default=None, validation_alias="DDmaX.Nut")
+    DDmaX_Pro: Optional[PData] = Field(default=None, validation_alias="DDmaX.Pro")
+    Oldschool: Optional[PData] = None
+    Race: Optional[PData] = None
+    Solo: Optional[PData] = None
+    total: Optional[PData] = None
+
+
 class PointG(BaseModel):
     date: str
     points: int
@@ -101,9 +115,9 @@ class Points(BaseModel):
     weekly_points: Optional[PData] = None
     monthly_points: Optional[PData] = None
     yearly_points: Optional[PData] = None
-    points: DDType
-    rank_points: DDType
-    team_points: DDType
+    points: PPoints
+    rank_points: PPoints
+    team_points: PPoints
 
 
 class RecentActivity(BaseModel):

ddapi-0.12.2/ddapi/ddapi/scheme/status_tw.py

@@ -0,0 +1,131 @@
+# Status.tw
+from datetime import datetime
+from enum import StrEnum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ChartEnum(StrEnum):
+    day = "day"
+    week = "week"
+    month = "month"
+
+
+class DataTw(BaseModel):
+    name: str
+    created_at: datetime = Field(alias="createdAt")
+
+
+class VersionTw(BaseModel):
+    version: str
+    created_at: datetime = Field(alias="createdAt")
+
+
+class CountryTw(BaseModel):
+    identifier: str
+    code: int
+    icon_url: str = Field(alias="iconUrl")
+
+
+class ClientTw(BaseModel):
+    name: str
+    country: CountryTw
+    score: int
+    is_player: bool = Field(alias="isPlayer")
+    is_afk: bool = Field(alias="isAfk")
+    team: int
+    created_at: datetime = Field(alias="createdAt")
+    clan: DataTw | None
+    server: "ServerTw" = None
+
+
+class ServerTw(BaseModel):
+    ip: str
+    port: int
+    name: str
+    num_clients: int = Field(alias="numClients")
+    num_players: int = Field(alias="numPlayers")
+    max_clients: int = Field(alias="maxClients")
+    max_players: int = Field(alias="maxPlayers")
+    has_password: bool = Field(alias="hasPassword")
+    supports6: bool
+    supports7: bool
+    created_at: datetime = Field(alias="createdAt")
+    relevance_score: int = Field(alias="relevanceScore")
+    client_score_kind: str | None = Field(alias="clientScoreKind")
+    logo_url: str = Field(alias="logoUrl")
+    map: DataTw
+    website: Optional[str] = None
+    discord_invite: Optional[str] = Field(None, alias="discordInvite")
+    description: Optional[str] = None
+    game_type: DataTw = Field(alias="gameType")
+    version: VersionTw
+    clients: list[ClientTw]
+
+
+class ServerTwOne(BaseModel):
+    ip: str
+    port: int
+    online: ServerTw
+
+
+class Chart(BaseModel):
+    avg_players: float = Field(alias="avgPlayers")
+    max_players: int = Field(alias="maxPlayers")
+    min_players: int = Field(alias="minPlayers")
+    timestamp: datetime
+
+
+class Charts(BaseModel):
+    charts: list[Chart]
+
+
+class MasterTw(BaseModel):
+    servers: list[ServerTw]
+
+
+class Info(BaseModel):
+    app: str
+    version: str
+
+
+class BannedMasterData(BaseModel):
+    ip: str
+    is_active: bool = Field(alias="isActive")
+    reason: str | None
+    unban_date: datetime | None = Field(alias="unbanDate")
+    created_at: datetime = Field(alias="createdAt")
+
+
+class BannedMaster(BaseModel):
+    servers: list[BannedMasterData]
+
+
+class ListData(BaseModel):
+    name: str
+    created_at: datetime = Field(alias="createdAt")
+    servers: list[ServerTw]
+
+
+class List(BaseModel):
+    data: list[ListData]
+
+
+class ListPlData(BaseModel):
+    name: str
+    created_at: datetime = Field(alias="createdAt")
+    players: list[ClientTw]
+
+
+class ListPl(BaseModel):
+    data: list[ListPlData]
+
+
+class Stats(BaseModel):
+    num_players: int = Field(alias="numPlayers")
+    num_clans: int = Field(alias="numClans")
+    num_servers: int = Field(alias="numServers")
+    num_maps: int = Field(alias="numMaps")
+    num_game_types: int = Field(alias="numGameTypes")
+    num_versions: int = Field(alias="numVersions")

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: ddapi
-Version: 0.12.0
+Version: 0.12.2
 Summary: DDnet api
 Home-page: https://github.com/ByFox213/ddapi
 Author: ByFox
 License: MIT
 Project-URL: Github, https://github.com/ByFox213/ddapi
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author

{ddapi-0.12.0 → ddapi-0.12.2}/ddapi/ddapi.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ ddapi/ddapi.egg-info/SOURCES.txt
 ddapi/ddapi.egg-info/dependency_links.txt
 ddapi/ddapi.egg-info/top_level.txt
 ddapi/ddapi/scheme/__init__.py
-ddapi/ddapi/scheme/base.py
 ddapi/ddapi/scheme/ddnet.py
 ddapi/ddapi/scheme/ddstats_tw.py
 ddapi/ddapi/scheme/status_tw.py

{ddapi-0.12.0 → ddapi-0.12.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = ddapi
-version = 0.12.0
+version = 0.12.2
 author = ByFox
 description = DDnet api
 long_description = file: README.md
@@ -14,7 +14,7 @@ license_files = LICENSE
 package_dir = 
 	= ddapi
 packages = find:
-python_requires = >=3.9
+python_requires = >=3.10
 
 [options.packages.find]
 where = ddapi

{ddapi-0.12.0 → ddapi-0.12.2}/setup.py

@@ -5,17 +5,15 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="ddapi",
-    version="0.12.0",
+    version="0.12.2",
     author="ByFox",
     description="DDnet api",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/ByFox213/ddapi",
     license="MIT",
-    project_urls={
-        "Github": "https://github.com/ByFox213/ddapi"
-    },
+    project_urls={"Github": "https://github.com/ByFox213/ddapi"},
     package_dir={"": "ddapi"},
     packages=setuptools.find_packages(where="ddapi"),
-    python_requires=">=3.8"
+    python_requires=">=3.10",
 )

ddapi-0.12.0/ddapi/ddapi/scheme/base.py

@@ -1,21 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-from ddapi import DData
-
-
-class DDType(BaseModel):
-    Novice: Optional[DData] = None
-    Moderate: Optional[DData] = None
-    Brutal: Optional[DData] = None
-    Insane: Optional[DData] = None
-    Dummy: Optional[DData] = None
-    DDmaX_Easy: Optional[DData] = Field(default=None, validation_alias="DDmaX.Easy")
-    DDmaX_Next: Optional[DData] = Field(default=None, validation_alias="DDmaX.Next")
-    DDmaX_Nut: Optional[DData] = Field(default=None, validation_alias="DDmaX.Nut")
-    DDmaX_Pro: Optional[DData] = Field(default=None, validation_alias="DDmaX.Pro")
-    Oldschool: Optional[DData] = Field(default=None)
-    Race: Optional[DData] = None
-    Solo: Optional[DData] = None
-    total: Optional[DData] = None

ddapi-0.12.0/ddapi/ddapi/scheme/status_tw.py

@@ -1,131 +0,0 @@
-# Status.tw
-from datetime import datetime
-from enum import StrEnum
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class ChartEnum(StrEnum):
-    day = "day"
-    week = "week"
-    month = "month"
-
-
-class DataTw(BaseModel):
-    name: str
-    created_at: datetime = Field(serialization_alias="createdAt")
-
-
-class VersionTw(BaseModel):
-    version: str
-    created_at: datetime = Field(serialization_alias="createdAt")
-
-
-class CountryTw(BaseModel):
-    identifier: str
-    code: int
-    icon_url: str = Field(serialization_alias="iconUrl")
-
-
-class ClientTw(BaseModel):
-    name: str
-    country: CountryTw
-    score: int
-    is_player: bool = Field(serialization_alias="isPlayer")
-    is_afk: bool = Field(serialization_alias="isAfk")
-    team: int
-    created_at: datetime = Field(serialization_alias="createdAt")
-    clan: DataTw | None
-    server: "ServerTw" = None
-
-
-class ServerTw(BaseModel):
-    ip: str
-    port: int
-    name: str
-    num_clients: int = Field(serialization_alias="numClients")
-    num_players: int = Field(serialization_alias="numPlayers")
-    max_clients: int = Field(serialization_alias="maxClients")
-    max_players: int = Field(serialization_alias="maxPlayers")
-    has_password: bool = Field(serialization_alias="hasPassword")
-    supports6: bool
-    supports7: bool
-    created_at: datetime = Field(serialization_alias="createdAt")
-    relevance_score: int = Field(serialization_alias="relevanceScore")
-    client_score_kind: str | None = Field(serialization_alias="clientScoreKind")
-    logo_url: str = Field(serialization_alias="logoUrl")
-    map: DataTw
-    website: Optional[str] = None
-    discord_invite: Optional[str] = Field(None, serialization_alias="discordInvite")
-    description: Optional[str] = None
-    game_type: DataTw = Field(serialization_alias="gameType")
-    version: VersionTw
-    clients: list[ClientTw]
-
-
-class ServerTwOne(BaseModel):
-    ip: str
-    port: int
-    online: ServerTw
-
-
-class Chart(BaseModel):
-    avg_players: float = Field(serialization_alias="avgPlayers")
-    max_players: int = Field(serialization_alias="maxPlayers")
-    min_players: int = Field(serialization_alias="minPlayers")
-    timestamp: datetime
-
-
-class Charts(BaseModel):
-    charts: list[Chart]
-
-
-class MasterTw(BaseModel):
-    servers: list[ServerTw]
-
-
-class Info(BaseModel):
-    app: str
-    version: str
-
-
-class BannedMasterData(BaseModel):
-    ip: str
-    is_active: bool = Field(serialization_alias="isActive")
-    reason: str | None
-    unban_date: datetime | None = Field(serialization_alias="unbanDate")
-    created_at: datetime = Field(serialization_alias="createdAt")
-
-
-class BannedMaster(BaseModel):
-    servers: list[BannedMasterData]
-
-
-class ListData(BaseModel):
-    name: str
-    created_at: datetime = Field(serialization_alias="createdAt")
-    servers: list[ServerTw]
-
-
-class List(BaseModel):
-    data: list[ListData]
-
-
-class ListPlData(BaseModel):
-    name: str
-    created_at: datetime = Field(serialization_alias="createdAt")
-    players: list[ClientTw]
-
-
-class ListPl(BaseModel):
-    data: list[ListPlData]
-
-
-class Stats(BaseModel):
-    num_players: int = Field(serialization_alias="numPlayers")
-    num_clans: int = Field(serialization_alias="numClans")
-    num_servers: int = Field(serialization_alias="numServers")
-    num_maps: int = Field(serialization_alias="numMaps")
-    num_game_types: int = Field(serialization_alias="numGameTypes")
-    num_versions: int = Field(serialization_alias="numVersions")