ddapi 0.8.1__tar.gz → 0.9.1__tar.gz

{ddapi-0.8.1 → ddapi-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ddapi
-Version: 0.8.1
+Version: 0.9.1
 Summary: DDnet api
 Home-page: https://github.com/ByFox213/ddapi
 Author: ByFox

{ddapi-0.8.1 → ddapi-0.9.1}/ddapi/ddapi/__init__.py

@@ -2,6 +2,6 @@
 from .main import DDnetApi, DDstats, Status
 from .scheme import *
 
-__version__ = "0.8.1"
+__version__ = "0.9.1"
 __author__ = 'ByFox'
 __LICENSE__ = "MIT"

ddapi-0.9.1/ddapi/ddapi/main.py

@@ -0,0 +1,232 @@
+from urllib.parse import quote
+
+from .api import API
+from .scheme import *
+
+__all__ = (
+    "DDnetApi",
+    "DDstats",
+    "Status"
+)
+
+
+class MasterEnum(StrEnum):
+    master1 = "master1"
+    master2 = "master2"
+    master3 = "master3"
+    master4 = "master4"
+
+
+class DDnetApi(API):
+    def __init__(self):
+        super().__init__()
+        self.domain = "ddnet.org"
+
+    @staticmethod
+    def powered() -> str:
+        return DDnetApi().domain
+
+    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
+        )
+
+    async def status(self) -> DDStatus:
+        return await self._generate_model_instance(
+            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"
+        )
+
+    async def query(self, player: str) -> Query:
+        return await self._generate_model_instance(
+            f"https://{self.domain}/players/?query={quote(player)}",
+            Query,
+            "players"
+        )
+
+    async def query_map(self, map_name: str) -> QueryMap:
+        return await self._generate_model_instance(
+            f"https://{self.domain}/maps/?query={quote(map_name)}",
+            QueryMap,
+            'maps',
+        )
+
+    async def query_mapper(self, player: str) -> QueryMapper:
+        return await self._generate_model_instance(
+            f"https://{self.domain}/maps/?qmapper={quote(player)}",
+            QueryMapper,
+            'players',
+        )
+
+    async def master(self, master: MasterEnum = MasterEnum.master1) -> Master:
+        return await self._generate_model_instance(
+            f"https://{master}.{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
+        )
+
+
+class DDstats(API):
+    def __init__(self):
+        super().__init__()
+        self.domain = 'ddstats.tw'
+
+    @staticmethod
+    def powered() -> str:
+        return DDstats().domain
+
+    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
+        )
+
+
+class Status(API):
+    def __init__(self):
+        super().__init__()
+        self.domain = 'status.tw'
+
+    @staticmethod
+    def powered() -> str:
+        return Status().domain
+
+    async def info(self) -> Info:
+        return await self._generate_model_instance(
+            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"
+        )
+
+    async def map_list(self) -> List:
+        return await self._generate_model_instance(
+            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
+        )
+
+    async def gametype_list(self) -> List:
+        return await self._generate_model_instance(
+            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
+        )
+
+    async def version_list(self) -> List:
+        return await self._generate_model_instance(
+            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
+        )
+
+    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"
+        )
+
+    async def server(self, ip: str, port: int | str) -> ServerTwOne:
+        return await self._generate_model_instance(
+            f"https://api.{self.domain}/server/{quote(ip)}/{port}",
+            ServerTwOne,
+        )
+
+    async def server_charts(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"
+        )
+
+    async def server_history(self, ip: str, port: int | str) -> None:
+        # https://api.status.tw/server/{ip}/{port}/history
+        raise NotImplementedError()
+
+    async def server_stats(self, ip: str, port: int | str) -> None:
+        # https://api.status.tw/server/{ip}/{port}/stats
+        raise NotImplementedError()
+
+    async def clan_list(self) -> ListPl:
+        return await self._generate_model_instance(
+            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
+        )
+
+    async def player_list(self) -> ListPl:
+        return await self._generate_model_instance(
+            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
+        )
+
+    async def player_history(self, name: str) -> None:
+        # https://api.status.tw/player/name/{name}/history
+        raise NotImplementedError()
+
+    async def stats(self) -> Stats:
+        return await self._generate_model_instance(
+            f"https://api.{self.domain}/stats",
+            Stats
+        )
+
+    async def stats_players(self, t: str) -> None:
+        # https://api.status.tw/stats/players/day | week | month
+        raise NotImplementedError()
+
+    async def stats_servers(self, t: str) -> None:
+        # https://api.status.tw/stats/servers/week | month
+        raise NotImplementedError()

{ddapi-0.8.1 → ddapi-0.9.1}/ddapi/ddapi/scheme/__init__.py

@@ -1,3 +1,7 @@
 from .ddnet import *
-from .status_tw import *
 from .ddstats_tw import *
+from .status_tw import *
+
+__version__ = "0.9.1"
+__author__ = 'ByFox'
+__LICENSE__ = "MIT"

ddapi-0.9.1/ddapi/ddapi/scheme/ddnet.py

@@ -0,0 +1,299 @@
+# ddnet
+from collections import Counter
+from datetime import datetime
+from typing import Optional, Any
+
+from pydantic import BaseModel, Field
+
+rm_list = ["DD-Persian", "/vDQMHSss8W", '']
+
+
+class DPoints(BaseModel):
+    total: int
+    points: Optional[int] = Field(default=None)
+    rank: Optional[int] = Field(default=None)
+
+
+class MaxFinishes(BaseModel):
+    rank: int
+    player: str
+    num: int
+    time: float
+    min_timestamp: int
+    max_timestamp: int
+
+
+class DDRanks(BaseModel):
+    rank: int
+    player: str
+    time: float
+    timestamp: int
+    country: str
+
+
+class DDTeamRanks(BaseModel):
+    rank: int
+    players: list[str]
+    time: float
+    timestamp: int
+    country: str
+
+
+class DMap(BaseModel):
+    name: str
+    website: str
+    thumbnail: str
+    web_preview: str
+    type: str
+    points: int
+    difficulty: int
+    mapper: str
+    release: Optional[int] = None
+    median_time: float
+    first_finish: int
+    last_finish: int
+    finishes: int
+    finishers: int
+    biggest_team: int
+    width: int
+    height: int
+    tiles: list[str]
+    team_ranks: list[DDTeamRanks]
+    ranks: list[DDRanks]
+    max_finishes: list[MaxFinishes]
+
+
+class DRank(BaseModel):
+    points: Optional[int] = None
+    rank: Optional[int] = None
+
+
+class FirstFinish(BaseModel):
+    timestamp: float
+    map: str
+    time: float
+
+
+class LastFinish(BaseModel):
+    timestamp: float
+    map: str
+    time: float
+    country: str
+    type: Optional[str] = None
+
+
+class FavoritePartner(BaseModel):
+    name: str
+    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 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 Activity(BaseModel):
+    date: str
+    hours_played: int
+
+
+class FavoriteServer(BaseModel):
+    server: str
+
+
+class DDPlayer(BaseModel):
+    player: str
+    points: DPoints
+    team_rank: Optional[DRank] = None
+    rank: Optional[DRank] = None
+    points_last_year: Optional[DRank] = None
+    points_last_month: Optional[DRank] = None
+    points_last_week: Optional[DRank] = None
+    favorite_server: FavoriteServer
+    first_finish: FirstFinish
+    last_finishes: list[LastFinish]
+    favorite_partners: Optional[list[FavoritePartner]] = None
+    types: DDType
+    activity: list[Activity]
+    hours_played_past_365_days: int
+
+
+class Skin(BaseModel):
+    name: Optional[str] = None
+    color_body: Optional[int] = None
+    color_feet: Optional[int] = None
+
+
+class Client(BaseModel):
+    name: str
+    clan: str
+    country: int
+    score: int
+    is_player: Optional[bool] = None
+    skin: Optional[Skin] = None
+    afk: Optional[bool] = None
+    team: Optional[int] = None
+
+
+class Map(BaseModel):
+    name: str
+    sha256: Optional[str] = None
+    size: Optional[int] = None
+
+
+class Community(BaseModel):
+    id: str
+    icon: str
+    admin: list[str]
+    public_key: Optional[str] = None
+    signature: Optional[str] = None
+
+
+class Info(BaseModel):
+    max_clients: int
+    max_players: int
+    passworded: bool
+    game_type: str
+    name: str
+    map: Map
+    version: str
+    clients: Optional[list[Client]] = None
+    requires_login: Optional[bool] = None
+    community: Optional[Community] = None
+
+    def __len__(self) -> int:
+        return len(self.clients)
+
+
+class Server(BaseModel):
+    addresses: list | str
+    location: str = Field(default=None)
+    info: Info
+
+    def __len__(self) -> int:
+        return self.count_client
+
+    @property
+    def count_client(self) -> int:
+        if self.info.clients is not None:
+            return len(self.info.clients)
+        return 0
+
+
+class CountServers(BaseModel):
+    name: str
+    address: str
+    game_type: str
+    count_clients: int
+
+
+class Master(BaseModel):
+    servers: list[Server]
+
+    def __len__(self) -> int:
+        return len(self.servers)
+
+    def get_clans(self, rm: list[str] = None) -> list[tuple[Any, int]]:
+        remove_list = rm_list.copy() if rm is None else rm
+        if not self.servers:
+            return []
+
+        dat: Counter[Any] = Counter(
+            client.clan
+            for server in self.servers
+            for client in server.info.clients
+            if client != ''
+        )
+
+        for i in remove_list:
+            del dat[i]
+        return sorted(dat.items(), key=lambda x: x[1], reverse=True)
+
+    @property
+    def count_servers(self) -> list[CountServers]:
+        return sorted(
+            (
+                CountServers(
+                    count_clients=i.count_client,
+                    address=i.addresses[0],
+                    game_type=i.info.game_type,
+                    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
+                )
+                for i in self.servers
+            ), key=lambda x: x.count_clients, reverse=True)
+
+    @property
+    def count_clients(self) -> int:
+        return sum(i.count_client for i in self.servers)
+
+
+class ReleasesMapsData(BaseModel):
+    name: str
+    website: str
+    thumbnail: str
+    web_preview: str
+    type: str
+    points: int
+    difficulty: int
+    mapper: str
+    release: datetime | str
+    width: int
+    height: int
+    tiles: list[str]
+
+
+class ReleasesMaps(BaseModel):
+    maps: list[ReleasesMapsData]
+
+
+class QueryData(BaseModel):
+    points: int
+    name: str
+
+
+class Query(BaseModel):
+    players: list[QueryData]
+
+
+class QueryMapperData(BaseModel):
+    mapper: str
+    num_maps: int
+
+
+class QueryMapper(BaseModel):
+    players: list[QueryMapperData]
+
+
+class QueryMapData(BaseModel):
+    name: str
+    type: str
+    mapper: str
+
+
+class QueryMap(BaseModel):
+    maps: list[QueryMapData]

{ddapi-0.8.1 → ddapi-0.9.1}/ddapi/ddapi/scheme/ddstats_tw.py

@@ -1,7 +1,6 @@
 # ddstats.tw
-from collections import Counter
 from datetime import datetime
-from typing import Any, Union, Optional
+from typing import Optional
 
 from pydantic import BaseModel, Field
 
@@ -178,6 +177,12 @@ class RecentTop10s(BaseModel):
     server: str
 
 
+class GeneralActivity(BaseModel):
+    total_seconds_played: int
+    start_of_playtime: datetime
+    average_seconds_played: int
+
+
 class Player(BaseModel):
     points_graph: list[PointG]
     recent_finishes: list[RecentFinishes]
@@ -194,136 +199,12 @@ class Player(BaseModel):
     most_played_categories: Optional[list[MostPlayed]] = None
     most_played_locations: Optional[list[MostPlayed]] = None
     playtime_per_month: list[PlaytimePerMonth]
+    general_activity: GeneralActivity
     favourite_rank1s_teammates: Optional[list[FavouriteRank1sTeammates]] = None
     all_top_10s: Optional[list[AllTop10s]] = None
     recent_top_10s: Optional[list[RecentTop10s]] = None
 
 
-class Skin(BaseModel):
-    name: Optional[str] = None
-    color_body: Optional[int] = None
-    color_feet: Optional[int] = None
-
-
-class Client(BaseModel):
-    name: str
-    clan: str
-    country: int
-    score: int
-    is_player: Optional[bool] = None
-    skin: Optional[Skin] = None
-    afk: Optional[bool] = None
-    team: Optional[int] = None
-
-
-class Map(BaseModel):
-    name: str
-    sha256: Optional[str] = None
-    size: Optional[int] = None
-
-
-class Community(BaseModel):
-    id: str
-    icon: str
-    admin: list[str]
-    public_key: Optional[str] = None
-    signature: Optional[str] = None
-
-
-class Info(BaseModel):
-    max_clients: int
-    max_players: int
-    passworded: bool
-    game_type: str
-    name: str
-    map: Map
-    version: str
-    clients: Optional[list[Client]] = None
-    requires_login: Optional[bool] = None
-    community: Optional[Community] = None
-
-    def __len__(self) -> int:
-        return len(self.clients)
-
-
-class Server(BaseModel):
-    addresses: Union[list, str]
-    location: str = Field(default=None)
-    info: Info
-
-    def __len__(self) -> int:
-        return self.count_client
-
-    @property
-    def count_client(self) -> int:
-        if self.info.clients is not None:
-            return len(self.info.clients)
-        return 0
-
-
-class CountServers(BaseModel):
-    name: str
-    address: str
-    game_type: str
-    count_clients: int
-
-
-class Master(BaseModel):
-    servers: list[Server]
-
-    def __len__(self) -> int:
-        return len(self.servers)
-
-    def get_clans(self, rm: list[str] = None) -> list[tuple[Any, int]]:
-        remove_list = rm_list.copy() if rm is None else rm
-        if not self.servers:
-            return []
-
-        dat: Counter[Any] = Counter(
-            client.clan
-            for server in self.servers
-            for client in server.info.clients
-            if client != ''
-        )
-
-        for i in remove_list:
-            del dat[i]
-        return sorted(dat.items(), key=lambda x: x[1], reverse=True)
-
-    @property
-    def count_servers(self) -> list[CountServers]:
-        return sorted(
-            (
-                CountServers(
-                    count_clients=i.count_client,
-                    address=i.addresses[0],
-                    game_type=i.info.game_type,
-                    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
-                )
-                for i in self.servers
-            ), key=lambda x: x.count_clients, reverse=True)
-
-    @property
-    def count_clients(self) -> int:
-        return sum(i.count_client for i in self.servers)
-
-
-class QueryData(BaseModel):
-    points: int
-    name: str
-
-
-class Query(BaseModel):
-    data: list[QueryData]
-
-
 class DDStatusData(BaseModel):
     name: str = None
     type: str = None

{ddapi-0.8.1 → ddapi-0.9.1}/ddapi/ddapi/scheme/status_tw.py

@@ -37,6 +37,7 @@ class ClientTw(BaseModel):
     team: int
     createdAt: datetime
     clan: DataTw | None
+    server: "ServerTw" = None
 
 
 class ServerTw(BaseModel):
@@ -82,3 +83,49 @@ class Charts(BaseModel):
 
 class MasterTw(BaseModel):
     servers: list[ServerTw]
+
+
+class Info(BaseModel):
+    app: str
+    version: str
+
+
+class BannedMasterData(BaseModel):
+    ip: str
+    isActive: bool
+    reason: str | None
+    unbanDate: datetime | None
+    createdAt: datetime
+
+
+class BannedMaster(BaseModel):
+    servers: list[BannedMasterData]
+
+
+class ListData(BaseModel):
+    name: str
+    createdAt: datetime
+    servers: list[ServerTw]
+
+
+class List(BaseModel):
+    data: list[ListData]
+
+
+class ListPlData(BaseModel):
+    name: str
+    createdAt: datetime
+    players: list[ClientTw]
+
+
+class ListPl(BaseModel):
+    data: list[ListPlData]
+
+
+class Stats(BaseModel):
+    numPlayers: int
+    numClans: int
+    numServers: int
+    numMaps: int
+    numGameTypes: int
+    numVersions: int

{ddapi-0.8.1 → ddapi-0.9.1}/ddapi/ddapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ddapi
-Version: 0.8.1
+Version: 0.9.1
 Summary: DDnet api
 Home-page: https://github.com/ByFox213/ddapi
 Author: ByFox

{ddapi-0.8.1 → ddapi-0.9.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = ddapi
-version = 0.8.1
+version = 0.9.1
 author = ByFox
 description = DDnet api
 long_description = file: README.md

{ddapi-0.8.1 → ddapi-0.9.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="ddapi",
-    version="0.8.1",
+    version="0.9.1",
     author="ByFox",
     description="DDnet api",
     long_description=long_description,

ddapi-0.8.1/ddapi/ddapi/main.py

@@ -1,173 +0,0 @@
-from typing import Union
-from urllib.parse import quote
-
-from .api import API
-from .scheme import DDPlayer, Master, Query, DMap, DDStatus, Player, MasterTw, ServerTwOne, ChartEnum, Charts
-
-__all__ = (
-    "DDnetApi",
-    "DDstats",
-    "Status"
-)
-
-
-class DDnetApi(API):
-    def __init__(self):
-        super().__init__()
-        self.domain = "ddnet.org"
-
-    @staticmethod
-    def powered() -> str:
-        return DDnetApi().domain
-
-    async def player(self, player_name: 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_name)}",
-            DDPlayer
-        )
-
-    async def status(self) -> Union[DDStatus, None]:
-        return await self._generate_model_instance(
-            f"https://{self.domain}/status/json/stats.json",
-            DDStatus
-        )
-
-    async def query(self, player: str) -> Union[Query, None]:
-        return await self._generate_model_instance(
-            f"https://{self.domain}/players/?query={quote(player)}",
-            Query,
-            "data"
-        )
-
-    async def master(self) -> Union[Master, None]:
-        return await self._generate_model_instance(
-            f"https://master1.{self.domain}/ddnet/15/servers.json",
-            Master
-        )
-
-    async def map(self, map_name: str) -> Union[DMap, None]:
-        return await self._generate_model_instance(
-            f"https://{self.domain}/maps/?json={quote(map_name)}",
-            DMap
-        )
-
-
-class DDstats(API):
-    def __init__(self):
-        super().__init__()
-        self.domain = 'ddstats.tw'
-
-    @staticmethod
-    def powered() -> str:
-        return DDstats().domain
-
-    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
-        )
-
-
-class Status(API):
-    def __init__(self):
-        super().__init__()
-        self.domain = 'status.tw'
-
-    @staticmethod
-    def powered() -> str:
-        return Status().domain
-
-    async def info(self) -> None:
-        # https://api.status.tw/info
-        raise NotImplementedError()
-
-    async def master_bans(self) -> None:
-        # https://api.status.tw/master/bans/list
-        raise NotImplementedError()
-
-    async def map_list(self) -> None:
-        # https://api.status.tw/map/list
-        raise NotImplementedError()
-
-    async def map(self, name: str) -> None:
-        # https://api.status.tw/map/name/{name}
-        raise NotImplementedError()
-
-    async def gametype_list(self) -> None:
-        # https://api.status.tw/gametype/list
-        raise NotImplementedError()
-
-    async def gametype(self, name: str) -> None:
-        # https://api.status.tw/gametype/name/{name}
-        raise NotImplementedError()
-
-    async def version_list(self) -> None:
-        # https://api.status.tw/version/list
-        raise NotImplementedError()
-
-    async def version(self, name: str) -> None:
-        # https://api.status.tw/version/name/{name}
-        raise NotImplementedError()
-
-    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"
-        )
-
-    async def server(self, ip: str, port: Union[int, str]) -> ServerTwOne:
-        return await self._generate_model_instance(
-            f"https://api.{self.domain}/server/{quote(ip)}/{port}",
-            ServerTwOne,
-        )
-
-    async def server_charts(self, ip: str, port: Union[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"
-        )
-
-    async def server_history(self, ip: str, port: Union[int, str]) -> None:
-        # https://api.status.tw/server/{ip}/{port}/history
-        raise NotImplementedError()
-
-    async def server_stats(self, ip: str, port: Union[int, str]) -> None:
-        # https://api.status.tw/server/{ip}/{port}/stats
-        raise NotImplementedError()
-
-    async def clan_list(self) -> None:
-        # https://api.status.tw/clan/list
-        raise NotImplementedError()
-
-    async def clan(self, name: str) -> None:
-        # https://api.status.tw/clan/name/{name}
-        raise NotImplementedError()
-
-    async def player_list(self) -> None:
-        # https://api.status.tw/player/list
-        raise NotImplementedError()
-
-    async def player(self, name: str) -> None:
-        # https://api.status.tw/player/name/{name}
-        raise NotImplementedError()
-
-    async def player_history(self, name: str) -> None:
-        # https://api.status.tw/player/name/{name}/history
-        raise NotImplementedError()
-
-    async def stats(self) -> None:
-        # https://api.status.tw/stats
-        raise NotImplementedError()
-
-    async def stats_players(self, t: str) -> None:
-        # https://api.status.tw/stats/players/day week month
-        raise NotImplementedError()
-
-    async def stats_servers(self, t: str) -> None:
-        # https://api.status.tw/stats/servers/week month
-        raise NotImplementedError()

ddapi-0.8.1/ddapi/ddapi/scheme/ddnet.py

@@ -1,132 +0,0 @@
-# ddnet
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class DPoints(BaseModel):
-    total: int
-    points: Optional[int] = Field(default=None)
-    rank: Optional[int] = Field(default=None)
-
-
-class MaxFinishes(BaseModel):
-    rank: int
-    player: str
-    num: int
-    time: float
-    min_timestamp: int
-    max_timestamp: int
-
-
-class DDRanks(BaseModel):
-    rank: int
-    player: str
-    time: float
-    timestamp: int
-    country: str
-
-
-class DDTeamRanks(BaseModel):
-    rank: int
-    players: list[str]
-    time: float
-    timestamp: int
-    country: str
-
-
-class DMap(BaseModel):
-    name: str
-    website: str
-    thumbnail: str
-    web_preview: str
-    type: str
-    points: int
-    difficulty: int
-    mapper: str
-    release: Optional[int] = None
-    median_time: float
-    first_finish: int
-    last_finish: int
-    finishes: int
-    finishers: int
-    biggest_team: int
-    width: int
-    height: int
-    tiles: list[str]
-    team_ranks: list[DDTeamRanks]
-    ranks: list[DDRanks]
-    max_finishes: list[MaxFinishes]
-
-
-class DRank(BaseModel):
-    points: Optional[int] = None
-    rank: Optional[int] = None
-
-
-class FirstFinish(BaseModel):
-    timestamp: float
-    map: str
-    time: float
-
-
-class LastFinish(BaseModel):
-    timestamp: float
-    map: str
-    time: float
-    country: str
-    type: Optional[str] = None
-
-
-class FavoritePartner(BaseModel):
-    name: str
-    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 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 Activity(BaseModel):
-    date: str
-    hours_played: int
-
-
-class FavoriteServer(BaseModel):
-    server: str
-
-
-class DDPlayer(BaseModel):
-    player: str
-    points: DPoints
-    team_rank: Optional[DRank] = None
-    rank: Optional[DRank] = None
-    points_last_year: Optional[DRank] = None
-    points_last_month: Optional[DRank] = None
-    points_last_week: Optional[DRank] = None
-    favorite_server: FavoriteServer
-    first_finish: FirstFinish
-    last_finishes: list[LastFinish]
-    favorite_partners: Optional[list[FavoritePartner]] = None
-    types: DDType
-    activity: list[Activity]
-    hours_played_past_365_days: int