Skip to content

Client

Client ¤

Sendou.ink Async API Client

Attributes:

Name Type Description
api_key str

Sendou.ink API Key
headers Dict[str, str]

Custom Headers
url str

Sendou.ink URL (Default: https://sendou.ink)
expiry Union[None, int, float, str, datetime, timedelta]

Cache Expiry Time (Default: 1800)

Examples:

from sendou import Client

client = Client("API")
Source code in sendou/client.py 
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class Client:
    """
    Sendou.ink Async API Client

    Attributes:
            api_key (str): Sendou.ink API Key
            headers (Dict[str, str]): Custom Headers
            url (str): Sendou.ink URL (**Default:** https://sendou.ink)
            expiry (Union[None, int, float, str, datetime, timedelta]): Cache Expiry Time (**Default:** 1800)

    Examples:
        ```python
        from sendou import Client

        client = Client("API")
        ```
    """
    __header: Dict[str, str]
    __client: RequestsClient

    def __init__(self, api_key: str, headers: Dict[str, str] = {}, url: Optional[str] = None,
                 expiry: Union[None, int, float, str, datetime, timedelta] = 1800):
        self.__headers = headers
        if "User-Agent" not in self.__headers:
            self.__headers["User-Agent"] = "sendou.py"
        if url:
            self.url = url
        else:
            self.url = "https://sendou.ink"
        self.__headers["Authorization"] = f"Bearer {api_key}"
        self.__client = RequestsClient.create(self.url, headers=self.__headers, expiry=expiry)

    def set_cache_backend(self, cache: CacheBackend):
        """
        Set the cache backend for the client. Use if you want to use a custom cache backend.

        Attributes:
            cache: Cache Backend

        Returns:
            (None): None
        """
        self.__client.cache = cache

    async def get_user(self, user_id: str) -> Optional[User]:
        """
        Get Sendou.ink user

        Attributes:
            user_id: User ID

        Returns:
            (Optional[User]): User (None if not found)

        Examples:
            ```python
            import sendou
            import asyncio

            async def run():
                client = sendou.Client("API_KEY")
                player = await client.get_user("USER_ID")
                print(player.name)

            asyncio.run(run())
            ```
        """
        path = User.api_route(user_id=user_id)
        data = await self.__client.get_response(path)
        return User(data, self.__client)

    async def get_calendar(self, year: int, week: int) -> List[CalendarEntry]:
        """
        Get Sendou.ink calendar

        Attributes:
            year: Year
            week: Week of year

        Returns:
            (List[CalendarEntry]): Calendar Entries
        """
        path = CalendarEntry.api_route(year=year, week=week)
        data = await self.__client.get_response(path)
        return [CalendarEntry(entry, self.__client) for entry in data]

    async def get_tournament(self, tournament_id: str) -> Optional[Tournament]:
        """
        Get Sendou.ink tournament

        Attributes:
            tournament_id: Tournament ID

        Returns:
            (Optional[Tournament]): Tournament (None if not found)
        """
        path = Tournament.api_route(tournament_id=tournament_id)
        data = await self.__client.get_response(path)
        return Tournament(int(tournament_id), data, self.__client)

    async def get_tournament_matches(self, match_id: str) -> Optional[Match]:
        """
        Get Sendou.ink match

        Attributes:
            match_id: Match ID

        Returns:
            (Optional[Match]): Match (None if not found)
        """
        path = Match.api_route(match_id=match_id)
        data = await self.__client.get_response(path)
        return Match(data, self.__client)

    async def get_organization(self, organization_id: str) -> Optional[Organization]:
        """
        Get Sendou.ink organization

        Attributes:
            organization_id: Organization ID

        Returns:
            (Optional[Organization]): Organization (None if not found)
        """
        path = Organization.api_route(organization_id=organization_id)
        data = await self.__client.get_response(path)
        return Organization.from_dict(data, self.__client)

get_calendar(year, week) async ¤

Get Sendou.ink calendar

Attributes:

Name Type Description
year

Year
week

Week of year

Returns:

Type Description
List[CalendarEntry]

Calendar Entries
Source code in sendou/client.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
async def get_calendar(self, year: int, week: int) -> List[CalendarEntry]:
    """
    Get Sendou.ink calendar

    Attributes:
        year: Year
        week: Week of year

    Returns:
        (List[CalendarEntry]): Calendar Entries
    """
    path = CalendarEntry.api_route(year=year, week=week)
    data = await self.__client.get_response(path)
    return [CalendarEntry(entry, self.__client) for entry in data]

get_organization(organization_id) async ¤

Get Sendou.ink organization

Attributes:

Name Type Description
organization_id

Organization ID

Returns:

Type Description
Optional[Organization]

Organization (None if not found)
Source code in sendou/client.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
async def get_organization(self, organization_id: str) -> Optional[Organization]:
    """
    Get Sendou.ink organization

    Attributes:
        organization_id: Organization ID

    Returns:
        (Optional[Organization]): Organization (None if not found)
    """
    path = Organization.api_route(organization_id=organization_id)
    data = await self.__client.get_response(path)
    return Organization.from_dict(data, self.__client)

get_tournament(tournament_id) async ¤

Get Sendou.ink tournament

Attributes:

Name Type Description
tournament_id

Tournament ID

Returns:

Type Description
Optional[Tournament]

Tournament (None if not found)
Source code in sendou/client.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
async def get_tournament(self, tournament_id: str) -> Optional[Tournament]:
    """
    Get Sendou.ink tournament

    Attributes:
        tournament_id: Tournament ID

    Returns:
        (Optional[Tournament]): Tournament (None if not found)
    """
    path = Tournament.api_route(tournament_id=tournament_id)
    data = await self.__client.get_response(path)
    return Tournament(int(tournament_id), data, self.__client)

get_tournament_matches(match_id) async ¤

Get Sendou.ink match

Attributes:

Name Type Description
match_id

Match ID

Returns:

Type Description
Optional[Match]

Match (None if not found)
Source code in sendou/client.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
async def get_tournament_matches(self, match_id: str) -> Optional[Match]:
    """
    Get Sendou.ink match

    Attributes:
        match_id: Match ID

    Returns:
        (Optional[Match]): Match (None if not found)
    """
    path = Match.api_route(match_id=match_id)
    data = await self.__client.get_response(path)
    return Match(data, self.__client)

get_user(user_id) async ¤

Get Sendou.ink user

Attributes:

Name Type Description
user_id

User ID

Returns:

Type Description
Optional[User]

User (None if not found)

Examples:

import sendou
import asyncio

async def run():
    client = sendou.Client("API_KEY")
    player = await client.get_user("USER_ID")
    print(player.name)

asyncio.run(run())
Source code in sendou/client.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
async def get_user(self, user_id: str) -> Optional[User]:
    """
    Get Sendou.ink user

    Attributes:
        user_id: User ID

    Returns:
        (Optional[User]): User (None if not found)

    Examples:
        ```python
        import sendou
        import asyncio

        async def run():
            client = sendou.Client("API_KEY")
            player = await client.get_user("USER_ID")
            print(player.name)

        asyncio.run(run())
        ```
    """
    path = User.api_route(user_id=user_id)
    data = await self.__client.get_response(path)
    return User(data, self.__client)

set_cache_backend(cache) ¤

Set the cache backend for the client. Use if you want to use a custom cache backend.

Attributes:

Name Type Description
cache

Cache Backend

Returns:

Type Description
None

None
Source code in sendou/client.py 
40
41
42
43
44
45
46
47
48
49
50
def set_cache_backend(self, cache: CacheBackend):
    """
    Set the cache backend for the client. Use if you want to use a custom cache backend.

    Attributes:
        cache: Cache Backend

    Returns:
        (None): None
    """
    self.__client.cache = cache