vprikol 0.1.0__tar.gz

vprikol-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: vprikol
+Version: 0.1.0
+Summary: 
+Author: evans
+Author-email: szx@bk.ru
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
+Requires-Dist: pydantic (>=2.7.4,<3.0.0)
+Description-Content-Type: text/markdown
+
+

vprikol-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "vprikol"
+version = "0.1.0"
+description = ""
+authors = ["evans <szx@bk.ru>"]
+readme = "README.md"
+packages = [{include = "vprikol"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+pydantic = "^2.7.4"
+aiohttp = "^3.9.5"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

vprikol-0.1.0/vprikol/__init__.py

@@ -0,0 +1,3 @@
+from .main import VprikolAPI
+
+__all__ = VprikolAPI

vprikol-0.1.0/vprikol/api.py

@@ -0,0 +1,32 @@
+from typing import Optional, Dict
+
+import aiohttp
+
+from .model import Response
+
+
+async def get_json(url: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Response:
+    async with aiohttp.ClientSession(headers=headers) as session:
+        async with session.get(url, params=params) as response:
+            response_json = await response.json()
+            if response.ok:
+                return Response(data=response_json)
+            return Response(error=response_json, success=False)
+
+
+async def post_json(url: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Response:
+    async with aiohttp.ClientSession(headers=headers) as session:
+        async with session.post(url, params=params) as response:
+            response_json = await response.json()
+            if response.ok:
+                return Response(data=response_json)
+            return Response(error=response_json, success=False)
+
+
+async def get_bytes(url: str, params: Optional[Dict] = None, headers: Optional[Dict] = None) -> Response:
+    async with aiohttp.ClientSession(headers=headers) as session:
+        async with session.get(url, params=params) as response:
+            response_data = await response.read()
+            if response.status == 200:
+                return Response(data=response_data)
+            return Response(error=(await response.json()), success=False)

vprikol-0.1.0/vprikol/main.py

@@ -0,0 +1,161 @@
+import asyncio
+import time
+from typing import List, Literal, Optional, Union, Dict
+
+from pydantic import parse_obj_as, ValidationError
+
+from .api import get_json, post_json, get_bytes
+from .model import (IpAPIResponse, MembersAPIResponse, PlayerInfoAPIResponse, CreatedFindTaskAPIResponse,
+                    ServerStatusAPIResponse, RatingAPIResponse, CheckRPUsernameAPIResponse, GenerateRPUsernameAPIResponse,
+                    PlayerInfoNotFound, PlayerOnlineAPIResponse, GhettoZonesAPIResponse, PlayerEstateAPIResponse, PlayersAPIResponse)
+
+Gender = Literal['male', 'female']
+Nation = Literal['russian', 'american', 'german', 'french', 'italian', 'japanese', 'latinos', 'swedish', 'danish', 'romanian']
+
+
+class VprikolAPI:
+    def __init__(self, token: str, base_url: str = 'https://api.szx.su/'):
+        if not token.startswith('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.'):
+            raise Exception('Токен передан неправильно.')
+        self.headers = {'Authorization': f'Bearer {token}'}
+        self.base_url = base_url
+
+    async def get_ip_info(self, ip: str) -> IpAPIResponse:
+        result = await get_json(url=f'{self.base_url}ip', headers=self.headers, params={'ip': ip})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return IpAPIResponse(**result.data)
+
+    async def get_members(self, server_id: int, fraction_id: Union[int, List[int]]) -> Dict[str, MembersAPIResponse]:
+        result = await get_json(url=f'{self.base_url}members', headers=self.headers, params={'server_id': server_id, 'fraction_id': fraction_id})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        response = {}
+        for fraction_id in result.data:
+            players = []
+            if not fraction_id.isdigit():
+                continue
+            for player in result.data[fraction_id]['players']:
+                players.append({'username': player, 'id': result.data[fraction_id]['players'][player]['id'],
+                                'isOnline': result.data[fraction_id]['players'][player]['isOnline'],
+                                'isLeader': result.data[fraction_id]['players'][player]['isLeader'],
+                                'rank': result.data[fraction_id]['players'][player]['rank'],
+                                'rankLabel': result.data[fraction_id]['players'][player]['rankLabel'],
+                                'ingameId': result.data[fraction_id]['players'][player]['ingameId'],
+                                'lvl': result.data[fraction_id]['players'][player]['lvl'],
+                                'ping': result.data[fraction_id]['players'][player]['ping'],
+                                'color': result.data[fraction_id]['players'][player]['color']
+                                }
+                               )
+            result.data[fraction_id]['players'] = players
+            response[fraction_id] = MembersAPIResponse(
+                    **result.data[fraction_id]
+            )
+
+        return response
+
+    async def get_player_information(self, server_id: int, nickname: str) -> Union[PlayerInfoAPIResponse, PlayerInfoNotFound]:
+        task = await post_json(url=f'{self.base_url}find/createTask', headers=self.headers, params={'server': server_id, 'nick': nickname})
+
+        if not task.success:
+            raise Exception(task.error)
+
+        task = CreatedFindTaskAPIResponse(**task.data)
+        while True:
+            result = await get_json(url=f'{self.base_url}find/getTaskResult', headers=self.headers, params={'request_id': task.request_id})
+
+            if not result.success and result.error.error_code and result.error.error_code == 425:
+                await asyncio.sleep(0.5)
+                continue
+
+            if result.error and result.error.error_code == 422:
+                return PlayerInfoNotFound(**result.error.dict())
+
+            if result.error and result.error.error_code in [500, 502, 503]:
+                raise Exception(result.error.detail)
+
+            try:
+                return PlayerInfoAPIResponse(**result.data)
+            except ValidationError:
+                return PlayerInfoAPIResponse(**result.data)
+
+    async def get_server_status(self, server_id: Optional[int] = None) -> Union[List[ServerStatusAPIResponse], ServerStatusAPIResponse]:
+        params = {'server': server_id} if server_id else None
+
+        result = await get_json(url=f'{self.base_url}status', headers=self.headers, params=params)
+
+        if not result.success:
+            raise Exception(result.error)
+
+        if isinstance(result.data, list):
+            return parse_obj_as(List[ServerStatusAPIResponse], result.data)
+
+        return ServerStatusAPIResponse(**result.data)
+
+    async def get_rating(self, server_id: int, rating_type: Literal[1, 2, 3]) -> RatingAPIResponse:
+        result = await get_json(url=f'{self.base_url}rating', headers=self.headers, params={'type': rating_type, 'server': server_id})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return RatingAPIResponse(**result.data)
+
+    async def check_rp_nickname(self, nickname: str, ai: bool = False) -> CheckRPUsernameAPIResponse:
+        result = await get_json(url=f'{self.base_url}checkrp', headers=self.headers, params={'nick': nickname, 'ai': int(ai)})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return CheckRPUsernameAPIResponse(**result.data)
+
+    async def generate_rp_nickname(self, gender: Gender, nation: Nation) -> GenerateRPUsernameAPIResponse:
+        result = await get_json(url=f'{self.base_url}rpnick', headers=self.headers, params={'gender': gender, 'nation': nation})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return GenerateRPUsernameAPIResponse(**result.data)
+
+    async def get_player_online(self, nickname: str, server_id: int, count: int = 100, offset: int = 0, date: int = int(time.time())) -> PlayerOnlineAPIResponse:
+        result = await get_json(url=f'{self.base_url}online', headers=self.headers, params={'nickname': nickname, 'count': count, 'offset': offset, 'server_id': server_id, 'filter_by_date': date})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return PlayerOnlineAPIResponse(**result.data)
+
+    async def get_ghetto_map(self, server_id: int) -> bytes:
+        result = await get_bytes(url=f'{self.base_url}ghetto/map', headers=self.headers, params={'server_id': server_id})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return result.data
+
+    async def get_ghetto_zones(self, server_id: int) -> GhettoZonesAPIResponse:
+        result = await get_json(url=f'{self.base_url}ghetto/zones', headers=self.headers, params={'server_id': server_id})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return GhettoZonesAPIResponse(**result.data)
+
+    async def get_estate(self, nickname: str, server_id: int) -> PlayerEstateAPIResponse:
+        result = await get_json(url=f'{self.base_url}estate', headers=self.headers, params={'server_id': server_id, 'nickname': nickname})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return PlayerEstateAPIResponse(**result.data)
+
+    async def get_players(self, server_id: int, nicknames: Optional[List[Union[str, int]]] = None) -> PlayersAPIResponse:
+        result = await get_json(url=f'{self.base_url}players?nicknames={nicknames}', headers=self.headers, params={'server_id': server_id})
+
+        if not result.success:
+            raise Exception(result.error)
+
+        return PlayersAPIResponse(**result.data)

vprikol-0.1.0/vprikol/model.py

@@ -0,0 +1,206 @@
+from typing import TypeVar, List, Optional, Dict, Generic, Union
+
+from pydantic import BaseModel, Field
+
+DataT = TypeVar('DataT')
+
+
+class FastAPIErrorDetail(BaseModel):
+    loc: List[str]
+    message: str = Field(alias='msg')
+    type: str
+
+
+class FastApiErrorResponse(BaseModel):
+    detail: Union[list[FastAPIErrorDetail] , str]
+
+
+class APIErrorResponse(BaseModel):
+    error_code: int
+    detail: str
+    queue_position: Optional[int] = None
+
+
+class Response(BaseModel, Generic[DataT]):
+    data: Optional[DataT] = None
+    error: Optional[Union[FastApiErrorResponse, APIErrorResponse]] = None
+    success: bool = True
+
+
+class MembersAPIPlayer(BaseModel):
+    username: str
+    id: Optional[int] = None
+    is_online: bool = Field(alias='isOnline')
+    is_leader: bool = Field(alias='isLeader')
+    rank: int
+    rank_label: Optional[str] = Field(None, alias='rankLabel')
+    ingame_id: Optional[int] = Field(None, alias='ingameId')
+    ping: Optional[int]
+    lvl: Optional[int]
+    color: Optional[int]
+
+
+class MembersAPIRecord(BaseModel):
+    count: int
+    date: str
+    leader: str
+
+
+class MembersAPIResponse(BaseModel):
+    server_label: str = Field(alias='serverName')
+    fraction_label: str = Field(alias='fractionLabel')
+    players: List[MembersAPIPlayer]
+    record: MembersAPIRecord
+    total_players: int = Field(alias='totalPlayers')
+    total_online: int = Field(alias='totalOnline')
+    leader_nickname: Optional[str] = Field(None, alias='leaderNick')
+    is_leader_online: bool = Field(alias='isLeaderOnline')
+    online_updated_at: int = Field(alias='onlineUpdatedAt')
+    members_updated_at: int = Field(alias='membersUpdatedAt')
+
+
+class ServerStatusAPIResponse(BaseModel):
+    server_number: int = Field(alias='number')
+    ip: str
+    port: int
+    online_players: int = Field(alias='onlinePlayers')
+    max_players: int = Field(alias='maxPlayers')
+    is_closed: bool = Field(alias='isClosed')
+    server_label: str = Field(alias='serverLabel')
+
+
+class CreatedFindTaskAPIResponse(BaseModel):
+    request_id: str
+    request_time: int
+    queue_position: int
+
+
+class PlayerInfoAPIResponse(BaseModel):
+    account_id: Optional[int] = Field(None, alias='accountId')
+    player_id: Optional[int] = Field(None, alias='playerId')
+    lvl: Optional[int] = None
+    cash: Optional[int] = None
+    bank: Optional[int] = None
+    individual_account: Optional[int] = Field(None, alias='individualAccount')
+    deposit: Optional[int] = None
+    total_money: Optional[int] = Field(None, alias='totalMoney')
+    is_online: bool = Field(False, alias='isOnline')
+    job_label: Optional[str] = Field(None, alias='jobLabel')
+    job_id: Optional[int] = Field(None, alias='jobId')
+    rank_number: Optional[int] = Field(None, alias='rankNumber')
+    rank_label: Optional[str] = Field(None, alias='rankLabel')
+    is_leader: bool = Field(False, alias='isLeader')
+    org_label: str = Field('', alias='orgLabel')
+    org_id: int = Field(0, alias='orgId')
+    vip_lvl: Optional[int] = Field(None, alias='vipLvl')
+    vip_label: Optional[str] = Field(None, alias='vipLabel')
+    phone_number: Optional[int] = Field(None, alias='phoneNumber')
+    updated_at: int = Field(0, alias='updatedAt')
+    player_nick: str = Field('', alias='playerNick')
+    player_server: int = Field(0, alias='playerServer')
+    server_name: str = Field('', alias='serverName')
+
+
+class PlayerInfoNotFound(APIErrorResponse):
+    pass
+
+
+class RatingPlayerInfo(BaseModel):
+    number: int
+    name: str
+    is_online: bool = Field('isOnline')
+
+
+class RatingAPIResponse(BaseModel):
+    server: str
+    players: List[RatingPlayerInfo]
+
+
+class IpAPIResponse(BaseModel):
+    ip: str
+    country: str
+    city: str
+    timezone: str
+    isp: str
+
+
+class CheckRPUsernameName(BaseModel):
+    rp: bool
+    graph: Optional[str] = None
+    gpt_answer: Optional[str] = None
+
+
+class CheckRPUsernameAPIResponse(BaseModel):
+    name: CheckRPUsernameName
+    surname: CheckRPUsernameName
+    nickname: str = Field(alias='nick')
+
+
+class GhettoZonesData(BaseModel):
+    grove: int = Field(alias='2569507584')
+    ballas: int = Field(alias='2580283596')
+    vagos: int = Field(alias='2568805329')
+    rifa: int = Field(alias='2583651942')
+    aztec: int = Field(alias='2581790464')
+    nw: int = Field(alias='2155378856')
+
+
+class GhettoZonesAPIResponse(BaseModel):
+    data: GhettoZonesData
+    server_name: str = Field(alias='serverName')
+    updated_at: int = Field(alias='updatedAt')
+
+
+class AuctionInfo(BaseModel):
+    active: bool
+    minimal_bet: int = Field("minimalBet")
+    time_end: int = Field(alias='timeEnd')
+    start_price: int = Field(alias='startPrice')
+
+
+class Coordinates(BaseModel):
+    x: float
+    y: float
+
+
+class EstateItem(BaseModel):
+    id: int
+    name: Optional[str]
+    owner: Optional[str]
+    auction: AuctionInfo
+    coordinates: Coordinates
+
+
+class PlayerEstateAPIResponse(BaseModel):
+    server_id: int = Field(alias='serverId')
+    server_label: str = Field(alias='serverLabel')
+    nickname: str = Field(alias='nickname')
+    houses: List[EstateItem]
+    businesses: List[EstateItem]
+
+
+class GenerateRPUsernameAPIResponse(BaseModel):
+    name: str
+    surname: str
+
+
+class OnlinePlayerInfo(BaseModel):
+    login_at: int
+    logout_at: int
+
+
+class PlayerOnlineAPIResponse(BaseModel):
+    sessions: List[OnlinePlayerInfo]
+
+
+class PlayerData(BaseModel):
+    ingame_id: Optional[int] = Field(None, alias='ingameId')
+    lvl: Optional[int] = None
+    ping: Optional[int] = None
+    color: Optional[int] = None
+
+
+class PlayersAPIResponse(BaseModel):
+    server_name: str = Field(alias='serverName')
+    updated_at: int = Field(alias='updatedAt')
+    data: Dict[str, Optional[PlayerData]]