fasthttp-client 0.1.0__py3-none-any.whl

fasthttp/__init__.py

@@ -0,0 +1,3 @@
+from fasthttp.app import FastHTTP
+
+__all__ = ("FastHTTP",)

fasthttp/app.py

@@ -0,0 +1,237 @@
+import asyncio
+import time
+from collections.abc import Callable
+from typing import Annotated, Literal
+
+import aiohttp
+from annotated_doc import Doc
+
+from fasthttp.client import HTTPClient
+from fasthttp.logging import setup_logger
+from fasthttp.routing import Route
+from fasthttp.types import RequestsOptinal
+
+
+class FastHTTP:
+    """
+    FastHTTP application entry point.
+
+    FastHTTP is a lightweight asynchronous HTTP client framework
+    built on top of aiohttp. It provides a clean decorator-based API
+    for defining HTTP requests and handling responses, similar to
+    web frameworks like FastAPI, but for outgoing requests.
+
+    The application manages:
+    - Request routing via decorators (GET, POST, PUT, PATCH, DELETE)
+    - Per-method default request configuration
+    - Async request execution
+    - Structured and colorized logging
+    - Unified Response handling
+
+    Example:
+    ```python
+        from fasthttp import FastHTTP
+        from fasthttp.response import Response
+
+        app = FastHTTP()
+
+        @app.get(url="https://httpbin.org/get")
+        async def get_data(resp: Response):
+            return resp.json()
+
+        if __name__ == "__main__":
+            app.run()
+    ```
+
+    """
+    def __init__(
+        self,
+        *,
+        debug: Annotated[
+            bool,
+            Doc(
+                """
+                Enable debug mode.
+
+                When enabled, FastHTTP will print datailed
+                tracebacks and requests/response logs.
+                """)] = False,
+
+        get_request: Annotated[
+            RequestsOptinal,
+            Doc(
+                """
+                Default configuration for GET requests.
+
+                Allows setting headers, timeout and other request-level
+                options that will be applied to all GET requests
+                """
+            )] | None = None,
+        post_request: Annotated[
+            RequestsOptinal,
+            Doc(
+                """
+                Default configuration for POST requests.
+
+                Used to define headers, timeout and other options
+
+                applied to all POST requests.
+                """
+            )] | None = None,
+        put_request: Annotated[
+            RequestsOptinal,
+            Doc(
+                """
+                Default configuration for PUT requests.
+
+                Controls request headers, timeout and other
+
+                options for PUT requests.
+                """
+            )] | None = None,
+        patch_request: Annotated[
+            RequestsOptinal,
+            Doc(
+                """
+# Create the app
+               Default configuration for PATCH requests.
+
+               Used to configure headers, timeout and
+               other PATCH-specific options.
+                """
+            )] | None = None,
+        delete_request: Annotated[
+            RequestsOptinal,
+            Doc(
+                """
+                Default configuration for DELETE requests.
+
+                Allows defining haders, timeout,
+                and other options for DELETE requests.
+                """
+            )] | None = None,
+    ) -> None:
+        self.logger = setup_logger(debug=debug)
+        self.routes: list[Route] = []
+
+        self.request_configs = {
+            "GET": get_request or {},
+            "POST": post_request or {},
+            "PUT": put_request or {},
+            "PATCH": patch_request or {},
+            "DELETE": delete_request or {},
+        }
+
+        self.client = HTTPClient(self.request_configs, self.logger)
+
+    def _add_route(
+        self,
+        *,
+        method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"],
+        url: str,
+        params=None,
+        json=None,
+        data=None,
+    ):
+        def decorator(func: Callable):
+            self.routes.append(
+                Route(
+                    method=method,
+                    url=url,
+                    handler=func,
+                    params=params,
+                    json=json,
+                    data=data,
+                )
+            )
+            self.logger.debug("Registered route: %s %s", method, url)
+            return func
+        return decorator
+
+    def get(self, *, url: str, params=None):
+        return self._add_route(
+            method="GET",
+            url=url,
+            params=params,
+        )
+
+    def post(self, *, url: str, json=None, data=None):
+        return self._add_route(
+            method="POST",
+            url=url,
+            json=json,
+            data=data,
+        )
+
+    def put(self, *, url: str, json=None, data=None):
+        return self._add_route(
+            method="PUT",
+            url=url,
+            json=json,
+            data=data,
+        )
+
+    def patch(self, *, url: str, json=None, data=None):
+        return self._add_route(
+            method="PATCH",
+            url=url,
+            json=json,
+            data=data,
+        )
+
+    def delete(self, *, url: str, json=None, data=None):
+        return self._add_route(
+            method="DELETE",
+            url=url,
+            json=json,
+            data=data,
+        )
+
+    async def _run(self) -> None:
+        total = len(self.routes)
+
+        self.logger.info("Sending %d requests", total)
+        start_all = time.perf_counter()
+
+        async with aiohttp.ClientSession() as session:
+            for route in self.routes:
+                start = time.perf_counter()
+
+                result = await self.client.send(session, route)
+                elapsed = (time.perf_counter() - start) * 1000
+
+                if result and isinstance(result.status, int):
+                    self.logger.info(
+                        "✔️ %-6s %-30s %s %6.2fms",
+                        route.method,
+                        route.url,
+                        result.status,
+                        elapsed,
+                    )
+
+                    handler_result = getattr(result, "_handler_result", None)
+                    if handler_result is not None:
+                        self.logger.debug("[RESULT] %s", handler_result)
+                    elif result.text:
+                        self.logger.debug("[RESULT] %s", result.text)
+                else:
+                    self.logger.error(
+                        "✖️ %-6s %-30s ERR %6.2fms",
+                        route.method,
+                        route.url,
+                        elapsed,
+                    )
+
+                await asyncio.sleep(0.5)
+
+        total_time = time.perf_counter() - start_all
+        self.logger.info("Done in %.2fs", total_time)
+
+    def run(self) -> None:
+        self.logger.info("FastHTTP started")
+        try:
+            asyncio.run(self._run())
+        except aiohttp.ClientConnectionError as e:
+            self.logger.error("Connection error: %s", e)
+        except KeyboardInterrupt:
+            self.logger.warning("Interrupted by user")

fasthttp/client.py

@@ -0,0 +1,90 @@
+import asyncio
+import time
+from typing import Optional
+
+import aiohttp
+
+from fasthttp.response import Response
+from fasthttp.routing import Route
+
+
+class HTTPClient:
+    """
+    HTTP client responsible for sending HTTP requests.
+
+    This class manages low-level request execution using aiohttp,
+    applies per-method request configuration (headers, timeout, redirects),
+    logs request lifecycle events, and returns normalized Response objects.
+    """
+    def __init__(self, request_configs: dict, logger) -> None:
+        self.request_configs = request_configs
+        self.logger = logger
+
+    async def send(self, session: aiohttp.ClientSession, route: Route) -> Optional[Response]:
+        """
+        Send a single HTTP request based on a Route definition.
+
+        This method:
+        - Applies request configuration based on HTTP method
+        - Sends the request using an existing aiohttp ClientSession
+        - Measures request execution time
+        - Logs outgoing requests and incoming responses
+        - Executes the route handler with the Response object
+
+        Returns:
+        - Response instance if the request was successful
+        - Modified Response if the handler returned a string or Response
+        - None if a connection or timeout error occurred
+        """
+        config = self.request_configs.get(route.method, {})
+
+        self.logger.debug(
+            "→ %s %s | headers=%s",
+            route.method,
+            route.url,
+            config.get("headers"),
+        )
+
+        start = time.perf_counter()
+
+        try:
+            async with session.request(
+                method=route.method,
+                url=route.url,
+                headers=config.get("headers"),
+                params=route.params,
+                json=route.json,
+                data=route.data,
+                timeout=config.get("timeout"),
+            ) as resp:
+                elapsed = (time.perf_counter() - start) * 1000
+                text = await resp.text()
+
+                self.logger.info(
+                    "← %s %s [%s] %.2fms",
+                    route.method,
+                    route.url,
+                    resp.status,
+                    elapsed,
+                )
+
+                response = Response(
+                    status=resp.status,
+                    text=text,
+                    headers=dict(resp.headers),
+                )
+
+                handler_result = await route.handler(response)
+                if isinstance(handler_result, Response):
+                    return handler_result
+                if isinstance(handler_result, str):
+                    response.text = handler_result
+
+                response._handler_result = handler_result
+                return response
+
+        except (aiohttp.ClientConnectorError, asyncio.TimeoutError):
+            return None
+
+        except Exception:
+            return None

fasthttp/logging.py

@@ -0,0 +1,116 @@
+import logging
+import sys
+from datetime import datetime, timezone
+from typing import ClassVar
+
+LOGGER_NAME = "fasthttp"
+
+
+class ColorFormatter(logging.Formatter):
+    """
+    Custom logging formatter with colored output.
+
+    Adds ANSI colors, icons and improved formatting
+    to log records based on their log level.
+
+    Designed for CLI-friendly and readable logs.
+    """
+    RESET = "\033[0m"
+
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+
+    GRAY = "\033[90m"
+    CYAN = "\033[36m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    RED = "\033[31m"
+    RED_BG = "\033[41m"
+    PURPLE = "\033[35m"
+
+    LEVEL_COLORS: ClassVar[dict[int, str]] = {
+        logging.DEBUG: YELLOW,
+        logging.INFO: GREEN,
+        logging.WARNING: BLUE,
+        logging.ERROR: RED,
+        logging.CRITICAL: RED_BG,
+    }
+
+    LEVEL_ICONS: ClassVar[dict[int, str]] = {
+        logging.DEBUG: "🐛",
+        logging.INFO: "✔",
+        logging.WARNING: "⚠",
+        logging.ERROR: "✖",
+        logging.CRITICAL: "💀",
+    }
+
+    def formatTime(self, record, datefmt=None) -> str: # noqa  N802
+        """
+        Format the timestamp of a log record.
+
+        Converts the record creation time to UTC
+        and formats it with millisecond precision.
+        """
+        t = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        return f"{self.GRAY}{t.strftime('%H:%M:%S.%f')[:-3]}{self.RESET}"
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Format a log record with colors and icons.
+
+        Applies:
+        - Colored log level names
+        - Colored logger names
+        - Emoji icons based on log level
+        - Special formatting for result messages
+
+        Returns the fully formatted log string.
+        """
+        color = self.LEVEL_COLORS.get(record.levelno, self.RESET)
+        icon = self.LEVEL_ICONS.get(record.levelno, "")
+
+        record.levelname = (
+            f"{color}{self.BOLD}{record.levelname:<8}{self.RESET}"
+        )
+        record.name = f"{self.CYAN}{record.name}{self.RESET}"
+
+        msg = str(record.msg)
+
+        if msg.startswith("[RESULT]"):
+            record.msg = f"{self.PURPLE}↳ {msg[8:].strip()}{self.RESET}"
+        else:
+            record.msg = f"{color}{icon} {msg}{self.RESET}"
+
+        return super().format(record)
+
+
+def setup_logger(*, debug: bool = False) -> logging.Logger:
+    """
+    Configure and return the application logger.
+
+    Creates a logger with colored output and
+    configurable verbosity based on debug mode.
+
+    If the logger is already configured,
+    returns the existing instance.
+    """
+    logger = logging.getLogger(LOGGER_NAME)
+
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.DEBUG)
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(logging.DEBUG if debug else logging.INFO)
+
+    formatter = ColorFormatter(
+        "%(asctime)s │ %(levelname)s │ %(name)s │ %(message)s"
+    )
+
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.propagate = False
+
+    return logger

fasthttp/response.py

@@ -0,0 +1,71 @@
+import json
+from typing import Annotated
+
+from annotated_doc import Doc
+
+from fasthttp.types import JSONResponse
+
+
+class Response:
+    """
+    HTTP response object.
+
+    Represents an HTTP response returned by the server,
+    including status code, raw body text, and response headers.
+
+    Used by FastHTTP to pass response data to route handlers.
+    """
+    def __init__(
+        self,
+        status: Annotated[
+            int,
+            Doc(
+                """
+                HTTP status code of the response.
+
+                Indicates the result of the HTTP request
+                (e.g. 200 for success, 404 for not found,
+                500 for server error).
+                """
+            )],
+        text: Annotated[
+            str,
+            Doc(
+                """
+                Raw response body as a string.
+
+                Contains the response payload exactly as
+                returned by the server.
+                """
+            )],
+        headers: Annotated[
+            dict,
+            Doc(
+                """
+                HTTP response headers.
+
+                A mapping of header names to their values
+                returned by the server.
+                """
+            )]
+    ) -> None:
+        self.status = status
+        self.text = text
+        self.headers = headers
+        self._handler_result = None
+
+    def json(self) -> JSONResponse.Value:
+        """
+        Parse the response body as JSON.
+
+        Returns the parsed JSON object. Raises a
+        ValueError if the response body is not valid JSON.
+        """
+        return json.loads(self.text)
+
+    def __repr__(self) -> str:
+        """
+        Return a debug-friendly string representation
+of the response.
+        """
+        return f"<Response [{self.status}]>"

fasthttp/routing.py

@@ -0,0 +1,95 @@
+from collections.abc import Callable
+from typing import Annotated, Any, Literal
+
+from annotated_doc import Doc
+
+
+class Route:
+    """
+    Definition of an HTTP request route.
+
+    A Route binds together an HTTP method, a target URL,
+    optional request data, and a response handler function.
+
+    It is used by FastHTTP to send requests and process
+    responses in a structured and predictable way.
+    """
+    def __init__(
+        self,
+        *,
+        method: Annotated[
+            Literal["GET", "POST", "PUT", "PATCH", "DELETE"],
+            Doc(
+                """
+                HTTP method for the request.
+
+                Determines how the request will be sent to the server.
+
+                Suppoeted methods are:
+                GET, POST, PUT, PATCH, DELETE.
+                """
+            )],
+        url: Annotated[
+            str,
+            Doc(
+                """
+                Target URL for the HTTP request.
+
+                Must be a full URL including scheme, host and path
+                Example:
+                https://api.google.com/
+                """
+            )],
+        handler: Annotated[
+            Callable,
+            Doc(
+                """
+                Response handler function.
+
+                This asyncfunction will be called with a Response object
+                and can return:
+                - str
+                - Response
+                - None
+                """
+            )],
+        params: Annotated[
+            dict | None,
+            Doc(
+                """
+                Query parameters to be sent with the request.
+
+                The dictionary will be encoded into the URL query string
+                and appended to the request URL.
+                """
+            )] = None,
+        json: Annotated[
+            dict | None,
+            Doc(
+                """
+                JSON body to be sent with the request.
+
+                The data will be serialized to JSON and sent with the
+
+                application/json Content-Type header.
+                """
+            )] = None,
+        data: Annotated[
+            Any | None,
+            Doc(
+                """
+
+                Raw request body or form data.
+
+                Can be used to send form-encoded data, plain text,
+
+                binary payloads or any custom request body.
+                """
+            )] = None,
+    ) -> None:
+        self.method = method
+        self.url = url
+        self.handler = handler
+        self.params = params
+        self.json = json
+        self.data = data

fasthttp/types.py

@@ -0,0 +1,55 @@
+from typing import Annotated, TypeAlias, TypedDict
+
+from annotated_doc import Doc
+
+
+class JSONResponse:
+    """
+    JSON response type definitions.
+
+    This class groups type aliases that describe valid JSON data
+    structures returned by HTTP responses.
+
+    It is used for type-safe annotations of parsed JSON payloads,
+    including primitive values, lists, and nested objects.
+    """
+    Primutive: TypeAlias = str | int | float | bool | None
+    Value: TypeAlias = Primutive | list["Value"] | dict[str, "Value"]
+
+
+class RequestsOptinal(TypedDict, total=False):
+    """
+    Optional request configuration.
+
+    Defines optional parameters that control how HTTP requests
+    are sent, such as headers, timeouts, and redirect behavior.
+
+    All fields are optional and may be omitted if not needed.
+    """
+    headers: Annotated[
+        dict[str, str],
+        Doc(
+            """
+            HTTP headers to be sent with the request.
+            A dictionary of header names and values that will be included
+            in every request of this method type.
+            """
+        )]
+    timeout: Annotated[
+        float,
+        Doc(
+            """
+            Request timeout in seconds.
+            Specifies the maximum amount of time to wait for the server
+            to respond before the request is cancelled.
+            """
+        )]
+    allow_redirects: Annotated[
+        bool,
+        Doc(
+            """
+            Enable or disable HTTP redirects.
+            When set to True, the client will automatically follow
+            redirect responses (3xx status codes).
+            """
+        )]

fasthttp_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: fasthttp-client
+Version: 0.1.0
+Summary: Fast and simple HTTP client library with async support and beautiful logging
+Project-URL: Homepage, https://github.com/ndugram/fasthttp
+Project-URL: Documentation, https://github.com/ndugram/fasthttp
+Project-URL: Repository, https://github.com/ndugram/fasthttp
+Project-URL: Issues, https://github.com/ndugram/fasthttp/issues
+Author-email: White NEFOR <n7for8572@gmail.com>
+Maintainer-email: White NEFOR <n7for8572@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: aiohttp,async,client,fast,http,http-client,python,requests
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: annotated-doc>=0.0.4
+Provides-Extra: dev
+Requires-Dist: mypy>=1.13.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.14.14; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# FastHTTP Client
+
+<div align="center">
+
+![PyPI version](https://badge.fury.io/py/fasthttp.svg)
+![Python Version](https://img.shields.io/pypi/pyversions/fasthttp.svg)
+![License](https://img.shields.io/pypi/l/fasthttp.svg)
+
+**🚀 Simple & Fast HTTP Client for Python**
+
+[Documentation](docs/index.md) • [Quick Start](#quick-start) • [Examples](docs/examples.md)
+
+</div>
+
+## ⚡ Features
+
+- **Simple API** - Minimal boilerplate with decorators
+- **Beautiful Logging** - Colorful request/response logs with timing
+- **Async Support** - Built on aiohttp for high performance
+- **Type Safe** - Full type annotations
+- **All HTTP Methods** - GET, POST, PUT, PATCH, DELETE
+
+## 🚀 Quick Start
+
+### Installation
+```bash
+pip install fasthttp-client
+```
+
+### Basic Usage
+```python
+from fasthttp import FastHTTP
+from fasthttp.response import Response
+
+app = FastHTTP()
+
+
+@app.get(url="https://httpbin.org/get")
+async def get_data(resp: Response):
+    return resp.json()
+
+
+if __name__ == "__main__":
+    app.run()
+```
+
+**Output:**
+```
+16:09:18.955 │ INFO     │ fasthttp │ ✔ FastHTTP started
+16:09:19.519 │ INFO     │ fasthttp │ ✔ ← GET https://httpbin.org/get [200] 458.26ms
+16:09:20.037 │ INFO     │ fasthttp │ ✔ Done in 1.08s
+```
+
+### With Configuration
+```python
+from fasthttp import FastHTTP
+from fasthttp.response import Response
+
+app = FastHTTP(
+    debug=True,
+    get_request={
+        "headers": {"User-Agent": "MyApp/1.0"},
+        "timeout": 10,
+    },
+)
+
+@app.get(url="https://api.github.com/users/octocat")
+async def get_user(resp: Response):
+    return resp.json()
+
+if __name__ == "__main__":
+    app.run()
+```
+
+## 🔧 All HTTP Methods
+
+```python
+from fasthttp import FastHTTP
+from fasthttp.response import Response
+
+app = FastHTTP()
+
+# GET
+@app.get(url="https://jsonplaceholder.typicode.com/posts/1")
+async def get_post(resp: Response):
+    return resp.json()
+
+# POST
+@app.post(url="https://httpbin.org/post", json={"name": "John"})
+async def create_user(resp: Response):
+    return f"Created: {resp.status}"
+
+# PUT
+@app.put(url="https://httpbin.org/put", json={"name": "Jane"})
+async def update_user(resp: Response):
+    return resp.json()
+
+# DELETE
+@app.delete(url="https://httpbin.org/delete")
+async def delete_user(resp: Response):
+    return f"Delete: {resp.status}"
+```
+
+## 📚 Documentation
+
+- **[📖 Documentation](docs/index.md)** - Complete guide
+- **[⚡ Quick Start](docs/quick-start.md)** - Get started in 2 minutes  
+- **[🔧 API Reference](docs/api-reference.md)** - Full API documentation
+- **[💡 Examples](docs/examples.md)** - Real-world examples
+- **[⚙️ Configuration](docs/configuration.md)** - Advanced settings
+
+## 🛠️ Development
+
+```bash
+git clone https://github.com/ndugram/fasthttp.git
+cd fasthttp
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Code quality
+ruff format .
+ruff check .
+```
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🤝 Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines.
+
+## 🔒 Security
+
+See [SECURITY.md](SECURITY.md) for security policies.
+
+---
+
+**Made with ❤️ by the NDUgram Team**

fasthttp_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fasthttp/__init__.py,sha256=1Wvp_6J6cxKkwSajw8RTNCexOOp0FcGxW6yf0KJE90s,59
+fasthttp/app.py,sha256=hiD78ceoEqoAyybRZA6lYMpcRrb2F116Q4z_A4uDKSE,6900
+fasthttp/client.py,sha256=4-g_FxujNRR4cUZ4WhB7Wgadz0_RYl_QZCeoT4EIg00,2900
+fasthttp/logging.py,sha256=SUNSSXIR61JDNzduMtM1BIIbDDg1NZUIwfygAlqq-uY,3087
+fasthttp/response.py,sha256=7fueAqAkJoaDDRbW0zRgHBRrxuKfM_TBBAYG8PJ-xrs,1789
+fasthttp/routing.py,sha256=oUGg3Ld2BgllRYcaURdgfaPz9qHZDlYQBeumZnJUBn4,2569
+fasthttp/types.py,sha256=G6przuFoKv2K74kguWk2cznIx2nMC91VyFcvgL3cClk,1623
+fasthttp_client-0.1.0.dist-info/METADATA,sha256=AzchcoK_pL9TVU-Q73RyHyHtyC_yX0HaJqByEQ6cM_w,4805
+fasthttp_client-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fasthttp_client-0.1.0.dist-info/licenses/LICENSE,sha256=Vz_vj5RNgcljwWVnBRK23jfM9H9I-Pwn0R7SDVxrOiQ,1086
+fasthttp_client-0.1.0.dist-info/RECORD,,

fasthttp_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fasthttp_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 安𝐍ᴇғᴏʀ | ᵈᵉᵛ
+
+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.