seb-auth 0.1.0__py3-none-any.whl

seb_auth/__init__.py

@@ -0,0 +1,46 @@
+"""
+seb-auth: Official Python SDK for SebAuth.
+
+Example:
+    from seb_auth import SebAuth
+
+    seb = SebAuth()  # reads SEBAUTH_API_KEY from env
+    seb.email.send(
+        to="user@example.com",
+        subject="Hello",
+        body="Hello from SebAuth!",
+    )
+"""
+
+from .client import SebAuth
+from .exceptions import (
+    SebAuthError,
+    AuthenticationError,
+    APIError,
+    BadRequestError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    TimeoutError,
+    ConnectionError,
+    InvalidResponseError,
+    ConfigurationError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "SebAuth",
+    "SebAuthError",
+    "AuthenticationError",
+    "APIError",
+    "BadRequestError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServerError",
+    "TimeoutError",
+    "ConnectionError",
+    "InvalidResponseError",
+    "ConfigurationError",
+    "__version__",
+]

seb_auth/auth.py

@@ -0,0 +1,43 @@
+"""Auth service placeholder.
+
+The SebAuth authentication endpoints are not yet exposed on the public
+API surface. This module reserves the ``seb.auth`` namespace so that
+methods can be added without breaking users of the SDK.
+
+Any call on this service will raise :class:`NotImplementedError` with a
+clear message pointing users at the SebAuth changelog.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import SebAuth
+
+__all__ = ["AuthService"]
+
+
+class AuthService:
+    """Placeholder for future SebAuth authentication endpoints."""
+
+    def __init__(self, client: "SebAuth") -> None:
+        self._client = client
+
+    def _not_yet_available(self, feature: str) -> "NotImplementedError":
+        return NotImplementedError(
+            f"seb.auth.{feature} is not yet available in the public SebAuth API. "
+            "This namespace is reserved for future releases of the SDK."
+        )
+
+    def sign_up(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("sign_up")
+
+    def sign_in(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("sign_in")
+
+    def sign_out(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("sign_out")
+
+    def get_user(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("get_user")

seb_auth/client.py

@@ -0,0 +1,213 @@
+"""The main :class:`SebAuth` client.
+
+The client is the entry point for every SebAuth service (email, auth,
+database, ...). It handles authentication, HTTP transport, timeouts, and
+error translation so that individual service modules can stay focused on
+their own business logic.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, Dict, Mapping, Optional
+
+import requests
+
+from . import exceptions as exc
+from .auth import AuthService
+from .database import DatabaseService
+from .email import EmailService
+
+__all__ = ["SebAuth"]
+
+logger = logging.getLogger("seb_auth")
+
+DEFAULT_BASE_URL = "https://seb-auth.lovable.app"
+DEFAULT_TIMEOUT = 30.0
+_USER_AGENT = "seb-auth-python/0.1.0"
+
+
+def _mask_key(api_key: str) -> str:
+    """Return a safe, masked representation of an API key for logging."""
+    if not api_key:
+        return "<empty>"
+    if len(api_key) <= 8:
+        return "***"
+    return f"{api_key[:6]}…{api_key[-4:]}"
+
+
+class SebAuth:
+    """Client for the SebAuth Backend-as-a-Service.
+
+    The API key is read (in this order) from:
+
+    1. The ``api_key`` keyword argument.
+    2. The ``SEBAUTH_API_KEY`` environment variable.
+
+    Example:
+        >>> from seb_auth import SebAuth
+        >>> seb = SebAuth()  # reads SEBAUTH_API_KEY from env
+        >>> seb.email.send(to="user@example.com", subject="Hi", body="Hello!")
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        resolved_key = api_key or os.environ.get("SEBAUTH_API_KEY")
+        if not resolved_key:
+            raise exc.ConfigurationError(
+                "SebAuth API key is required. Pass api_key=... or set the "
+                "SEBAUTH_API_KEY environment variable."
+            )
+
+        self._api_key = resolved_key
+        self.base_url = (base_url or os.environ.get("SEBAUTH_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self._session = session or requests.Session()
+
+        # Service namespaces.
+        self.email = EmailService(self)
+        self.auth = AuthService(self)
+        self.database = DatabaseService(self)
+
+    # ------------------------------------------------------------------ #
+    # Public helpers                                                     #
+    # ------------------------------------------------------------------ #
+
+    def __repr__(self) -> str:  # pragma: no cover - trivial
+        return f"SebAuth(base_url={self.base_url!r}, api_key={_mask_key(self._api_key)!r})"
+
+    def close(self) -> None:
+        """Close the underlying HTTP session."""
+        self._session.close()
+
+    def __enter__(self) -> "SebAuth":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # noqa: D401
+        self.close()
+
+    # ------------------------------------------------------------------ #
+    # Transport                                                          #
+    # ------------------------------------------------------------------ #
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Optional[Mapping[str, Any]] = None,
+        params: Optional[Mapping[str, Any]] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Send an authenticated HTTP request and return the parsed JSON body.
+
+        Raises a subclass of :class:`SebAuthError` for any failure.
+        """
+        url = f"{self.base_url}{path if path.startswith('/') else '/' + path}"
+        merged_headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Accept": "application/json",
+            "User-Agent": _USER_AGENT,
+        }
+        if json_body is not None:
+            merged_headers["Content-Type"] = "application/json"
+        if headers:
+            merged_headers.update(headers)
+
+        logger.debug(
+            "SebAuth %s %s (key=%s)", method, url, _mask_key(self._api_key)
+        )
+
+        try:
+            response = self._session.request(
+                method=method.upper(),
+                url=url,
+                json=json_body,
+                params=params,
+                headers=merged_headers,
+                timeout=timeout if timeout is not None else self.timeout,
+            )
+        except requests.exceptions.Timeout as e:
+            raise exc.TimeoutError(
+                f"Request to SebAuth timed out after "
+                f"{timeout if timeout is not None else self.timeout}s"
+            ) from e
+        except requests.exceptions.ConnectionError as e:
+            raise exc.ConnectionError(
+                f"Could not connect to SebAuth at {self.base_url}"
+            ) from e
+        except requests.exceptions.RequestException as e:
+            raise exc.SebAuthError(f"HTTP request failed: {e}") from e
+
+        return self._handle_response(response)
+
+    # ------------------------------------------------------------------ #
+    # Internals                                                          #
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _parse_body(response: requests.Response) -> Any:
+        if not response.content:
+            return None
+        content_type = response.headers.get("Content-Type", "")
+        if "application/json" in content_type:
+            try:
+                return response.json()
+            except (json.JSONDecodeError, ValueError) as e:
+                raise exc.InvalidResponseError(
+                    f"SebAuth returned invalid JSON: {e}"
+                ) from e
+        # Some errors may not have a JSON content-type; try best-effort JSON.
+        try:
+            return response.json()
+        except (json.JSONDecodeError, ValueError):
+            return response.text
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        body = self._parse_body(response)
+
+        if 200 <= response.status_code < 300:
+            if body is None:
+                return {}
+            if isinstance(body, dict):
+                return body
+            raise exc.InvalidResponseError(
+                f"Expected JSON object from SebAuth, got {type(body).__name__}"
+            )
+
+        # Error path — pull a human message out of the body.
+        message = "Unknown error"
+        if isinstance(body, dict):
+            message = (
+                body.get("error")
+                or body.get("message")
+                or body.get("detail")
+                or message
+            )
+            issues = body.get("issues")
+            if issues:
+                message = f"{message}: {issues}"
+        elif isinstance(body, str) and body.strip():
+            message = body.strip()
+
+        status = response.status_code
+        if status in (401, 403):
+            raise exc.AuthenticationError(message, status_code=status, response_body=body)
+        if status == 400:
+            raise exc.BadRequestError(message, status_code=status, response_body=body)
+        if status == 404:
+            raise exc.NotFoundError(message, status_code=status, response_body=body)
+        if status == 429:
+            raise exc.RateLimitError(message, status_code=status, response_body=body)
+        if 500 <= status < 600:
+            raise exc.ServerError(message, status_code=status, response_body=body)
+        raise exc.APIError(message, status_code=status, response_body=body)

seb_auth/database.py

@@ -0,0 +1,60 @@
+"""Database service placeholder.
+
+The SebAuth database endpoints are not yet exposed on the public API
+surface. This module reserves the ``seb.database`` namespace so that
+methods can be added without breaking users of the SDK.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import SebAuth
+
+__all__ = ["DatabaseService", "Table"]
+
+
+class Table:
+    """Placeholder for a future table/collection handle."""
+
+    def __init__(self, service: "DatabaseService", name: str) -> None:
+        self._service = service
+        self.name = name
+
+    def _not_yet_available(self, op: str) -> "NotImplementedError":
+        return NotImplementedError(
+            f"seb.database.table({self.name!r}).{op} is not yet available in "
+            "the public SebAuth API. This namespace is reserved for future "
+            "releases of the SDK."
+        )
+
+    def insert(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("insert")
+
+    def select(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("select")
+
+    def update(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("update")
+
+    def delete(self, *args, **kwargs):  # pragma: no cover - stub
+        raise self._not_yet_available("delete")
+
+
+class DatabaseService:
+    """Placeholder for future SebAuth database endpoints."""
+
+    def __init__(self, client: "SebAuth") -> None:
+        self._client = client
+
+    def table(self, name: str) -> Table:
+        """Return a handle for the given table/collection.
+
+        Currently every operation on the returned :class:`Table` raises
+        :class:`NotImplementedError` because the database endpoints have not
+        yet shipped in the public SebAuth API.
+        """
+        if not name or not isinstance(name, str):
+            raise ValueError("Table name must be a non-empty string")
+        return Table(self, name)

seb_auth/email.py

@@ -0,0 +1,98 @@
+"""Email service — wraps ``POST /api/public/v1/mail/send``."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import SebAuth
+
+__all__ = ["EmailService", "SendEmailResult"]
+
+
+class SendEmailResult(dict):
+    """Result returned by :meth:`EmailService.send`.
+
+    Behaves like a plain ``dict`` but exposes the most common fields as
+    attributes for convenience::
+
+        result = seb.email.send(to=..., subject=..., body=...)
+        print(result.id, result.status)
+    """
+
+    @property
+    def id(self) -> Optional[str]:
+        return self.get("id")
+
+    @property
+    def status(self) -> Optional[str]:
+        return self.get("status")
+
+    @property
+    def to_email(self) -> Optional[str]:
+        return self.get("to_email")
+
+    @property
+    def from_email(self) -> Optional[str]:
+        return self.get("from_email")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        return self.get("message_id")
+
+    @property
+    def sent_at(self) -> Optional[str]:
+        return self.get("sent_at")
+
+
+class EmailService:
+    """Send transactional email through SebAuth."""
+
+    _SEND_PATH = "/api/public/v1/mail/send"
+
+    def __init__(self, client: "SebAuth") -> None:
+        self._client = client
+
+    def send(
+        self,
+        to: str,
+        subject: str,
+        body: str,
+        *,
+        timeout: Optional[float] = None,
+    ) -> SendEmailResult:
+        """Send an email through SebAuth.
+
+        Args:
+            to: Recipient email address.
+            subject: Email subject.
+            body: Email body (plain text or HTML, depending on your account).
+            timeout: Optional per-request timeout override in seconds.
+
+        Returns:
+            A :class:`SendEmailResult` describing the queued/sent message.
+
+        Raises:
+            seb_auth.SebAuthError: If the request fails for any reason.
+        """
+        if not to or not isinstance(to, str):
+            raise ValueError("'to' must be a non-empty string")
+        if not isinstance(subject, str):
+            raise ValueError("'subject' must be a string")
+        if not isinstance(body, str):
+            raise ValueError("'body' must be a string")
+
+        payload: Dict[str, Any] = {"to": to, "subject": subject, "body": body}
+
+        response = self._client.request(
+            "POST",
+            self._SEND_PATH,
+            json_body=payload,
+            timeout=timeout,
+        )
+
+        email = response.get("email") if isinstance(response, dict) else None
+        if isinstance(email, dict):
+            return SendEmailResult(email)
+        # Fall back to the full response if the API shape ever changes.
+        return SendEmailResult(response if isinstance(response, dict) else {})

seb_auth/exceptions.py

@@ -0,0 +1,71 @@
+"""Exceptions raised by the SebAuth SDK.
+
+All exceptions inherit from :class:`SebAuthError` so users can catch every
+SDK-specific problem with a single ``except SebAuthError`` clause.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class SebAuthError(Exception):
+    """Base class for every exception raised by the SebAuth SDK."""
+
+
+class ConfigurationError(SebAuthError):
+    """Raised when the SDK is misconfigured (e.g. missing API key)."""
+
+
+class APIError(SebAuthError):
+    """Raised when the SebAuth API returns a non-2xx response.
+
+    Attributes:
+        status_code: HTTP status code returned by the API.
+        message: Human-readable error message extracted from the response.
+        response_body: Parsed response body (dict if JSON, else raw text).
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_body: Any = None,
+    ) -> None:
+        self.status_code = status_code
+        self.message = message
+        self.response_body = response_body
+        formatted = f"[{status_code}] {message}" if status_code is not None else message
+        super().__init__(formatted)
+
+
+class BadRequestError(APIError):
+    """HTTP 400 — the request body or parameters were invalid."""
+
+
+class AuthenticationError(APIError):
+    """HTTP 401 / 403 — the API key is missing, malformed or invalid."""
+
+
+class NotFoundError(APIError):
+    """HTTP 404 — the requested resource was not found."""
+
+
+class RateLimitError(APIError):
+    """HTTP 429 — you have been rate limited."""
+
+
+class ServerError(APIError):
+    """HTTP 5xx — SebAuth is having trouble handling your request."""
+
+
+class TimeoutError(SebAuthError):  # noqa: A001 — shadowing builtin is intentional
+    """Raised when a request to SebAuth exceeds the configured timeout."""
+
+
+class ConnectionError(SebAuthError):  # noqa: A001 — shadowing builtin is intentional
+    """Raised when the SDK cannot connect to the SebAuth API."""
+
+
+class InvalidResponseError(SebAuthError):
+    """Raised when the API responds with something the SDK cannot parse."""

seb_auth-0.1.0.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: seb-auth
+Version: 0.1.0
+Summary: Official Python SDK for SebAuth — a Backend-as-a-Service for email, auth, and database.
+Author: SebAuth
+License: MIT
+Project-URL: Homepage, https://seb-auth.lovable.app
+Project-URL: Documentation, https://seb-auth.lovable.app
+Project-URL: Source, https://github.com/sebauth/seb-auth-python
+Project-URL: Issues, https://github.com/sebauth/seb-auth-python/issues
+Keywords: sebauth,baas,email,auth,sdk,seb-auth
+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.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Communications :: Email
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"
+Requires-Dist: responses>=0.23; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: license-file
+
+# seb-auth
+
+**Official Python SDK for [SebAuth](https://seb-auth.lovable.app)** — a Backend-as-a-Service for email, authentication and database.
+
+[![PyPI](https://img.shields.io/pypi/v/seb-auth.svg)](https://pypi.org/project/seb-auth/)
+[![Python](https://img.shields.io/pypi/pyversions/seb-auth.svg)](https://pypi.org/project/seb-auth/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## Install
+
+```bash
+pip install seb-auth
+```
+
+## Quick start
+
+```python
+from seb_auth import SebAuth
+
+# Reads SEBAUTH_API_KEY from the environment.
+seb = SebAuth()
+
+result = seb.email.send(
+    to="user@example.com",
+    subject="Hello",
+    body="Hello from SebAuth!",
+)
+
+print(result.id, result.status)
+```
+
+Set your API key once and forget about it:
+
+```bash
+export SEBAUTH_API_KEY="sk_live_..."
+```
+
+Or pass it explicitly (never hard-code it in your source):
+
+```python
+import os
+from seb_auth import SebAuth
+
+seb = SebAuth(api_key=os.environ["MY_SEBAUTH_KEY"])
+```
+
+## Features
+
+- 📨 **Email** — send transactional email via `seb.email.send(...)`.
+- 🔐 **Auth** — namespace reserved for upcoming SebAuth auth endpoints.
+- 🗄️ **Database** — namespace reserved for upcoming SebAuth database endpoints.
+- ⏱️ Sensible request **timeouts** (30 s default, per-call overridable).
+- 🧯 Typed **exception hierarchy** for easy error handling.
+- 🕵️ Never prints or logs your full API key.
+
+## Sending email
+
+`seb.email.send(...)` makes a real HTTP request to
+`POST https://seb-auth.lovable.app/api/public/v1/mail/send` and returns a
+result object exposing everything SebAuth tells you about the message.
+
+```python
+from seb_auth import SebAuth
+
+seb = SebAuth()
+
+result = seb.email.send(
+    to="jane@example.com",
+    subject="Welcome to Acme",
+    body="<h1>Hi Jane 👋</h1><p>Thanks for signing up!</p>",
+)
+
+print(result.id)          # -> "e5e7eea2-..."
+print(result.status)      # -> "sent"
+print(result.message_id)  # -> "<...@gmail.com>"
+print(result.sent_at)     # -> ISO-8601 timestamp
+```
+
+`SendEmailResult` is a normal `dict`, so `result["id"]` works too.
+
+## Error handling
+
+Every exception raised by the SDK inherits from `SebAuthError`, so you can
+catch everything with one clause or drill down as needed:
+
+```python
+from seb_auth import (
+    SebAuth,
+    SebAuthError,
+    AuthenticationError,
+    BadRequestError,
+    RateLimitError,
+    TimeoutError,
+    ConnectionError,
+)
+
+seb = SebAuth()
+
+try:
+    seb.email.send(to="user@example.com", subject="Hi", body="Hello!")
+except AuthenticationError:
+    print("Your API key is invalid.")
+except BadRequestError as e:
+    print("Bad request:", e.message)
+except RateLimitError:
+    print("Slow down — you're being rate limited.")
+except TimeoutError:
+    print("SebAuth took too long to respond.")
+except ConnectionError:
+    print("Could not reach SebAuth.")
+except SebAuthError as e:
+    print("Something else went wrong:", e)
+```
+
+Every `APIError` exposes `status_code`, `message` and `response_body` for
+easy debugging.
+
+## Configuration
+
+| Argument     | Env var             | Default                              |
+| ------------ | ------------------- | ------------------------------------ |
+| `api_key`    | `SEBAUTH_API_KEY`   | — *(required)*                       |
+| `base_url`   | `SEBAUTH_BASE_URL`  | `https://seb-auth.lovable.app`       |
+| `timeout`    | —                   | `30` seconds                         |
+
+You can also pass a custom `requests.Session` via `session=...` if you
+need to configure retries, proxies, or connection pooling.
+
+## Context manager
+
+`SebAuth` can be used as a context manager to guarantee that the
+underlying HTTP session is closed:
+
+```python
+with SebAuth() as seb:
+    seb.email.send(to="user@example.com", subject="Hi", body="Hello!")
+```
+
+## Roadmap
+
+The SebAuth public API currently exposes the email endpoint. The
+`seb.auth` and `seb.database` namespaces are reserved for upcoming
+endpoints and will raise `NotImplementedError` until they ship.
+
+## Development
+
+```bash
+git clone https://github.com/sebauth/seb-auth-python
+cd seb-auth-python
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT © SebAuth

seb_auth-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+seb_auth/__init__.py,sha256=YdW8Uiq7n06s2dC9a2klz7OfwVYOmZiv4CHOhs8cdGk,864
+seb_auth/auth.py,sha256=Pn3A84DWHBcb0xCEZQQXb7z0l_lGQJGHQQPIXhHlxYM,1444
+seb_auth/client.py,sha256=xke6H-RoWIRxX5nicTMVmA-emBKmgDpWvZFGDElJfFA,7619
+seb_auth/database.py,sha256=EWITV09eoL29Gqbr6FMI5Xb8AkKbBqrXyhst9UtS_jg,2014
+seb_auth/email.py,sha256=WGx50jyEzSQdKBFTQXGxYejSr41o0aiIBvHpw2ypxDE,2814
+seb_auth/exceptions.py,sha256=NnIK1-IaTD7xp7bAqdTJhQ2NucYWsVa0nNtt3R8zA-Y,2123
+seb_auth-0.1.0.dist-info/licenses/LICENSE,sha256=R-848iiTjCIN7D_qRmbsHqJks9nEVTeGz50-TAIblIw,1064
+seb_auth-0.1.0.dist-info/METADATA,sha256=P6rl3o2jrqJS2X7TdJyZz9M3xQHT6eEe_N4_MJW1olA,5713
+seb_auth-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+seb_auth-0.1.0.dist-info/top_level.txt,sha256=hOdvSfR2JPumzv7Vd56k0AkGlKQkPh9gHscnbz_zZyI,9
+seb_auth-0.1.0.dist-info/RECORD,,

seb_auth-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

seb_auth-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SebAuth
+
+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.

seb_auth-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+seb_auth