anzar 0.1.0__tar.gz

anzar-0.1.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.3
+Name: anzar
+Version: 0.1.0
+Summary: Add your description here
+Author: Hakou Guelfen
+Author-email: Hakou Guelfen <hakoudev@gmail.com>
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: pydantic[email]>=2.11.7
+Requires-Dist: requests>=2.32.5
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Anzar SDK Documentation
+
+## Installation
+
+```bash
+pip install anzar
+```
+
+## Quick Start
+
+```python
+from anzar import AnzarAuth
+
+# Initialize the SDK
+auth = AnzarAuth
+
+# Use the authenticated client
+# (Add specific usage examples here)
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project root:
+
+```env
+# Add your environment variables here
+ANZAR_API_KEY=your_api_key
+ANZAR_BASE_URL=https://api.anzar.com
+```
+
+## API Reference
+
+### AnzarAuth
+
+Authentication manager for user login, registration, and session management.
+
+```python
+from anzar import AnzarAuth
+```
+
+#### Methods
+
+##### `login(email, password)`
+
+Authenticate a user with credentials.
+
+**Parameters:**
+- `email` (str): User's email
+- `password` (str): User's password
+
+**Returns:**
+- `User`: User object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.login("user@example.com", "password123")
+if isinstance(result, User):
+    print(f"Logged in: {result.username}")
+else:
+    print(f"Login failed: {result.error}")
+```
+
+##### `register(username, email, password)`
+
+Register a new user account.
+
+**Parameters:**
+- `username` (str): Desired username
+- `email` (str): User's email address
+- `password` (str): User's password
+
+**Returns:**
+- `User`: User object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.register("newuser", "user@example.com", "password123")
+```
+
+##### `logout()`
+
+Log out the current user.
+
+**Returns:**
+- `User`: Empty user object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.logout()
+```
+
+##### `isLoggedIn()`
+
+Check if a user is currently logged in.
+
+**Returns:**
+- `User`: Current user object if logged in
+- `Error`: Error object if not logged in
+
+**Example:**
+```python
+result = AnzarAuth.isLoggedIn()
+if isinstance(result, User):
+    print(f"Current user: {result.username}")
+else:
+    print("No user logged in")
+```
+
+## Error Handling
+
+```python
+from anzar.types import Error
+try:
+    result = AnzarAuth.login(email, password)
+except Error as e:
+    print(f"Error: {e}")
+```
+
+## Examples
+
+### Basic Authentication Flow
+
+```python
+from anzar import AnzarAuth
+
+# Register new user
+result = AnzarAuth.register("johndoe", "john@example.com", "securepass123")
+if isinstance(result, Error):
+    print(f"Registration failed: {result.message}")
+    return
+
+# Login
+result = AnzarAuth.login("john@example.com", "securepass123")
+if isinstance(result, Error):
+    print(f"Login failed: {result.message}")
+    return
+
+print(f"Welcome {result.username}")
+
+# Check login status
+user = AnzarAuth.isLoggedIn()
+if not isinstance(user, Error):
+    print(f"Current user: {user.username}")
+
+# Logout
+AnzarAuth.logout()
+```
+
+## Contributing
+
+Instructions for contributing to the SDK.
+
+## License
+
+License information.

anzar-0.1.0/README.md

@@ -0,0 +1,160 @@
+# Anzar SDK Documentation
+
+## Installation
+
+```bash
+pip install anzar
+```
+
+## Quick Start
+
+```python
+from anzar import AnzarAuth
+
+# Initialize the SDK
+auth = AnzarAuth
+
+# Use the authenticated client
+# (Add specific usage examples here)
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project root:
+
+```env
+# Add your environment variables here
+ANZAR_API_KEY=your_api_key
+ANZAR_BASE_URL=https://api.anzar.com
+```
+
+## API Reference
+
+### AnzarAuth
+
+Authentication manager for user login, registration, and session management.
+
+```python
+from anzar import AnzarAuth
+```
+
+#### Methods
+
+##### `login(email, password)`
+
+Authenticate a user with credentials.
+
+**Parameters:**
+- `email` (str): User's email
+- `password` (str): User's password
+
+**Returns:**
+- `User`: User object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.login("user@example.com", "password123")
+if isinstance(result, User):
+    print(f"Logged in: {result.username}")
+else:
+    print(f"Login failed: {result.error}")
+```
+
+##### `register(username, email, password)`
+
+Register a new user account.
+
+**Parameters:**
+- `username` (str): Desired username
+- `email` (str): User's email address
+- `password` (str): User's password
+
+**Returns:**
+- `User`: User object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.register("newuser", "user@example.com", "password123")
+```
+
+##### `logout()`
+
+Log out the current user.
+
+**Returns:**
+- `User`: Empty user object on success
+- `Error`: Error object on failure
+
+**Example:**
+```python
+result = AnzarAuth.logout()
+```
+
+##### `isLoggedIn()`
+
+Check if a user is currently logged in.
+
+**Returns:**
+- `User`: Current user object if logged in
+- `Error`: Error object if not logged in
+
+**Example:**
+```python
+result = AnzarAuth.isLoggedIn()
+if isinstance(result, User):
+    print(f"Current user: {result.username}")
+else:
+    print("No user logged in")
+```
+
+## Error Handling
+
+```python
+from anzar.types import Error
+try:
+    result = AnzarAuth.login(email, password)
+except Error as e:
+    print(f"Error: {e}")
+```
+
+## Examples
+
+### Basic Authentication Flow
+
+```python
+from anzar import AnzarAuth
+
+# Register new user
+result = AnzarAuth.register("johndoe", "john@example.com", "securepass123")
+if isinstance(result, Error):
+    print(f"Registration failed: {result.message}")
+    return
+
+# Login
+result = AnzarAuth.login("john@example.com", "securepass123")
+if isinstance(result, Error):
+    print(f"Login failed: {result.message}")
+    return
+
+print(f"Welcome {result.username}")
+
+# Check login status
+user = AnzarAuth.isLoggedIn()
+if not isinstance(user, Error):
+    print(f"Current user: {user.username}")
+
+# Logout
+AnzarAuth.logout()
+```
+
+## Contributing
+
+Instructions for contributing to the SDK.
+
+## License
+
+License information.

anzar-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "anzar"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Hakou Guelfen", email = "hakoudev@gmail.com" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "dotenv>=0.9.9",
+    "keyring>=25.6.0",
+    "pydantic[email]>=2.11.7",
+    "requests>=2.32.5",
+]
+# packages=["anzar", "anzar.types"]
+
+
+[build-system]
+requires = ["uv_build>=0.8.4,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = []
+
+
+[tool.uv]
+dev-dependencies = [
+    "pytest",
+]
+

anzar-0.1.0/src/anzar/__init__.py

@@ -0,0 +1,21 @@
+import dotenv
+import logging
+
+from ._api.client import HttpClient
+from ._api.http_interceptor import HttpInterceptor
+
+_ = dotenv.load_dotenv()
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+
+
+def get_anzar_auth():
+    from ._auth.authenticator import AuthManager
+
+    return AuthManager(HttpClient(HttpInterceptor()))
+
+
+AnzarAuth = get_anzar_auth()
+__all__ = ["AnzarAuth"]

anzar-0.1.0/src/anzar/_api/client.py

@@ -0,0 +1,37 @@
+from requests.models import Response
+
+from anzar._models.auth import LoginRequest, RegisterRequest
+from anzar._api.http_interceptor import HttpInterceptor
+from anzar._utils.errors import Error
+from anzar._utils.types import T
+from anzar._utils.validator import Validator
+
+
+class HttpClient:
+    def __init__(self, http_interceptor: HttpInterceptor):
+        self.http_interceptor: HttpInterceptor = http_interceptor
+        self.accessToken: str | None = None
+
+    def get(self, url: str, model_type: type[T]) -> T | Error:
+        response: Response = self.http_interceptor.get(url)
+
+        if response.status_code in (200, 201):
+            return model_type.model_validate(response.json())
+        else:
+            return Error.model_validate(response.json())
+
+    def post(
+        self,
+        url: str,
+        data: LoginRequest | RegisterRequest | None,
+        model_type: type[T],
+    ) -> T | Error:
+        if data:
+            response: Response = self.http_interceptor.post(url, json=data.__dict__)
+        else:
+            response = self.http_interceptor.post(url)
+
+        if response.status_code in (200, 201):
+            return Validator().validate(model_type, response)
+        else:
+            return Error.model_validate(response.json())

anzar-0.1.0/src/anzar/_api/http_interceptor.py

@@ -0,0 +1,113 @@
+import logging
+import os
+from typing import Any, override
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
+
+from anzar._models.auth import AuthResponse, JWTTokens
+from anzar._utils.config import Config
+from anzar._utils.storage import TokenStorage
+from anzar._utils.types import Token, TokenType
+
+
+class HttpInterceptor(requests.Session):
+    def __init__(self) -> None:
+        super().__init__()
+        self.API_URL: str = os.getenv("API_URL", "http://localhost:3000")
+        self.storage: TokenStorage = TokenStorage()
+        self.banned_endpoints: list[str] = ["auth/login", "auth/register"]
+        self.refresh_endpoints: list[str] = ["auth/logout", "auth/refreshToken"]
+
+        # Retry logic (optional)
+        retries = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[500, 502, 503, 504],
+            allowed_methods=["GET", "POST", "PUT", "DELETE", "PATCH"],
+        )
+        adapter = HTTPAdapter(max_retries=retries)
+        self.mount("http://", adapter)
+        self.mount("https://", adapter)
+
+    def __extractTokenFromCache(self, tokenType: TokenType) -> Token | None:
+        token = self.storage.load(tokenType.name)
+        return Token.new(token, tokenType) if token else None
+
+    def __isUrlPartOf(self, url: str | bytes, endpoints: list[str]) -> bool:
+        for endpoint in endpoints:
+            if url == f"{self.API_URL}/{endpoint}":
+                return True
+        return False
+
+    def __get_appropriate_token(self, url: str | bytes) -> Token | None:
+        if self.__isUrlPartOf(url, self.banned_endpoints):
+            return None
+
+        if self.__isUrlPartOf(url, self.refresh_endpoints):
+            return self.__extractTokenFromCache(TokenType.RefreshToken)
+
+        return self.__extractTokenFromCache(TokenType.AccessToken)
+
+    def __handle_auth_response(
+        self, url: str | bytes, response: requests.Response
+    ) -> None:
+        if not response.ok:
+            return
+
+        if url == f"{self.API_URL}/auth/refreshToken":
+            jwtTokens = JWTTokens.model_validate(response.json())
+        elif self.__isUrlPartOf(url, self.banned_endpoints):
+            auth_response = AuthResponse.model_validate(response.json())
+            jwtTokens = JWTTokens(
+                accessToken=auth_response.accessToken,
+                refreshToken=auth_response.refreshToken,
+            )
+        else:
+            return
+
+        self.storage.save(jwtTokens)
+
+    def __send_request(
+        self, method: str | bytes, url: str | bytes, *args, **kwargs
+    ) -> requests.Response:
+        token = self.__get_appropriate_token(url)
+        kwargs["headers"] = Config().headers(token=token)
+        return super().request(method, url, timeout=30, *args, **kwargs)
+
+    @override
+    def request(
+        self,
+        method: str | bytes,
+        url: str | bytes,
+        _refresh_attempted: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ) -> requests.Response:
+        # PRE-REQUEST INTERCEPTION
+        logging.info(f"{method} {url}")
+        response = self.__send_request(method, url, *args, **kwargs)
+
+        # POST-RESPONSE INTERCEPTION
+        logging.info(f"Response: {response.status_code}")
+        if (
+            response.status_code == 401
+            and not self.__isUrlPartOf(url, self.banned_endpoints)
+            and not self.__isUrlPartOf(url, self.refresh_endpoints)
+            and not _refresh_attempted
+        ):
+            # header: Content-Type: application/x-www-form-urlencoded
+            response = self.request(
+                method="POST",
+                url=f"{self.API_URL}/auth/refreshToken",
+                _refresh_attempted=True,
+                *args,
+                **kwargs,
+            )
+
+            response = self.__send_request(method, url, *args, **kwargs)
+
+        self.__handle_auth_response(url, response)
+
+        return response

anzar-0.1.0/src/anzar/_auth/authenticator.py

@@ -0,0 +1,81 @@
+import os
+
+from anzar._api.client import HttpClient
+
+from anzar._models.auth import AuthResponse
+from anzar._models.user import User
+from anzar._utils.errors import Error
+from anzar._utils.storage import TokenStorage
+from anzar._utils.types import NoType
+from anzar._utils.validator import Validator
+
+
+class AuthManager:
+    def __init__(self, httpClient: HttpClient) -> None:
+        self._http_client: HttpClient = httpClient
+
+        self._API_URL: str = os.getenv("API_URL", "http://localhost:3000")
+        assert self._API_URL is not None, "Env was unable to load"
+        self.__endpoints: dict[str, str] = {
+            "login": f"{self._API_URL}/auth/login",
+            "register": f"{self._API_URL}/auth/register",
+            "user": f"{self._API_URL}/user",
+            "logout": f"{self._API_URL}/auth/logout",
+        }
+
+    def register(self, username: str, email: str, password: str) -> Error | User:
+        req = Validator().construct_register(username, email, password)
+        if isinstance(req, Error):
+            return req
+
+        url = self.__endpoints["register"]
+        response = self._http_client.post(url, req, AuthResponse)
+
+        return response.user if isinstance(response, AuthResponse) else response
+
+    def login(self, email: str, password: str):
+        req = Validator().construct_login(email, password)
+        if isinstance(req, Error):
+            return req
+
+        url = self.__endpoints["login"]
+        response = self._http_client.post(url, req, AuthResponse)
+
+        return response.user if isinstance(response, AuthResponse) else response
+
+    def getUser(self):
+        url = self.__endpoints["user"]
+        response = self._http_client.get(url, User)
+        return response
+
+    def logout(self):
+        url = self.__endpoints["logout"]
+        response = self._http_client.post(url, None, NoType)
+        TokenStorage().clear()
+
+        return response
+
+
+# def main():
+#     from pprint import pprint
+#     from anzar._api.http_interceptor import HttpInterceptor
+#
+#     authManager = AuthManager(HttpClient(HttpInterceptor()))
+#
+#     # username, email, password = "Hakou", "hakouguelfen@gmail.com", "hakouguelfen"
+#     # user = authManager.register(username, email, password)
+#     # pprint(user)
+#
+#     # email, password = "hakouguelfen@gmail.com", "hakouguelfen"
+#     # user = authManager.login(email, password)
+#     # pprint(user)
+#
+#     user = authManager.getUser()
+#     pprint(user)
+#
+#     response = authManager.logout()
+#     pprint(response)
+#
+#
+# if __name__ == "__main__":
+#     main()

anzar-0.1.0/src/anzar/_models/auth.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel, EmailStr
+from pydantic.dataclasses import dataclass
+
+from .user import User
+
+
+@dataclass()
+class LoginRequest:
+    email: EmailStr
+    password: str
+
+
+@dataclass()
+class RegisterRequest:
+    username: str
+    email: EmailStr
+    password: str
+
+
+class AuthResponse(BaseModel):
+    accessToken: str
+    refreshToken: str
+    user: User
+
+
+class JWTTokens(BaseModel):
+    accessToken: str
+    refreshToken: str
+    refreshTokenJti: str | None = None

anzar-0.1.0/src/anzar/_models/user.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, EmailStr
+
+from enum import Enum
+
+
+class Role(str, Enum):
+    Admin = "Admin"
+    User = "User"
+
+
+class User(BaseModel):
+    # id: str | None = Field(None, alias="_id")
+    _id: str | None
+    username: str
+    email: EmailStr
+    role: Role
+    isPremium: bool
+    accountLocked: bool

anzar-0.1.0/src/anzar/_utils/config.py

@@ -0,0 +1,16 @@
+from anzar._utils.types import Header, Token, TokenType
+
+
+class Config:
+    def headers(self, token: Token | None) -> Header:
+        default_headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "Anzar-SDK/1.0",
+        }
+        if token is not None:
+            if token.tokenType == TokenType.AccessToken:
+                default_headers["authorization"] = f"Bearer {token.value}"
+            if token.tokenType == TokenType.RefreshToken:
+                default_headers["x-refresh-token"] = f"Bearer {token.value}"
+
+        return default_headers

anzar-0.1.0/src/anzar/_utils/errors.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class Error(BaseModel):
+    error: str

anzar-0.1.0/src/anzar/_utils/storage.py

@@ -0,0 +1,29 @@
+import keyring
+
+from anzar._models.auth import JWTTokens
+from anzar._utils.types import TokenType
+
+
+SERVICE_NAME = "AnzarSDK"
+
+ACCESS_TOKEN = TokenType.AccessToken.name
+REFRESH_TOKEN = TokenType.RefreshToken.name
+
+
+class TokenStorage:
+    def save(self, tokens: JWTTokens):
+        try:
+            keyring.set_password(SERVICE_NAME, ACCESS_TOKEN, tokens.accessToken)
+            keyring.set_password(SERVICE_NAME, REFRESH_TOKEN, tokens.refreshToken)
+        except Exception as e:
+            print(e)
+
+    def load(self, username: str):
+        try:
+            return keyring.get_password(SERVICE_NAME, username)
+        except Exception as e:
+            print(e)
+
+    def clear(self):
+        keyring.set_password(SERVICE_NAME, ACCESS_TOKEN, "")
+        keyring.set_password(SERVICE_NAME, REFRESH_TOKEN, "")

anzar-0.1.0/src/anzar/_utils/types.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Generic, TypeVar, override
+
+from pydantic import BaseModel
+
+Header = Mapping[str, str | bytes | None]
+T = TypeVar("T", bound=BaseModel)
+
+
+class NoType(BaseModel):
+    status: str | None
+
+
+class TokenType(Enum):
+    AccessToken = auto()
+    RefreshToken = auto()
+
+
+@dataclass()
+class Token:
+    value: str
+    tokenType: TokenType
+
+    @classmethod
+    def new(cls, value: str, tokenType: TokenType):
+        return cls(value, tokenType)
+
+
+R = TypeVar("R")
+
+
+class Result(Generic[R]):
+    @property
+    def is_ok(self) -> bool: ...
+    @property
+    def is_err(self) -> bool: ...
+
+
+class Ok(Result[R]):
+    def __init__(self, value: R) -> None:
+        self.value: R = value
+
+    @property
+    @override
+    def is_ok(self) -> bool:
+        return True
+
+    @property
+    @override
+    def is_err(self) -> bool:
+        return False
+
+
+class Err(Result[R]):
+    def __init__(self, error: str) -> None:
+        self.error: str = error
+
+    @property
+    @override
+    def is_ok(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_err(self) -> bool:
+        return True

anzar-0.1.0/src/anzar/_utils/validator.py

@@ -0,0 +1,36 @@
+from pydantic import ValidationError
+from requests import Response
+
+from anzar._utils.errors import Error
+from anzar._utils.types import T
+
+from anzar._models.auth import LoginRequest, RegisterRequest
+
+
+class Validator:
+    def construct_register(
+        self, username: str, email: str, password: str
+    ) -> RegisterRequest | Error:
+        try:
+            return RegisterRequest(username, email, password)
+
+        except ValidationError as e:
+            ctx = e.errors()[0].get("ctx")
+
+            reason: str | None = ctx.get("reason") if ctx else None
+            return Error(error=reason or "Data is not validated")
+
+    def construct_login(self, email: str, password: str) -> LoginRequest | Error:
+        try:
+            return LoginRequest(email, password)
+        except ValidationError as e:
+            ctx = e.errors()[0].get("ctx")
+
+            reason: str | None = ctx.get("reason") if ctx else None
+            return Error(error=reason or "Data is not validated")
+
+    def validate(self, model_type: type[T], res: Response) -> T | Error:
+        try:
+            return model_type.model_validate(res.json())
+        except ValidationError as _:
+            return Error(error="")

anzar-0.1.0/src/anzar/types.py

@@ -0,0 +1,8 @@
+from ._utils.errors import Error
+from ._utils.types import NoType
+
+from anzar._models.user import User
+from anzar._models.auth import AuthResponse
+
+
+__all__ = ["User", "AuthResponse", "NoType", "Error"]