fragment-api-py 1.0.0__tar.gz

fragment_api_py-1.0.0/FragmentAPI/__init__.py

@@ -0,0 +1,11 @@
+from .api import FragmentAPI
+from .models import FragmentSession, FragmentAPIError, FragmentErrorType
+
+__all__ = [
+    'FragmentAPI',
+    'FragmentSession',
+    'FragmentAPIError',
+    'FragmentErrorType'
+]
+
+__version__ = "1.0.0"

fragment_api_py-1.0.0/FragmentAPI/api.py

@@ -0,0 +1,295 @@
+from typing import Optional, Dict, Any
+from .models import FragmentSession, FragmentAPIError
+from .utils import make_request, handle_api_error
+from .exceptions import FragmentAuthError, FragmentOrderError, FragmentPaymentError
+import os
+
+class FragmentAPI:
+    def __init__(self, api_url: str = "https://fragment-api.net"):
+        if not isinstance(api_url, str) or not api_url.startswith(('http://', 'https://')):
+            api_url = f'https://{api_url}'
+        self.api_url = api_url.rstrip('/') + '/'
+        self.session = None
+        
+    def _make_request(self, method: str, endpoint: str, 
+                    params: Optional[dict] = None, 
+                    json_data: Optional[dict] = None) -> Dict[str, Any]:
+        return make_request(self.api_url, method, endpoint, params, json_data)
+        
+    def save_session(self, filename: str = "fragment_session.json"):
+        if self.session:
+            self.session.save_to_file(filename)
+
+    def load_session(self, filename: str = "fragment_session.json"):
+        self.session = FragmentSession.load_from_file(filename)
+        return self.session
+
+    def auth(self) -> 'FragmentAuth':
+        return FragmentAuth(self)
+        
+    def general(self) -> 'FragmentGeneral':
+        return FragmentGeneral(self)
+        
+    def premium(self) -> 'FragmentPremium':
+        return FragmentPremium(self)
+        
+    def stars(self) -> 'FragmentStars':
+        return FragmentStars(self)
+        
+    def ton(self) -> 'FragmentTON':
+        return FragmentTON(self)
+
+class FragmentAuth:
+    def __init__(self, api: FragmentAPI):
+        self.api = api
+        
+    def create_auth_key(self, fragment_cookies: str, seed: str) -> FragmentSession:
+        data = {
+            "fragment_cookies": fragment_cookies,
+            "seed": seed
+        }
+        
+        try:
+            response = self.api._make_request("POST", "/v2/auth", json_data=data)
+            
+            if not response.get("success"):
+                raise FragmentAuthError(
+                    FragmentErrorType.INVALID_FRAGMENT_COOKIES,
+                    "Failed to create auth key",
+                    400,
+                    response
+                )
+            
+            # Создаем и сохраняем сессию
+            self.api.session = FragmentSession(
+                auth_key=response["auth_key"],
+                fragment_cookies=fragment_cookies
+            )
+            
+            return self.api.session
+            
+        except FragmentAPIError as e:
+            if "Invalid fragment_cookies" in str(e):
+                e = FragmentAuthError(
+                    FragmentErrorType.INVALID_FRAGMENT_COOKIES,
+                    str(e),
+                    e.status_code,
+                    e.details
+                )
+            raise e
+
+class FragmentGeneral:
+    def __init__(self, api: FragmentAPI):
+        self.api = api
+    
+    def ping(self) -> dict:
+        return self.api._make_request("GET", "/v2/ping")
+    
+    def get_balance(self, auth_key: Optional[str] = None) -> dict:
+        """
+        Получить баланс кошелька
+        """
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+            wallet_type = self.api.session.wallet_type
+        else:
+            wallet_type = "v4r2"
+        
+        params = {
+            "auth_key": auth_key,
+            "wallet_type": wallet_type
+        }
+        
+        response = self.api._make_request("GET", "/v2/getBalance", params=params)
+        
+        # Обновляем баланс в сессии
+        if self.api.session and response.get("success"):
+            self.api.session.last_balance = response.get("balance")
+            
+        return response
+    
+    def get_user_info(self, username: str, auth_key: Optional[str] = None) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+        
+        params = {
+            "username": username,
+            "auth_key": auth_key
+        }
+        return self.api._make_request("GET", "/v2/getUserInfo", params=params)
+    
+    def get_orders(self, auth_key: Optional[str] = None, limit: int = 10, offset: int = 0) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+        
+        params = {
+            "auth_key": auth_key,
+            "limit": limit,
+            "offset": offset
+        }
+        return self.api._make_request("GET", "/v2/getOrders", params=params)
+
+class FragmentPremium:
+    def __init__(self, api: FragmentAPI):
+        self.api = api
+        
+    def create_premium_order(self, username: str, duration: int, 
+                           auth_key: Optional[str] = None,
+                           show_sender: bool = False) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+        
+        data = {
+            "username": username,
+            "duration": duration,
+            "auth_key": auth_key,
+            "show_sender": show_sender
+        }
+        return self.api._make_request("POST", "/v2/buyPremium/create", json_data=data)
+    
+    def pay_premium_order(self, order_uuid: str, cost: float,
+                         auth_key: Optional[str] = None,
+                         wallet_type: Optional[str] = None) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+            wallet_type = self.api.session.wallet_type
+        
+        data = {
+            "order_uuid": order_uuid,
+            "auth_key": auth_key,
+            "cost": cost,
+            "wallet_type": wallet_type or "v4r2"
+        }
+        return self.api._make_request("POST", "/v2/buyPremium/pay", json_data=data)
+    
+    def check_premium_order(self, uuid: str) -> dict:
+        params = {"uuid": uuid}
+        return self.api._make_request("GET", "/v2/buyPremium/check", params=params)
+
+class FragmentStars:
+    def __init__(self, api: FragmentAPI):
+        self.api = api
+        
+    def create_stars_order(self, username: str, amount: int, 
+                         auth_key: Optional[str] = None,
+                         show_sender: bool = True) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+        
+        data = {
+            "username": username,
+            "amount": amount,
+            "auth_key": auth_key,
+            "show_sender": show_sender
+        }
+        return self.api._make_request("POST", "/v2/buyStars/create", json_data=data)
+    
+    def pay_stars_order(self, order_uuid: str, cost: float,
+                       auth_key: Optional[str] = None,
+                       wallet_type: Optional[str] = None) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+            wallet_type = self.api.session.wallet_type
+        
+        data = {
+            "order_uuid": order_uuid,
+            "auth_key": auth_key,
+            "cost": cost,
+            "wallet_type": wallet_type or "v4r2"
+        }
+        return self.api._make_request("POST", "/v2/buyStars/pay", json_data=data)
+    
+    def check_stars_order(self, uuid: str) -> dict:
+        params = {"uuid": uuid}
+        return self.api._make_request("GET", "/v2/buyStars/check", params=params)
+
+class FragmentTON:
+    def __init__(self, api: FragmentAPI):
+        self.api = api
+        
+    def create_ton_order(self, username: str, amount: int,
+                       auth_key: Optional[str] = None,
+                       show_sender: bool = True) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+        
+        data = {
+            "username": username,
+            "amount": amount,
+            "auth_key": auth_key,
+            "show_sender": show_sender
+        }
+        return self.api._make_request("POST", "/v2/buyTon/create", json_data=data)
+    
+    def pay_ton_order(self, order_uuid: str, cost: float,
+                     auth_key: Optional[str] = None,
+                     wallet_type: Optional[str] = None) -> dict:
+        if auth_key is None:
+            if not self.api.session or not self.api.session.auth_key:
+                raise FragmentAuthError(
+                    FragmentErrorType.AUTH_KEY_NOT_FOUND,
+                    "No auth key provided and no active session",
+                    401
+                )
+            auth_key = self.api.session.auth_key
+            wallet_type = self.api.session.wallet_type
+        
+        data = {
+            "order_uuid": order_uuid,
+            "auth_key": auth_key,
+            "cost": cost,
+            "wallet_type": wallet_type or "v4r2"
+        }
+        return self.api._make_request("POST", "/v2/buyTon/pay", json_data=data)
+    
+    def check_ton_order(self, uuid: str) -> dict:
+        params = {"uuid": uuid}
+        return self.api._make_request("GET", "/v2/buyTon/check", params=params)

fragment_api_py-1.0.0/FragmentAPI/exceptions.py

@@ -0,0 +1,13 @@
+from .models import FragmentAPIError, FragmentErrorType
+
+class FragmentAuthError(FragmentAPIError):
+    pass
+
+class FragmentOrderError(FragmentAPIError):
+    pass
+
+class FragmentPaymentError(FragmentAPIError):
+    pass
+
+class FragmentNetworkError(FragmentAPIError):
+    pass

fragment_api_py-1.0.0/FragmentAPI/models.py

@@ -0,0 +1,59 @@
+from enum import Enum
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any
+import json
+import os
+
+class FragmentErrorType(Enum):
+    AUTH_KEY_EXPIRED = "AUTH_KEY_EXPIRED"
+    INVALID_WALLET_TYPE = "INVALID_WALLET_TYPE"
+    INVALID_ORDER_PRODUCT_TYPE = "INVALID_ORDER_PRODUCT_TYPE"
+    ORDER_ALREADY_PROCESSED = "ORDER_ALREADY_PROCESSED"
+    ORDER_ALREADY_PROCESSING = "ORDER_ALREADY_PROCESSING"
+    INVALID_ORDER_COST = "INVALID_ORDER_COST"
+    INVALID_PREMIUM_DURATION = "INVALID_PREMIUM_DURATION"
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE"
+    ORDER_EXPIRED = "ORDER_EXPIRED"
+    INVALID_USERNAME_FORMAT = "INVALID_USERNAME_FORMAT"
+    USER_NOT_FOUND = "USER_NOT_FOUND"
+    AUTH_KEY_NOT_FOUND = "AUTH_KEY_NOT_FOUND"
+    ORDER_NOT_FOUND = "ORDER_NOT_FOUND"
+    MISSING_FRAGMENT_COOKIES = "MISSING_FRAGMENT_COOKIES"
+    MISSING_SEED = "MISSING_SEED"
+    INVALID_SEED_FORMAT = "INVALID_SEED_FORMAT"
+    INVALID_FRAGMENT_COOKIES = "INVALID_FRAGMENT_COOKIES"
+    USER_ALREADY_HAS_PREMIUM = "USER_ALREADY_HAS_PREMIUM"
+    SEARCH_ERROR = "SEARCH_ERROR"
+    BALANCE_CHECK_ERROR = "BALANCE_CHECK_ERROR"
+    TRANSFER_FAILED = "TRANSFER_FAILED"
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+
+@dataclass
+class FragmentAPIError(Exception):
+    error_type: FragmentErrorType
+    message: str
+    status_code: int
+    details: Optional[Dict[str, Any]] = None
+
+    def __str__(self):
+        return f"[{self.status_code}] {self.error_type.value}: {self.message}"
+
+@dataclass
+class FragmentSession:
+    auth_key: str
+    fragment_cookies: str
+    wallet_type: str = "v4r2"
+    last_balance: Optional[float] = None
+
+    def save_to_file(self, filename: str = "fragment_session.json"):
+        with open(filename, 'w') as f:
+            json.dump(asdict(self), f)
+
+    @classmethod
+    def load_from_file(cls, filename: str = "fragment_session.json"):
+        if not os.path.exists(filename):
+            return None
+        
+        with open(filename, 'r') as f:
+            data = json.load(f)
+            return cls(**data)

fragment_api_py-1.0.0/FragmentAPI/utils.py

@@ -0,0 +1,55 @@
+from urllib.parse import urljoin
+from typing import Dict, Optional, Any
+import requests
+from .models import FragmentAPIError, FragmentErrorType
+
+def make_request(api_url: str, method: str, endpoint: str, 
+               params: Optional[dict] = None, 
+               json_data: Optional[dict] = None) -> Dict[str, Any]:
+    url = urljoin(api_url, endpoint.lstrip('/'))
+    
+    try:
+        response = requests.request(
+            method, 
+            url, 
+            params=params, 
+            json=json_data,
+            timeout=30
+        )
+        
+        if not response.ok:
+            handle_api_error(response)
+            
+        return response.json()
+        
+    except requests.exceptions.RequestException as e:
+        raise FragmentAPIError(
+            FragmentErrorType.INTERNAL_SERVER_ERROR,
+            f"Network error: {str(e)}",
+            500
+        ) from e
+
+def handle_api_error(response: requests.Response):
+    try:
+        error_data = response.json()
+        error_code = error_data.get("error_code")
+        message = error_data.get("message", "Unknown error")
+        
+        try:
+            error_type = FragmentErrorType(error_code)
+        except ValueError:
+            error_type = FragmentErrorType.INTERNAL_SERVER_ERROR
+        
+        raise FragmentAPIError(
+            error_type,
+            message,
+            response.status_code,
+            error_data
+        )
+        
+    except ValueError:
+        raise FragmentAPIError(
+            FragmentErrorType.INTERNAL_SERVER_ERROR,
+            f"HTTP {response.status_code}: {response.text}",
+            response.status_code
+        )

fragment_api_py-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: fragment-api-py
+Version: 1.0.0
+Summary: Python client for Fragment API (fragment.com)
+Home-page: https://github.com/S1qwy/fragment-api-py
+Author: S1qwy
+Author-email: S1qwy <amirhansuper75@gmail.com>
+Project-URL: Homepage, https://github.com/S1qwy/fragment-api-py
+Project-URL: Bug-Reports, https://github.com/S1qwy/fragment-api-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: dataclasses>=0.6; python_version < "3.7"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Fragment API Python Client
+
+Python client for [Fragment API](https://fragment.com) - Telegram Stars, Premium and TON service.
+
+## Features
+
+- Full Fragment API support
+- Session management (auto-save auth_key)
+- Detailed error handling
+- Support for all operations:
+  - Telegram Stars
+  - Telegram Premium
+  - TON transfers
+- Automatic session save/load
+
+## Installation
+
+```bash
+pip install fragment-api-py
+```
+
+## Quick Start
+
+```python
+from fragment_api import FragmentAPI, FragmentAuth
+
+# Initialize API
+api = FragmentAPI("https://fragment-api.net")
+
+# Authenticate
+auth = FragmentAuth(api)
+session = auth.create_auth_key("your_cookies", "your_seed")
+
+# Get balance
+print(api.general().get_balance())
+```
+
+[View full documentation on GitHub](https://github.com/yourusername/fragment-api-py)

fragment_api_py-1.0.0/PYPI_README.md

@@ -0,0 +1,38 @@
+# Fragment API Python Client
+
+Python client for [Fragment API](https://fragment.com) - Telegram Stars, Premium and TON service.
+
+## Features
+
+- Full Fragment API support
+- Session management (auto-save auth_key)
+- Detailed error handling
+- Support for all operations:
+  - Telegram Stars
+  - Telegram Premium
+  - TON transfers
+- Automatic session save/load
+
+## Installation
+
+```bash
+pip install fragment-api-py
+```
+
+## Quick Start
+
+```python
+from fragment_api import FragmentAPI, FragmentAuth
+
+# Initialize API
+api = FragmentAPI("https://fragment-api.net")
+
+# Authenticate
+auth = FragmentAuth(api)
+session = auth.create_auth_key("your_cookies", "your_seed")
+
+# Get balance
+print(api.general().get_balance())
+```
+
+[View full documentation on GitHub](https://github.com/yourusername/fragment-api-py)

fragment_api_py-1.0.0/README.md

@@ -0,0 +1,75 @@
+# Fragment API Python Client
+
+[![PyPI version](https://badge.fury.io/py/fragment-api-py.svg)](https://badge.fury.io/py/fragment-api-py)
+[![Python versions](https://img.shields.io/pypi/pyversions/fragment-api-py.svg)](https://pypi.org/project/fragment-api-py/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Неофициальный Python клиент для работы с [Fragment API](https://fragment-api.net) - сервисом покупки Telegram Stars, Premium и TON.
+
+## Возможности
+
+- Полная поддержка всех методов Fragment API
+- Удобное управление сессиями (автосохранение auth_key)
+- Подробная обработка ошибок с понятными сообщениями
+- Поддержка всех типов операций:
+  - Telegram Stars
+  - Telegram Premium
+  - TON переводы
+- Автоматическая загрузка и сохранение сессий
+
+## Установка
+
+```bash
+pip install fragment-api-py
+```
+
+## Быстрый старт
+
+```python
+from fragment_api import FragmentAPI, FragmentAuth
+
+# Инициализация API
+api = FragmentAPI("https://fragment-api.net")
+
+# Аутентификация
+auth = FragmentAuth(api)
+session = auth.create_auth_key("your_fragment_cookies", "your_seed_phrase")
+
+# Работа с API
+general = api.general()
+print(general.get_balance())
+```
+
+## Примеры использования
+
+### Покупка Telegram Premium
+
+```python
+premium = api.premium()
+order = premium.create_premium_order("@username", 12)  # 12 месяцев
+payment = premium.pay_premium_order(order["order_id"], order["cost"])
+```
+
+### Покупка Telegram Stars
+
+```python
+stars = api.stars()
+order = stars.create_stars_order("@username", 100)  # 100 Stars
+payment = stars.pay_stars_order(order["order_id"], order["cost"])
+```
+
+### Перевод TON
+
+```python
+ton = api.ton()
+order = ton.create_ton_order("@username", 5)  # 5 TON
+payment = ton.pay_ton_order(order["order_id"], order["cost"])
+```
+
+## Документация
+
+Полная документация доступна на [GitHub Wiki](https://github.com/yourusername/fragment-api-py/wiki).
+
+## Лицензия
+
+MIT License. Смотрите файл [LICENSE](LICENSE).

fragment_api_py-1.0.0/fragment_api_py.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: fragment-api-py
+Version: 1.0.0
+Summary: Python client for Fragment API (fragment.com)
+Home-page: https://github.com/S1qwy/fragment-api-py
+Author: S1qwy
+Author-email: S1qwy <amirhansuper75@gmail.com>
+Project-URL: Homepage, https://github.com/S1qwy/fragment-api-py
+Project-URL: Bug-Reports, https://github.com/S1qwy/fragment-api-py/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: dataclasses>=0.6; python_version < "3.7"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Fragment API Python Client
+
+Python client for [Fragment API](https://fragment.com) - Telegram Stars, Premium and TON service.
+
+## Features
+
+- Full Fragment API support
+- Session management (auto-save auth_key)
+- Detailed error handling
+- Support for all operations:
+  - Telegram Stars
+  - Telegram Premium
+  - TON transfers
+- Automatic session save/load
+
+## Installation
+
+```bash
+pip install fragment-api-py
+```
+
+## Quick Start
+
+```python
+from fragment_api import FragmentAPI, FragmentAuth
+
+# Initialize API
+api = FragmentAPI("https://fragment-api.net")
+
+# Authenticate
+auth = FragmentAuth(api)
+session = auth.create_auth_key("your_cookies", "your_seed")
+
+# Get balance
+print(api.general().get_balance())
+```
+
+[View full documentation on GitHub](https://github.com/yourusername/fragment-api-py)

fragment_api_py-1.0.0/fragment_api_py.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+PYPI_README.md
+README.md
+pyproject.toml
+setup.py
+./FragmentAPI/__init__.py
+./FragmentAPI/api.py
+./FragmentAPI/exceptions.py
+./FragmentAPI/models.py
+./FragmentAPI/utils.py
+fragment_api_py.egg-info/PKG-INFO
+fragment_api_py.egg-info/SOURCES.txt
+fragment_api_py.egg-info/dependency_links.txt
+fragment_api_py.egg-info/requires.txt
+fragment_api_py.egg-info/top_level.txt

fragment_api_py-1.0.0/fragment_api_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fragment_api_py-1.0.0/fragment_api_py.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.25.1
+
+[:python_version < "3.7"]
+dataclasses>=0.6

fragment_api_py-1.0.0/fragment_api_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+FragmentAPI

fragment_api_py-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fragment-api-py"
+version = "1.0.0"
+authors = [
+    {name = "S1qwy", email = "amirhansuper75@gmail.com"},
+]
+description = "Python client for Fragment API (fragment.com)"
+readme = "PYPI_README.md"
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests>=2.25.1",
+    "dataclasses>=0.6;python_version<'3.7'",
+]
+
+[project.urls]
+Homepage = "https://github.com/S1qwy/fragment-api-py"
+Bug-Reports = "https://github.com/S1qwy/fragment-api-py/issues"

fragment_api_py-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fragment_api_py-1.0.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+with open("PYPI_README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="fragment-api-py",
+    version="1.0.0",
+    author="S1qwy",
+    author_email="amirhansuper75@gmail.com",
+    description="Python client for Fragment API (fragment.com)",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/S1qwy/fragment-api-py",
+    packages=find_packages(include=['FragmentAPI', 'FragmentAPI.*']),
+    package_dir={'': '.'},
+    install_requires=[
+        "requests>=2.25.1",
+        "dataclasses>=0.6;python_version<'3.7'",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    keywords="fragment, telegram, ton, stars, premium, api",
+    project_urls={
+        "Bug Reports": "https://github.com/S1qwy/fragment-api-py/issues",
+        "Source": "https://github.com/S1qwy/fragment-api-py",
+    },
+)