ddapi 0.13.0__tar.gz → 0.14.0__tar.gz

{ddapi-0.13.0 → ddapi-0.14.0}/PKG-INFO

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

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/__init__.py

@@ -5,6 +5,6 @@ from .enum import MasterEnum
 from .cache import CacheABC, EmptyCache, MemoryCache
 from .scheme import *  # noqa: F403
 
-__version__ = "0.13.0"
+__version__ = "0.14.0"
 __author__ = "ByFox"
 __LICENSE__ = "MIT"

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/_api.py

@@ -1,7 +1,9 @@
 import asyncio
+import atexit
 import logging
-from abc import ABC
-from typing import Optional, Type, Any
+from http import HTTPStatus
+from json import JSONDecoder
+from typing import Optional
 
 import aiohttp
 from aiohttp import ClientSession
@@ -18,62 +20,52 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-class API(ABC):
+
+class API:
     def __init__(
         self,
         session: ClientSession = None,
         *,
         autoclose: bool = True,
-        cache: CacheABC = EmptyCache(),
-        json_loads: Any = DEFAULT_JSON_DECODER,
-    ):
+        cache: CacheABC = None,
+        json_loads: JSONDecoder = DEFAULT_JSON_DECODER,
+    ) -> None:
         self.__session = session
-        self.cache = cache
+        self.cache = cache or EmptyCache()
         self.json_loads = json_loads
         self.autoclose = autoclose
 
         if self.__session is None:
             self.__session = aiohttp.ClientSession()
-            logger.debug("Created a new aiohttp ClientSession.")
 
-    async def __aenter__(self):
+        atexit.register(self.close_api)
+
+    async def __aenter__(self) -> "API":
         if self.__session is None:
             self.__session = aiohttp.ClientSession()
-            logger.debug("Created a new aiohttp ClientSession on enter.")
         return self
 
-    async def __aexit__(self, _exc_type, _exc_val, _exc_tb):
+    async def __aexit__(self, _exc_type, _exc_val, _exc_tb) -> None:  # noqa: ANN001
         if self.autoclose:
-            logger.debug("Closing aiohttp ClientSession on exit.")
             await self.close()
 
-    def __del__(self):
-        if self.__session is not None and not self.__session.closed:
-            loop = asyncio.get_event_loop()
-            if loop.is_running():
-                logger.warning("Closing aiohttp ClientSession in the background.")
-                loop.create_task(self.close())
-            else:
-                logger.warning("Closing aiohttp ClientSession synchronously.")
-                loop.run_until_complete(self.close())
-
-    async def _get(self, url: str) -> Optional[dict]:
+    async def _get(self, url: str) -> dict | None:
         """Send a GET request to the given URL and return the response as JSON."""
-        logger.debug(f"Sending GET request to {url}.")
+        logger.debug("Sending GET request to %s.", url)
         async with self.__session.get(url) as req:
-            if req.status == 200:
-                logger.debug(f"Received response from {url}: {req.status}.")
+            if req.status == HTTPStatus.OK.value:
+                logger.debug("Received response from %s: %s.", url, req.status)
                 return await req.json(loads=self.json_loads)
-            logger.error(f"Failed to get response from {url}: {req.status}.")
+            logger.error("Failed to get response from %s: %s.", url, req.status)
             return None
 
     async def _generate_model_instance(
         self,
         url: str,
-        model: Type[T],
-        k: Optional[str] = None,
+        model: type[T],
+        k: str | None = None,
         cache_timeout: int = 300,
-    ) -> Optional[T]:
+    ) -> T | None:
         """Generate a model instance from the given URL and optional keyword arguments.
 
         Args:
@@ -90,7 +82,7 @@ class API(ABC):
 
         dat = await self._get(url)
         if dat is None or not dat:
-            logger.warning(f"No data received from {url}.")
+            logger.warning("No data received from %s.", url)
             return None
 
         data = model(**{k: dat} if k is not None else dat)
@@ -104,7 +96,6 @@ class API(ABC):
     async def close(self) -> None:
         """Close the aiohttp session."""
         if self.__session is not None:
-            logger.debug("Closing aiohttp ClientSession.")
             await self.__session.close()
         self.__session = None
         self.cache = None
@@ -116,3 +107,6 @@ class API(ABC):
     @staticmethod
     def powered() -> None:
         return None
+
+    def close_api(self) -> None:
+        asyncio.run(self.close())

ddapi-0.14.0/ddapi/ddapi/api/ddnet.py

@@ -0,0 +1,56 @@
+from ddapi._api import API
+from ddapi.scheme import (
+    DDPlayer,
+    DDStatus,
+    ReleasesMaps,
+    Query,
+    QueryMap,
+    QueryMapper,
+    Master,
+    DMap,
+)
+
+__all__ = ("DDnetApi",)
+
+from ddapi.enum import MasterEnum
+
+
+class DDnetApi(API):
+    @property
+    def domain(self) -> str:
+        return "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(DDPlayer.api(player), DDPlayer)
+
+    async def status(self) -> DDStatus:
+        return await self._generate_model_instance(DDStatus.api(), DDStatus)
+
+    async def releases_map(self) -> ReleasesMaps:
+        return await self._generate_model_instance(
+            ReleasesMaps.api(), ReleasesMaps, "maps"
+        )
+
+    async def query(self, player: str) -> Query:
+        return await self._generate_model_instance(Query.api(player), Query, "players")
+
+    async def query_map(self, map_name: str) -> QueryMap:
+        return await self._generate_model_instance(
+            QueryMap.api(map_name), QueryMap, "maps"
+        )
+
+    async def query_mapper(self, player: str) -> QueryMapper:
+        return await self._generate_model_instance(
+            QueryMapper.api(player), QueryMapper, "players"
+        )
+
+    async def master(self, master: MasterEnum = MasterEnum.master1) -> Master:
+        return await self._generate_model_instance(Master.api(master), Master)
+
+    async def map(self, map_name: str) -> DMap:
+        return await self._generate_model_instance(DMap.api(map_name), DMap)

ddapi-0.14.0/ddapi/ddapi/api/ddstats.py

@@ -0,0 +1,38 @@
+from urllib.parse import quote
+
+from ddapi._api import API
+from ddapi.scheme import (
+    DProfile,
+    SMap,
+    Maps,
+    Player,
+)
+
+__all__ = ("DDstats",)
+
+
+class DDstats(API):
+    @property
+    def domain(self) -> str:
+        return "ddstats.tw"
+
+    @staticmethod
+    def powered() -> str:
+        return DDstats().domain
+
+    async def profile(self, player: str) -> DProfile:
+        return await self._generate_model_instance(
+            DProfile.api(player),
+            DProfile,
+            "profile",
+        )
+
+    async def map(self, map_name: str) -> SMap:
+        return await self._generate_model_instance(SMap.api(map_name), SMap)
+
+    async def maps(self) -> Maps:
+        return await self._generate_model_instance(Maps.api(), Maps, "maps")
+
+    async def player(self, player: str) -> Player:
+        """Fetch player data from the API and return it as a dictionary."""
+        return await self._generate_model_instance(Player.api(player), Player)

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/api/status.py

@@ -1,7 +1,7 @@
 from urllib.parse import quote
 
-from .._api import API
-from ..scheme import (
+from ddapi._api import API
+from ddapi.scheme import (
     Info,
     BannedMaster,
     List,
@@ -90,11 +90,11 @@ class Status(API):
 
     async def server_history(self, ip: str, port: int | str) -> None:
         # TODO: https://api.status.tw/server/{ip}/{port}/history
-        raise NotImplementedError()
+        raise NotImplementedError
 
     async def server_stats(self, ip: str, port: int | str) -> None:
         # TODO: https://api.status.tw/server/{ip}/{port}/stats
-        raise NotImplementedError()
+        raise NotImplementedError
 
     async def clan_list(self) -> ListPl:
         return await self._generate_model_instance(
@@ -118,7 +118,7 @@ class Status(API):
 
     async def player_history(self, name: str) -> None:
         # TODO:  https://api.status.tw/player/name/{name}/history
-        raise NotImplementedError()
+        raise NotImplementedError
 
     async def stats(self) -> Stats:
         return await self._generate_model_instance(
@@ -127,8 +127,8 @@ class Status(API):
 
     async def stats_players(self, t: str) -> None:
         # TODO: https://api.status.tw/stats/players/day | week | month
-        raise NotImplementedError()
+        raise NotImplementedError
 
     async def stats_servers(self, t: str) -> None:
         # TODO:  https://api.status.tw/stats/servers/week | month
-        raise NotImplementedError()
+        raise NotImplementedError

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/cache/base.py

@@ -1,26 +1,29 @@
 import asyncio
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Generic
 
+from ddapi.types import T
 
-class CacheABC(ABC):
-    def __init__(self):
+
+class CacheABC(ABC, Generic[T]):
+    def __init__(self) -> None:
         self._cache = {}
         self._lock = asyncio.Lock()
+        self._remove_tasks: dict[str, asyncio.Task] = {}
 
     @abstractmethod
-    async def get(self, key: str, default: Any = None) -> Any:
+    async def get(self, key: str, default: T = None) -> T:
         return default
 
     @abstractmethod
-    async def set(self, key: str, value: Any, timeout_seconds: int = None) -> bool:
+    async def set(self, key: str, value: T, delay: int | None = None) -> bool:
         return True
 
     @abstractmethod
     def delete(self, key: str) -> bool:
         return True
 
-    async def get_or_set(self, key: str, value: Any = None) -> Any:
+    async def get_or_set(self, key: str, value: T = None) -> T:
         result = await self.get(key)
         if result is not None:
             return result

ddapi-0.14.0/ddapi/ddapi/cache/empty.py

@@ -0,0 +1,13 @@
+from .base import CacheABC
+from ddapi.types import T
+
+
+class EmptyCache(CacheABC):
+    async def get(self, key: str, default: T = None) -> T:  # noqa: ARG002
+        return default
+
+    async def set(self, key: str, value: T, delay: int | None = None) -> bool:  # noqa: ARG002
+        return True
+
+    def delete(self, key: str) -> bool:  # noqa: ARG002
+        return True

ddapi-0.14.0/ddapi/ddapi/cache/memory.py

@@ -0,0 +1,40 @@
+import asyncio
+
+from .base import CacheABC
+from ddapi.types import T
+
+
+class MemoryCache(CacheABC):
+    async def get(self, key: str, default: T = None) -> T:
+        async with self._lock:
+            return self._cache.get(key, default)
+
+    async def set(self, key: str, value: T, delay: int | None = None) -> bool:
+        async with self._lock:
+            self._cache[key] = value
+            if delay is not None:
+                if existing_task := self._remove_tasks.get(key):
+                    existing_task.cancel()
+
+                self._remove_tasks[key] = asyncio.create_task(
+                    self._remove_after_sleep(key, delay)
+                )
+            return True
+
+    async def delete(self, key: str) -> bool:
+        async with self._lock:
+            if key in self._cache:
+                self._cache.pop(key, None)
+                await self._remove_tasks.pop(key, None)
+                if existing_task := self._remove_tasks.get(key):
+                    existing_task.cancel()
+                return True
+            return False
+
+    async def _remove_after_sleep(self, key: str, delay: int) -> None:
+        try:
+            await asyncio.sleep(delay)
+            self._cache.pop(key, None)
+            await self._remove_tasks.pop(key, None)
+        except asyncio.CancelledError:
+            pass

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/scheme/ddnet.py

@@ -1,45 +1,47 @@
 # ddnet
 from collections import Counter
 from datetime import datetime
-from typing import Optional, Any
+from urllib.parse import quote
 
 from pydantic import BaseModel, Field
 
+from ddapi.enum import MasterEnum
+
 rm_list = ["DD-Persian", "/vDQMHSss8W", ""]
 
 
 class DRank(BaseModel):
-    points: Optional[int] = None
-    rank: Optional[int] = None
+    points: int | None = None
+    rank: int | None = None
 
 
 class DPoints(BaseModel):
     total: int
-    points: Optional[int] = Field(default=None)
-    rank: Optional[int] = Field(default=None)
+    points: int | None = Field(default=None)
+    rank: int | None = 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)
+    points: DPoints | None = Field(default=None)
+    team_rank: DRank | None = Field(default=None)
+    rank: DRank | None = Field(default=None)
+    maps: dict | None = 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
+    Novice: DData | None = None
+    Moderate: DData | None = None
+    Brutal: DData | None = None
+    Insane: DData | None = None
+    Dummy: DData | None = None
+    DDmaX_Easy: DData | None = Field(default=None, validation_alias="DDmaX.Easy")
+    DDmaX_Next: DData | None = Field(default=None, validation_alias="DDmaX.Next")
+    DDmaX_Nut: DData | None = Field(default=None, validation_alias="DDmaX.Nut")
+    DDmaX_Pro: DData | None = Field(default=None, validation_alias="DDmaX.Pro")
+    Oldschool: DData | None = Field(default=None)
+    Race: DData | None = None
+    Solo: DData | None = None
+    total: DData | None = None
 
 
 class MaxFinishes(BaseModel):
@@ -76,7 +78,7 @@ class DMap(BaseModel):
     points: int
     difficulty: int
     mapper: str
-    release: Optional[int] = None
+    release: int | None = None
     median_time: float
     first_finish: int
     last_finish: int
@@ -90,6 +92,17 @@ class DMap(BaseModel):
     ranks: list[DDRanks]
     max_finishes: list[MaxFinishes]
 
+    def url(self) -> str:
+        return f"https://ddnet.org/maps/{self.name}"
+
+    @staticmethod
+    def url_with_name(map_name: str) -> str:
+        return f"https://ddnet.org/maps/{map_name}"
+
+    @staticmethod
+    def api(map_name: str) -> str:
+        return f"https://ddnet.org/maps/?json={quote(map_name)}"
+
 
 class FirstFinish(BaseModel):
     timestamp: float
@@ -102,7 +115,7 @@ class LastFinish(BaseModel):
     map: str
     time: float
     country: str
-    type: Optional[str] = None
+    type: str | None = None
 
 
 class FavoritePartner(BaseModel):
@@ -122,24 +135,35 @@ class FavoriteServer(BaseModel):
 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
+    team_rank: DRank | None = None
+    rank: DRank | None = None
+    points_last_year: DRank | None = None
+    points_last_month: DRank | None = None
+    points_last_week: DRank | None = None
     favorite_server: FavoriteServer
     first_finish: FirstFinish
     last_finishes: list[LastFinish]
-    favorite_partners: Optional[list[FavoritePartner]] = None
+    favorite_partners: list[FavoritePartner] | None = None
     types: DDType
     activity: list[Activity]
     hours_played_past_365_days: int
 
+    def url(self) -> str:
+        return f"https://ddnet.org/players/{self.player}"
+
+    @staticmethod
+    def url_with_name(player: str) -> str:
+        return f"https://ddnet.org/players/{player}"
+
+    @staticmethod
+    def api(player: str) -> str:
+        return f"https://ddnet.org/players/?json2={quote(player)}"
+
 
 class Skin(BaseModel):
-    name: Optional[str] = None
-    color_body: Optional[int] = None
-    color_feet: Optional[int] = None
+    name: str | None = None
+    color_body: int | None = None
+    color_feet: int | None = None
 
 
 class Client(BaseModel):
@@ -147,24 +171,24 @@ class Client(BaseModel):
     clan: str
     country: int
     score: int
-    is_player: Optional[bool] = None
-    skin: Optional[Skin] = None
-    afk: Optional[bool] = None
-    team: Optional[int] = None
+    is_player: bool | None = None
+    skin: Skin | None = None
+    afk: bool | None = None
+    team: int | None = None
 
 
 class Map(BaseModel):
     name: str
-    sha256: Optional[str] = None
-    size: Optional[int] = None
+    sha256: str | None = None
+    size: int | None = None
 
 
 class Community(BaseModel):
     id: str
     icon: str
     admin: list[str]
-    public_key: Optional[str] = None
-    signature: Optional[str] = None
+    public_key: str | None = None
+    signature: str | None = None
 
 
 class Info(BaseModel):
@@ -175,9 +199,9 @@ class Info(BaseModel):
     name: str = None
     map: Map = None
     version: str = None
-    clients: Optional[list[Client]] = None
-    requires_login: Optional[bool] = None
-    community: Optional[Community] = None
+    clients: list[Client] | None = None
+    requires_login: bool | None = None
+    community: Community | None = None
 
     def __len__(self) -> int:
         return len(self.clients)
@@ -211,12 +235,14 @@ class Master(BaseModel):
     def __len__(self) -> int:
         return len(self.servers)
 
-    def get_clans(self, rm: list[str] = None) -> list[tuple[Any, int]]:
+    def get_clans(
+        self, rm: list[str] | None = None
+    ) -> list[str] | list[tuple[str, int]]:
         remove_list = rm_list.copy() if rm is None else rm
         if not self.servers:
             return []
 
-        dat: Counter[Any] = Counter(
+        dat: Counter[str] = Counter(
             client.clan
             for server in self.servers
             for client in server.info.clients
@@ -254,6 +280,10 @@ class Master(BaseModel):
     def count_clients(self) -> int:
         return sum(i.count_client for i in self.servers)
 
+    @staticmethod
+    def api(server: MasterEnum) -> str:
+        return f"https://master{server}.ddnet.org/ddnet/15/servers.json"
+
 
 class ReleasesMapsData(BaseModel):
     name: str
@@ -265,14 +295,22 @@ class ReleasesMapsData(BaseModel):
     difficulty: int
     mapper: str
     release: datetime | str
-    width: int
-    height: int
-    tiles: list[str]
+    width: int = None
+    height: int = None
+    tiles: list[str] = None
 
 
 class ReleasesMaps(BaseModel):
     maps: list[ReleasesMapsData]
 
+    @staticmethod
+    def url() -> str:
+        return "https://ddnet.org/releases"
+
+    @staticmethod
+    def api() -> str:
+        return "https://ddnet.org/releases/maps.json"
+
 
 class QueryData(BaseModel):
     points: int
@@ -282,6 +320,10 @@ class QueryData(BaseModel):
 class Query(BaseModel):
     players: list[QueryData]
 
+    @staticmethod
+    def api(player: str) -> str:
+        return f"https://ddnet.org/players/?query={quote(player)}"
+
 
 class QueryMapperData(BaseModel):
     mapper: str
@@ -291,6 +333,10 @@ class QueryMapperData(BaseModel):
 class QueryMapper(BaseModel):
     players: list[QueryMapperData]
 
+    @staticmethod
+    def api(player: str) -> str:
+        return f"https://ddnet.org/maps/?qmapper={quote(player)}"
+
 
 class QueryMapData(BaseModel):
     name: str
@@ -301,6 +347,10 @@ class QueryMapData(BaseModel):
 class QueryMap(BaseModel):
     maps: list[QueryMapData]
 
+    @staticmethod
+    def api(map_name: str) -> str:
+        return f"https://ddnet.org/maps/?query={quote(map_name)}"
+
 
 class DDStatusData(BaseModel):
     name: str = None
@@ -326,3 +376,11 @@ class DDStatusData(BaseModel):
 
 class DDStatus(BaseModel):
     servers: list[DDStatusData]
+
+    @staticmethod
+    def url() -> str:
+        return "https://ddnet.org/status"
+
+    @staticmethod
+    def api() -> str:
+        return "https://ddnet.org/status/json/stats.json"

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/scheme/ddstats_tw.py

@@ -1,6 +1,7 @@
 # ddstats.tw
 from datetime import datetime
 from typing import Optional
+from urllib.parse import quote
 
 from pydantic import BaseModel, Field
 
@@ -11,19 +12,19 @@ class PData(BaseModel):
 
 
 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
+    Novice: PData | None = None
+    Moderate: PData | None = None
+    Brutal: PData | None = None
+    Insane: PData | None = None
+    Dummy: PData | None = None
+    DDmaX_Easy: PData | None = Field(default=None, validation_alias="DDmaX.Easy")
+    DDmaX_Next: PData | None = Field(default=None, validation_alias="DDmaX.Next")
+    DDmaX_Nut: PData | None = Field(default=None, validation_alias="DDmaX.Nut")
+    DDmaX_Pro: PData | None = Field(default=None, validation_alias="DDmaX.Pro")
+    Oldschool: PData | None = None
+    Race: PData | None = None
+    Solo: PData | None = None
+    total: PData | None = None
 
 
 class PointG(BaseModel):
@@ -36,16 +37,27 @@ class PointG(BaseModel):
 class Profile(BaseModel):
     name: str
     points: int
-    clan: Optional[str]
-    country: Optional[int]
-    skin_name: Optional[str]
-    skin_color_body: Optional[int] = None
-    skin_color_feet: Optional[int] = None
+    clan: str | None
+    country: int | None
+    skin_name: str | None
+    skin_color_body: int | None = None
+    skin_color_feet: int | None = None
 
 
 class DProfile(BaseModel):
     profile: Profile
 
+    def url(self) -> str:
+        return f"https://ddstats.tw/player/{quote(self.name)}"
+
+    @staticmethod
+    def url_with_name(player: str) -> str:
+        return f"https://ddstats.tw/player/{quote(player)}"
+
+    @staticmethod
+    def api(player: str) -> str:
+        return f"https://ddstats.tw/profile/json?player={quote(player)}"
+
 
 class DDMap(BaseModel):
     map: str
@@ -53,7 +65,7 @@ class DDMap(BaseModel):
     points: int
     stars: int
     mapper: str
-    timestamp: Optional[datetime] = None
+    timestamp: datetime | None = None
 
 
 class RecentFinishes(BaseModel):
@@ -97,24 +109,24 @@ class Finishes(BaseModel):
     map: DDMap
     name: str
     time: float
-    timestamp: Optional[datetime]
+    timestamp: datetime | None
     server: str
     rank: int
-    team_rank: Optional[int] = None
-    seconds_played: Optional[int] = None
+    team_rank: int | None = None
+    seconds_played: int | None = None
 
 
 class UnfinishedMap(BaseModel):
     map: DDMap
     finishes: int
-    finishes_rank: Optional[int] = None
-    median_time: Optional[float] = None
+    finishes_rank: int | None = None
+    median_time: float | None = None
 
 
 class Points(BaseModel):
-    weekly_points: Optional[PData] = None
-    monthly_points: Optional[PData] = None
-    yearly_points: Optional[PData] = None
+    weekly_points: PData | None = None
+    monthly_points: PData | None = None
+    yearly_points: PData | None = None
     points: PPoints
     rank_points: PPoints
     team_points: PPoints
@@ -132,9 +144,9 @@ class RecentPlayerInfo(BaseModel):
     name: str
     clan: str
     country: int
-    skin_name: Optional[str] = None
-    skin_color_body: Optional[int] = None
-    skin_color_feet: Optional[int] = None
+    skin_name: str | None = None
+    skin_color_body: int | None = None
+    skin_color_feet: int | None = None
     last_seen: str
     seconds_played: int
 
@@ -142,7 +154,7 @@ class RecentPlayerInfo(BaseModel):
 class MostPlayedMaps(BaseModel):
     map_name: str
     seconds_played: int
-    map: Optional[DDMap] = None
+    map: DDMap | None = None
 
 
 class MostPlayed(BaseModel):
@@ -175,7 +187,7 @@ class RecentTop10s(BaseModel):
     map: str
     time: float
     rank: int
-    timestamp: Optional[datetime] = None
+    timestamp: datetime | None = None
     server: str
 
 
@@ -188,28 +200,43 @@ class GeneralActivity(BaseModel):
 class Player(BaseModel):
     points_graph: list[PointG]
     recent_finishes: list[RecentFinishes]
-    favourite_teammates: Optional[list[FavouriteTeammates]] = None
+    favourite_teammates: list[FavouriteTeammates] | None = None
     profile: Profile
     is_mapper: bool
     finishes: list[Finishes]
-    unfinished_maps: Optional[list[UnfinishedMap]] = None
+    unfinished_maps: list[UnfinishedMap] | None = None
     points: Points
-    recent_activity: Optional[list[RecentActivity]] = None
-    recent_player_info: Optional[list[RecentPlayerInfo]] = None
-    most_played_maps: Optional[list[MostPlayedMaps]] = None
-    most_played_gametypes: Optional[list[MostPlayed]] = None
-    most_played_categories: Optional[list[MostPlayed]] = None
-    most_played_locations: Optional[list[MostPlayed]] = None
+    recent_activity: list[RecentActivity] | None = None
+    recent_player_info: list[RecentPlayerInfo] | None = None
+    most_played_maps: list[MostPlayedMaps] | None = None
+    most_played_gametypes: list[MostPlayed] | None = None
+    most_played_categories: list[MostPlayed] | None = None
+    most_played_locations: list[MostPlayed] | None = None
     playtime_per_month: list[PlaytimePerMonth]
-    general_activity: Optional[GeneralActivity] = None
-    favourite_rank1s_teammates: Optional[list[FavouriteRank1sTeammates]] = None
-    all_top_10s: Optional[list[AllTop10s]] = None
-    recent_top_10s: Optional[list[RecentTop10s]] = None
+    general_activity: GeneralActivity | None = None
+    favourite_rank1s_teammates: list[FavouriteRank1sTeammates] | None = None
+    all_top_10s: list[AllTop10s] | None = None
+    recent_top_10s: list[RecentTop10s] | None = None
+
+    def url(self) -> str:
+        return f"https://ddstats.tw/player/{quote(self.profile.name)}"
+
+    @staticmethod
+    def url_with_name(player: str) -> str:
+        return f"https://ddstats.tw/player/{quote(player)}"
+
+    @staticmethod
+    def api(player: str) -> str:
+        return f"https://ddstats.tw/player/json?player={quote(player)}"
 
 
 class Maps(BaseModel):
     maps: list[DDMap]
 
+    @staticmethod
+    def api() -> str:
+        return "https://ddstats.tw/maps/json"
+
 
 class InfoSMap(BaseModel):
     map: DDMap
@@ -220,7 +247,7 @@ class InfoSMap(BaseModel):
 
 class RankingSMap(BaseModel):
     rank: int
-    timestamp: Optional[datetime] = None
+    timestamp: datetime | None = None
     name: str
     time: float
     map: str
@@ -229,7 +256,7 @@ class RankingSMap(BaseModel):
 
 class TeamRankingSMap(BaseModel):
     rank: int
-    timestamp: Optional[datetime] = None
+    timestamp: datetime | None = None
     id: list[int]
     players: list[str]
     time: float
@@ -278,3 +305,14 @@ class SMap(BaseModel):
     team_rankings: list[TeamRankingSMap]
     time_cps: list[TimeCpsSMap]
     playtime: list[PlaytimeSMap]
+
+    def url(self) -> str:
+        return f"https://ddstats.tw/map/{quote(self.info.map.map)}"
+
+    @staticmethod
+    def url_with_name(map_name: str) -> str:
+        return f"https://ddstats.tw/map/{quote(map_name)}"
+
+    @staticmethod
+    def api(map_name: str) -> str:
+        return f"https://ddstats.tw/map/json?map={quote(map_name)}"

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi/scheme/status_tw.py

@@ -56,9 +56,9 @@ class ServerTw(BaseModel):
     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
+    website: str | None = None
+    discord_invite: str | None = Field(None, alias="discordInvite")
+    description: str | None = None
     game_type: DataTw = Field(alias="gameType")
     version: VersionTw
     clients: list[ClientTw]

{ddapi-0.13.0 → ddapi-0.14.0}/ddapi/ddapi.egg-info/PKG-INFO

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

{ddapi-0.13.0 → ddapi-0.14.0}/setup.cfg

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

{ddapi-0.13.0 → ddapi-0.14.0}/setup.py

@@ -1,11 +1,13 @@
+from pathlib import Path
+
 import setuptools
 
-with open("README.md", "r", encoding="utf-8") as fh:
+with Path.open(Path("README.md"), encoding="utf-8") as fh:
     long_description = fh.read()
 
 setuptools.setup(
     name="ddapi",
-    version="0.13.0",
+    version="0.14.0",
     author="ByFox",
     description="DDnet api",
     long_description=long_description,

ddapi-0.13.0/ddapi/ddapi/api/ddnet.py

@@ -1,72 +0,0 @@
-from urllib.parse import quote
-
-from .._api import API
-from ..scheme import (
-    DDPlayer,
-    DDStatus,
-    ReleasesMaps,
-    Query,
-    QueryMap,
-    QueryMapper,
-    Master,
-    DMap,
-)
-
-__all__ = ("DDnetApi",)
-
-from ..enum import MasterEnum
-
-
-class DDnetApi(API):
-    @property
-    def domain(self) -> str:
-        return "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, number: MasterEnum = MasterEnum.master1) -> Master:
-        return await self._generate_model_instance(
-            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
-        )

ddapi-0.13.0/ddapi/ddapi/api/ddstats.py

@@ -1,44 +0,0 @@
-from urllib.parse import quote
-
-from .._api import API
-from ..scheme import (
-    DProfile,
-    SMap,
-    Maps,
-    Player,
-)
-
-__all__ = ("DDstats",)
-
-
-class DDstats(API):
-    @property
-    def domain(self) -> str:
-        return "ddstats.tw"
-
-    @staticmethod
-    def powered() -> str:
-        return DDstats().domain
-
-    async def profile(self, player_name: str) -> DProfile:
-        return await self._generate_model_instance(
-            f"https://{self.domain}/profile/json?player={quote(player_name)}",
-            DProfile,
-            "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
-        )
-
-    async def maps(self) -> Maps:
-        return await self._generate_model_instance(
-            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
-        )

ddapi-0.13.0/ddapi/ddapi/cache/empty.py

@@ -1,14 +0,0 @@
-from typing import Any
-
-from ddapi.cache import CacheABC
-
-
-class EmptyCache(CacheABC):
-    async def get(self, key: str, default: Any = None) -> Any:
-        return default
-
-    async def set(self, key: str, value: Any, timeout_seconds: int = None) -> bool:
-        return True
-
-    def delete(self, key: str) -> bool:
-        return True

ddapi-0.13.0/ddapi/ddapi/cache/memory.py

@@ -1,29 +0,0 @@
-import asyncio
-from typing import Any
-
-from .base import CacheABC
-
-
-class MemoryCache(CacheABC):
-    async def get(self, key: str, default: Any = None) -> Any:
-        async with self._lock:
-            return self._cache.get(key, default)
-
-    async def set(self, key: str, value: Any, timeout_seconds: int = None) -> bool:
-        async with self._lock:
-            if timeout_seconds is None:
-                self._cache[key] = value
-                return True
-            asyncio.create_task(self._remove_after_timeout(key, timeout_seconds))
-            return True
-
-    async def delete(self, key: str) -> bool:
-        async with self._lock:
-            if key in self._cache:
-                del self._cache[key]
-                return True
-            return False
-
-    async def _remove_after_timeout(self, key: str, timeout: int):
-        await asyncio.sleep(timeout)
-        await self.delete(key)