init-data-py 0.1.0__tar.gz

init_data_py-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish Python Package to PyPI
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/init-data-py
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Search and replace version
+        run: |
+          VERSION="${TAG_NAME//v/}"
+          sed -i "s/1\.0+versionplaceholder\.1/$VERSION/" pyproject.toml
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name }}
+
+      - uses: eifinger/setup-rye@v4
+        with:
+          enable-cache: true
+
+      - name: Build
+        run: |
+          rye build
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

init_data_py-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv
+
+.mypy_cache
+.ruff_cache

init_data_py-0.1.0/.python-version

@@ -0,0 +1 @@
+3.11.9

init_data_py-0.1.0/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 nimaxin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

init_data_py-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.3
+Name: init-data-py
+Version: 0.1.0
+Summary: A Python library that provides tools for using and validating Telegram web app init data.
+Author-email: nimaxin <nimaxin@proton.me>
+License-Expression: MIT
+License-File: LICENCE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# init-data-py
+
+A Python library that provides tools for using and validating Telegram web app init data.
+
+## Installation
+
+You can install the library using pip.
+
+```bash
+pip install init-data-py
+```
+
+## Usage
+
+### Parsing.
+
+```python
+from init_data_py import InitData
+
+query_string = "query_id=AAF03wc0Ag..."
+
+InitData.from_query_string(query_string)
+```
+
+### Signing
+
+```python
+from init_data_py import InitData
+from init_data_py.types import User
+
+BOT_TOKEN = "7244657541:AA..."
+
+init_data = InitData(
+    user=User(
+        id=5167898484,
+        first_name="xin",
+        username="pvnimaxin",
+    )
+).sign(bot_token=BOT_TOKEN)
+```
+
+### Validation
+
+```python
+from init_data_py import InitData
+
+BOT_TOKEN = "7244657541:AA..."
+
+init_data = InitData(...)
+is_valid = init_data.validate(bot_token=BOT_TOKEN, lifetime=3600)
+```
+
+## License
+
+This library is licensed under the [MIT License](LICENCE).

init_data_py-0.1.0/README.md

@@ -0,0 +1,55 @@
+# init-data-py
+
+A Python library that provides tools for using and validating Telegram web app init data.
+
+## Installation
+
+You can install the library using pip.
+
+```bash
+pip install init-data-py
+```
+
+## Usage
+
+### Parsing.
+
+```python
+from init_data_py import InitData
+
+query_string = "query_id=AAF03wc0Ag..."
+
+InitData.from_query_string(query_string)
+```
+
+### Signing
+
+```python
+from init_data_py import InitData
+from init_data_py.types import User
+
+BOT_TOKEN = "7244657541:AA..."
+
+init_data = InitData(
+    user=User(
+        id=5167898484,
+        first_name="xin",
+        username="pvnimaxin",
+    )
+).sign(bot_token=BOT_TOKEN)
+```
+
+### Validation
+
+```python
+from init_data_py import InitData
+
+BOT_TOKEN = "7244657541:AA..."
+
+init_data = InitData(...)
+is_valid = init_data.validate(bot_token=BOT_TOKEN, lifetime=3600)
+```
+
+## License
+
+This library is licensed under the [MIT License](LICENCE).

init_data_py-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "init-data-py"
+version = "0.1.0"
+description = "A Python library that provides tools for using and validating Telegram web app init data."
+authors = [
+    { name = "nimaxin", email = "nimaxin@proton.me" }
+]
+dependencies = []
+readme = "README.md"
+requires-python = ">= 3.8"
+license = "MIT"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.rye]
+managed = true
+dev-dependencies = [
+    "mypy>=1.11.1",
+    "tox>=4.17.1",
+    "ruff>=0.5.7",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/init_data_py"]
+
+[tool.rye.scripts]
+tests = "python -m unittest discover --verbose"
+
+[tool.ruff]
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 79
+indent-width = 4
+
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I001"]
+fixable = ["ALL"]
+
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

init_data_py-0.1.0/requirements-dev.lock

@@ -0,0 +1,42 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.
+cachetools==5.4.0
+    # via tox
+chardet==5.2.0
+    # via tox
+colorama==0.4.6
+    # via tox
+distlib==0.3.8
+    # via virtualenv
+filelock==3.15.4
+    # via tox
+    # via virtualenv
+mypy==1.11.1
+mypy-extensions==1.0.0
+    # via mypy
+packaging==24.1
+    # via pyproject-api
+    # via tox
+platformdirs==4.2.2
+    # via tox
+    # via virtualenv
+pluggy==1.5.0
+    # via tox
+pyproject-api==1.7.1
+    # via tox
+ruff==0.5.7
+tox==4.17.1
+typing-extensions==4.12.2
+    # via mypy
+virtualenv==20.26.3
+    # via tox

init_data_py-0.1.0/requirements.lock

@@ -0,0 +1,12 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.

init_data_py-0.1.0/src/init_data_py/__init__.py

@@ -0,0 +1,5 @@
+from .init_data import InitData
+
+__version__ = "0.1.0"
+
+__all__ = ["InitData"]

init_data_py-0.1.0/src/init_data_py/errors/__init__.py

@@ -0,0 +1,15 @@
+from .errors import (
+    AuthDateMissingError,
+    ExpiredError,
+    SignInvalidError,
+    SignMissingError,
+    UnexpectedFormatError,
+)
+
+__all__ = [
+    "AuthDateMissingError",
+    "ExpiredError",
+    "SignInvalidError",
+    "SignMissingError",
+    "UnexpectedFormatError",
+]

init_data_py-0.1.0/src/init_data_py/errors/errors.py

@@ -0,0 +1,23 @@
+class AuthDateMissingError(Exception):
+    def __init__(self):
+        super().__init__("auth_date is missing.")
+
+
+class ExpiredError(Exception):
+    def __init__(self):
+        super().__init__("init data is expired.")
+
+
+class SignInvalidError(Exception):
+    def __init__(self):
+        super().__init__("signature (hash) is invalid.")
+
+
+class SignMissingError(Exception):
+    def __init__(self):
+        super().__init__("signature (hash) is missing.")
+
+
+class UnexpectedFormatError(Exception):
+    def __init__(self):
+        super().__init__("the init data query string has unexpected format.")

init_data_py-0.1.0/src/init_data_py/init_data.py

@@ -0,0 +1,261 @@
+import hashlib
+import hmac
+import json
+import time
+import urllib.parse
+from datetime import datetime, timedelta
+from typing import Literal, Optional
+
+from init_data_py import errors, types
+
+
+class InitData:
+    """Represent a [WebAppInitData](https://core.telegram.org/bots/webapps#webappinitdata).
+
+    Parameters:
+        query_id (`str`, optional):
+            A unique identifier for the Mini App session, required for sending messages via the answerWebAppQuery method.
+
+        user (`init_data_py.types.User`, optional):
+            An object containing data about the current user.
+
+        receiver (`init_data_py.types.User`, optional):
+            An object containing data about the chat partner of the current user in the chat where the bot was launched via the attachment menu. Returned only for private chats and only for Mini Apps launched via the attachment menu.
+
+        chat (`init_data_py.types.Chat`, optional):
+            An object containing data about the chat where the bot was launched via the attachment menu. Returned for supergroups, channels and group chats - only for Mini Apps launched via the attachment menu.
+
+        chat_type (`str`, optional):
+            Type of the chat from which the Mini App was opened. Can be either "sender" for a private chat with the user opening the link, "private", "group", "supergroup", or "channel". Returned only for Mini Apps launched from direct links.
+
+        chat_instance (`str`, optional):
+            Global identifier, uniquely corresponding to the chat from which the Mini App was opened. Returned only for Mini Apps launched from a direct link.
+
+        start_param (`str`, optional):
+            The value of the startattach parameter, passed via link. Only returned for Mini Apps when launched from the attachment menu via link.
+
+        can_send_after (`int`, optional):
+            Time in seconds, after which a message can be sent via the answerWebAppQuery method.
+
+        auth_date (`int`, optional):
+            Unix time when the form was opened.
+
+        hash (`str`, optional):
+            A hash of all passed parameters, which the bot server can use to check their validity.
+    """
+
+    def __init__(
+        self,
+        *,
+        query_id: Optional[str] = None,
+        user: Optional["types.User"] = None,
+        receiver: Optional["types.User"] = None,
+        chat: Optional["types.Chat"] = None,
+        chat_type: Optional[
+            Literal["sender", "private", "group", "supergroup", "channel"]
+        ] = None,
+        chat_instance: Optional[str] = None,
+        start_param: Optional[str] = None,
+        can_send_after: Optional[int] = None,
+        auth_date: Optional[int] = None,
+        hash: Optional[str] = None,
+    ) -> None:
+        self.query_id = query_id
+        self.user = user
+        self.receiver = receiver
+        self.chat = chat
+        self.chat_type = chat_type
+        self.chat_instance = chat_instance
+        self.start_param = start_param
+        self.can_send_after = can_send_after
+        self.auth_date = auth_date
+        self.hash = hash
+
+    def validate(self, bot_token: str, lifetime: Optional[int] = None):
+        """Validates the init data authenticity.
+
+        Parameters:
+            bot_token (`str`):
+                The token associated with the bot, used to either launch the webapp or sign the init data.
+
+            lifetime (`int`, optional):
+                The maximum validity period of the init data in seconds.
+                Recommended for security. Default is `None`.
+
+        Returns:
+            `bool`:
+                `True` if the init data is valid; otherwise, raises an exception.
+
+        Raises:
+            `errors.SignMissingError`: In case the signature (hash) is missing.
+            `errors.AuthDateMissingError`: In case the auth_date is missing.
+            `errors.ExpiredError`: In case the init data has expired based on the provided lifetime.
+            `errors.SignInvalidError`: In case the signature (hash) is invalid.
+        """
+        if self.hash is None:
+            raise errors.SignMissingError()
+
+        if self.auth_date is None:
+            raise errors.AuthDateMissingError()
+
+        if lifetime is not None:
+            auth_date = datetime.fromtimestamp(self.auth_date)
+            expire_date = auth_date - timedelta(seconds=lifetime)
+            if datetime.now() > expire_date:
+                raise errors.ExpiredError()
+
+        if self.hash != self.calculate_hash(bot_token):
+            raise errors.SignInvalidError()
+
+        return True
+
+    def sign(self, bot_token: str, auth_date: Optional[int] = None):
+        """Sign the init data using the provided bot token.
+
+        Parameters:
+            bot_token (`str`):
+                The bot token used to generate the signature for init data.
+
+            auth_date (`init`):
+                The timestamp (without timezone) representing the authorization date. If not provided, the current timestamp will be used.
+
+        Returns:
+            `None`:
+                This method updates the current init data by setting the `auth_date` and generated signature (`hash`) attributes.
+        """
+        if auth_date is None:
+            self.auth_date = int(time.time())
+        self.auth_date = auth_date
+        self.hash = self.calculate_hash(bot_token)
+
+    def calculate_hash(
+        self,
+        bot_token: str,
+    ):
+        """Calculates a hash based on the bot token and the current `InitData` object.
+
+        Parameters:
+            bot_token (`str`):
+                The bot token used to generate the secret key for hash computation.
+
+        Returns:
+            `str`:
+                The calculated hash, derived from the init data attributes and the generated secret key.
+        """
+        init_data = self.to_dict(nested=False)
+        init_data.pop("hash", None)
+        sorted_attrs = sorted(init_data.items())
+        data_check_string = "\n".join(
+            f"{k}={v}" for k, v in sorted_attrs
+        ).encode()
+        secret_key = hmac.new(
+            b"WebAppData", bot_token.encode(), hashlib.sha256
+        ).digest()
+        return hmac.new(
+            secret_key, data_check_string, hashlib.sha256
+        ).hexdigest()
+
+    @classmethod
+    def from_query_string(cls, query_string: str):
+        """Create an InitData object from a query string.
+
+        Parameters:
+            query_string (`str`):
+                The query string from `window.WebApp.initData` to parse and covert into an WebAppInitData object.
+
+        Raises:
+            `errors.SignMissingError`: In case the signature (hash) is missing.
+            `errors.AuthDateMissingError`: In case the auth_date is missing.
+            `errors.UnexpectedFormatError`: In case the the format of the query string is unexpected.
+        """
+        parsed_qs = dict(urllib.parse.parse_qsl(query_string))
+
+        if not parsed_qs:
+            raise errors.UnexpectedFormatError()
+
+        init_data = {}
+
+        for k, v in parsed_qs.items():
+            if k in {
+                "hash",
+                "query_id",
+                "chat_type",
+                "chat_instance",
+                "start_param",
+            }:
+                init_data[k] = v
+
+            elif k in {"auth_date", "can_send_after"}:
+                init_data[k] = int(v)  # type: ignore
+            elif k in {"user", "receiver"}:
+                try:
+                    init_data[k] = types.User.from_json(v)
+                except json.decoder.JSONDecodeError:
+                    raise errors.UnexpectedFormatError()
+            elif k == "chat":
+                try:
+                    init_data[k] = types.Chat.from_json(v)
+                except json.decoder.JSONDecodeError:
+                    raise errors.UnexpectedFormatError()
+            else:
+                raise errors.UnexpectedFormatError()
+
+        hash = parsed_qs.get("hash")
+        if hash is None:
+            raise errors.UnexpectedFormatError()
+
+        auth_date = parsed_qs.get("auth_date")
+        if auth_date is None:
+            raise errors.UnexpectedFormatError()
+
+        return cls(**init_data)  # type: ignore
+
+    def to_json(self):
+        """Returns a JSON serialized representation of the object."""
+        return json.dumps(self.to_dict(nested=True))
+
+    def to_dict(self, nested=True):
+        """Returns a dictionary representation of the object.
+
+        Parameters:
+            nested (`bool`):
+                If True, nested objects will be converted to dictionaries; if False, nested objects will be represented as serialized JSON.
+        """
+        init_data_attrs = {
+            k: v for k, v in self.__dict__.items() if v is not None
+        }
+        init_data = {}
+
+        for k, v in init_data_attrs.items():
+            if isinstance(v, (types.User, types.Chat)):
+                if nested:
+                    init_data[k] = v.to_dict()
+                    continue
+                init_data[k] = v.to_json()
+            elif k in {"auth_date", "can_send_after"}:
+                init_data[k] = int(v)
+            else:
+                init_data[k] = str(v)
+
+        return init_data
+
+    def to_query_string(self):
+        """Returns a query string representation of the object."""
+        init_data = self.to_dict(nested=False)
+        return urllib.parse.urlencode(init_data)
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_dict(nested=True), indent=4)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+
+        for attr in self.__dict__:
+            try:
+                if getattr(self, attr) != getattr(other, attr):
+                    return False
+            except AttributeError:
+                return False
+
+        return True

init_data_py-0.1.0/src/init_data_py/types/__init__.py

@@ -0,0 +1,4 @@
+from .chat import Chat
+from .user import User
+
+__all__ = ["Chat", "User"]

init_data_py-0.1.0/src/init_data_py/types/chat.py

@@ -0,0 +1,41 @@
+from typing import Literal, Optional
+
+from .object import Object
+
+
+class Chat(Object):
+    """
+    Represent a [WebAppChat](https://core.telegram.org/bots/webapps#webappchat).
+
+    Parameters:
+        id (int):
+            Unique identifier for this chat. This number may have more than 32 significant bits and some programming languages may have difficulty/silent defects in interpreting it. But it has at most 52 significant bits, so a signed 64-bit integer or double-precision float type are safe for storing this identifier.
+
+        type (`str`):
+            Type of chat, can be either "group", "supergroup" or "channel".
+
+        title (`str`):
+            Title of the chat.
+
+        username (`str`, optional):
+            Username of the chat.
+
+        photo_url (`str`, optional):
+            URL of the chat's photo. The photo can be in .jpeg or .svg formats. Only returned for Mini Apps launched from the attachment menu.
+    """
+
+    def __init__(
+        self,
+        *,
+        id: int,
+        type: Literal["group", "supergroup", "channel"],
+        title: str,
+        username: Optional[str] = None,
+        photo_url: Optional[str] = None,
+    ) -> None:
+        self.id = id
+        self.type = type
+        self.title = title
+        self.username = username
+        self.photo_url = photo_url
+        # NOTE: The order of the attributes is important.

init_data_py-0.1.0/src/init_data_py/types/object.py

@@ -0,0 +1,32 @@
+import json
+
+
+class Object:
+    def to_json(self):
+        """Returns a JSON serialized representation of the object."""
+        return json.dumps(self.to_dict(), separators=(",", ":"))
+
+    def to_dict(self):
+        """Returns a dictionary representation of the object."""
+        return {k: v for k, v in self.__dict__.items() if v is not None}
+
+    @classmethod
+    def from_json(cls, json_string):
+        """Create an object from JSON serialized string."""
+        return cls(**json.loads(json_string))
+
+    def __str__(self) -> str:
+        return json.dumps(self.to_dict(), indent=4)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+
+        for attr in self.__dict__:
+            try:
+                if getattr(self, attr) != getattr(other, attr):
+                    return False
+            except AttributeError:
+                return False
+
+        return True

init_data_py-0.1.0/src/init_data_py/types/user.py

@@ -0,0 +1,65 @@
+from typing import Literal, Optional
+
+from .object import Object
+
+
+class User(Object):
+    """Represent a [WebAppUser](https://core.telegram.org/bots/webapps#webappuser).
+
+    Parameters:
+        id (int):
+            A unique identifier for the user or bot. This number may have more than 32 significant bits and some programming languages may have difficulty/silent defects in interpreting it. It has at most 52 significant bits, so a 64-bit integer or a double-precision float type is safe for storing this identifier.
+
+        is_bot (boolean, optional):
+            True, if this user is a bot. Returns in the `receiver` field only.
+
+        first_name (`str`):
+            First name of the user or bot.
+
+        last_name (`str`, optional):
+            Last name of the user or bot.
+
+        username (`str`, optional):
+            Username of the user or bot.
+
+        language_code (`str`, optional):
+            IETF language tag of the user's language. Returns in user field only.
+
+        is_premium (True, optional):
+            True, if this user is a Telegram Premium user.
+
+        added_to_attachment_menu (True, optional):
+            True, if this user added the bot to the attachment menu.
+
+        allows_write_to_pm (True, optional):
+            True, if this user allowed the bot to message them.
+
+        photo_url (`str`, optional):
+            URL of the user's profile photo. The photo can be in .jpeg or .svg formats. Only returned for Mini Apps launched from the attachment menu.
+    """
+
+    def __init__(
+        self,
+        *,
+        id: int,
+        first_name: str,
+        last_name: Optional[str] = None,
+        username: Optional[str] = None,
+        language_code: Optional[str] = None,
+        is_premium: Optional[Literal[True]] = None,
+        is_bot: Optional[bool] = None,
+        added_to_attachment_menu: Optional[Literal[True]] = None,
+        allows_write_to_pm: Optional[Literal[True]] = None,
+        photo_url: Optional[str] = None,
+    ) -> None:
+        self.id = id
+        self.is_bot = is_bot
+        self.first_name = first_name
+        self.last_name = last_name
+        self.username = username
+        self.language_code = language_code
+        self.is_premium = is_premium
+        self.added_to_attachment_menu = added_to_attachment_menu
+        self.allows_write_to_pm = allows_write_to_pm
+        self.photo_url = photo_url
+        # NOTE: The order of the attributes is important.

init_data_py-0.1.0/tests/test_parse.py

@@ -0,0 +1,29 @@
+import unittest
+
+from init_data_py import InitData, errors, types
+
+
+class TestParseInitData(unittest.TestCase):
+    def setUp(self) -> None:
+        self.query_string = "query_id=AAF03wc0AgAAAHTfBzROOCVW&user=%7B%22id%22%3A5167898484%2C%22first_name%22%3A%22xin%22%2C%22last_name%22%3A%22%22%2C%22username%22%3A%22pvnimaxin%22%2C%22language_code%22%3A%22en%22%2C%22allows_write_to_pm%22%3Atrue%7D&auth_date=1722938610&hash=8654c8c617c143abf656f4f159be2539880a56f58c2d9be622f90c0346aa162b"
+        self.expected_init_data = InitData(
+            query_id="AAF03wc0AgAAAHTfBzROOCVW",
+            user=types.User(
+                id=5167898484,
+                first_name="xin",
+                last_name="",
+                username="pvnimaxin",
+                language_code="en",
+                allows_write_to_pm=True,
+            ),
+            auth_date=1722938610,
+            hash="8654c8c617c143abf656f4f159be2539880a56f58c2d9be622f90c0346aa162b",
+        )
+
+    def test_valid_query_string(self):
+        init_data = InitData.from_query_string(self.query_string)
+        self.assertEqual(init_data, self.expected_init_data)
+
+    def test_invalid_query_string(self):
+        with self.assertRaises(errors.UnexpectedFormatError):
+            InitData.from_query_string(self.query_string.upper())

init_data_py-0.1.0/tests/test_sign.py

@@ -0,0 +1,32 @@
+import unittest
+
+from init_data_py import InitData, types
+
+
+class TestSignInitData(unittest.TestCase):
+    def setUp(self) -> None:
+        self.init_data = InitData(
+            query_id="AAF03wc0AgAAAHTfBzROOCVW",
+            user=types.User(
+                id=5167898484,
+                first_name="xin",
+                last_name="",
+                username="pvnimaxin",
+                language_code="en",
+                allows_write_to_pm=True,
+            ),
+        )
+        self.bot_token = "7244657541:AAEgqk0HDC3WD5cdbnGMdd6L0TJ74FDp97Y"
+
+        self.expected_auth_date = 1722938610
+        self.expected_hash = (
+            "8654c8c617c143abf656f4f159be2539880a56f58c2d9be622f90c0346aa162b"
+        )
+
+    def test_sign(self):
+        self.init_data.sign(
+            bot_token=self.bot_token,
+            auth_date=self.expected_auth_date,
+        )
+        self.assertEqual(self.init_data.hash, self.expected_hash)
+        self.assertEqual(self.init_data.auth_date, self.expected_auth_date)

init_data_py-0.1.0/tests/test_validate.py

@@ -0,0 +1,46 @@
+import time
+import unittest
+
+from init_data_py import InitData, errors, types
+
+
+class TestValidateInitData(unittest.TestCase):
+    def setUp(self) -> None:
+        self.init_data = InitData(
+            query_id="AAF03wc0AgAAAHTfBzROOCVW",
+            user=types.User(
+                id=5167898484,
+                first_name="xin",
+                last_name="",
+                username="pvnimaxin",
+                language_code="en",
+                allows_write_to_pm=True,
+            ),
+            auth_date=1722938610,
+            hash="8654c8c617c143abf656f4f159be2539880a56f58c2d9be622f90c0346aa162b",
+        )
+        self.bot_token = "7244657541:AAEgqk0HDC3WD5cdbnGMdd6L0TJ74FDp97Y"
+
+    def test_valid_init_data(self):
+        self.assertTrue(self.init_data.validate(self.bot_token))
+
+    def test_invalid_init_data(self):
+        self.init_data.hash = "invalid hash"
+        with self.assertRaises(errors.SignInvalidError):
+            self.init_data.validate(self.bot_token)
+
+    def test_sign_missing_init_data(self):
+        self.init_data.hash = None
+        with self.assertRaises(errors.SignMissingError):
+            self.init_data.validate(self.bot_token)
+
+    def test_auth_date_missing_init_data(self):
+        self.init_data.auth_date = None
+        with self.assertRaises(errors.AuthDateMissingError):
+            self.init_data.validate(self.bot_token)
+
+    def test_expired_init_data(self):
+        lifetime = 10
+        self.init_data.auth_date = int(time.time()) - lifetime
+        with self.assertRaises(errors.ExpiredError):
+            self.init_data.validate(self.bot_token, lifetime)