rxresume-python 0.1.0__py3-none-any.whl

reactive_resume/__init__.py

@@ -0,0 +1,26 @@
+"""Reactive Resume API Python SDK.
+
+An unofficial client for programmatically interacting with Reactive Resume v4 API.
+"""
+
+from .core.client import RxResumeClient
+from .core.async_client import AsyncRxResumeClient
+from .core.exceptions import (
+    ReactiveResumeError,
+    ReactiveResumeAPIError,
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "RxResumeClient",
+    "AsyncRxResumeClient",
+    "ReactiveResumeError",
+    "ReactiveResumeAPIError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+]

reactive_resume/api/__init__.py

@@ -0,0 +1,11 @@
+"""API endpoints and service groups."""
+
+from .auth import AuthAPI, AsyncAuthAPI
+from .resumes import ResumesAPI, AsyncResumesAPI
+
+__all__ = [
+    "AuthAPI",
+    "AsyncAuthAPI",
+    "ResumesAPI",
+    "AsyncResumesAPI",
+]

reactive_resume/api/auth.py

@@ -0,0 +1,66 @@
+"""Authentication endpoints implementation."""
+
+from typing import Tuple
+from ..models.user import User
+
+
+class AuthAPI:
+    """Synchronous Authentication operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def login(self, email: str, password: str) -> Tuple[str, User]:
+        """Log in with email and password.
+
+        Args:
+            email: User's email.
+            password: User's password.
+
+        Returns:
+            A tuple of (access_token, User object).
+        """
+        payload = {"identifier": email, "password": password}
+        response = self._client._request("POST", "/api/auth/login", json=payload)
+
+        # Typically returns token in cookies or response body
+        # Let's extract token and user
+        token = response.get("token") or response.get("accessToken", "")
+        user_data = response.get("user") or response
+        user = User.model_validate(user_data)
+        return token, user
+
+    def me(self) -> User:
+        """Get the current authenticated user profile."""
+        response = self._client._request("GET", "/api/user/me")
+        return User.model_validate(response)
+
+
+class AsyncAuthAPI:
+    """Asynchronous Authentication operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def login(self, email: str, password: str) -> Tuple[str, User]:
+        """Log in asynchronously with email and password.
+
+        Args:
+            email: User's email.
+            password: User's password.
+
+        Returns:
+            A tuple of (access_token, User object).
+        """
+        payload = {"identifier": email, "password": password}
+        response = await self._client._request("POST", "/api/auth/login", json=payload)
+
+        token = response.get("token") or response.get("accessToken", "")
+        user_data = response.get("user") or response
+        user = User.model_validate(user_data)
+        return token, user
+
+    async def me(self) -> User:
+        """Get the current authenticated user profile asynchronously."""
+        response = await self._client._request("GET", "/api/user/me")
+        return User.model_validate(response)

reactive_resume/api/resumes.py

@@ -0,0 +1,169 @@
+"""Resumes endpoints implementation."""
+
+from typing import List, Dict, Any
+from ..models.resume import Resume, ResumeImportData
+
+
+class ResumesAPI:
+    """Synchronous Resume operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def list(self) -> List[Resume]:
+        """List all resumes for the authenticated user.
+
+        Returns:
+            A list of Resume objects.
+        """
+        response = self._client._request("GET", "/api/openapi/resumes")
+        # The response is usually a list of resume objects
+        if isinstance(response, dict) and "data" in response:
+            # Handle potential pagination wrapper
+            items = response["data"]
+        else:
+            items = response
+        return [Resume.model_validate(item) for item in items]
+
+    def get(self, resume_id: str) -> Resume:
+        """Retrieve a specific resume by ID.
+
+        Args:
+            resume_id: Unique identifier for the resume.
+
+        Returns:
+            The Resume object.
+        """
+        response = self._client._request("GET", f"/api/openapi/resume/{resume_id}")
+        return Resume.model_validate(response)
+
+    def create(self, data: ResumeImportData) -> Resume:
+        """Create or import a new resume.
+
+        Args:
+            data: ResumeImportData object containing title, basics, and sections.
+
+        Returns:
+            The created Resume object.
+        """
+        # Convert Pydantic model to dict, matching what API expects
+        payload = data.model_dump(by_alias=True, exclude_none=True)
+        response = self._client._request("POST", "/api/openapi/resumes", json=payload)
+        return Resume.model_validate(response)
+
+    def import_resume(self, data: ResumeImportData) -> Resume:
+        """Alias for create, importing a resume.
+
+        Args:
+            data: ResumeImportData object containing title, basics, and sections.
+
+        Returns:
+            The imported Resume object.
+        """
+        return self.create(data)
+
+    def update(self, resume_id: str, data: Dict[str, Any]) -> Resume:
+        """Update a resume (PATCH).
+
+        Args:
+            resume_id: Unique identifier for the resume.
+            data: Dictionary of properties to update (e.g. JSON Patch or key-value updates).
+
+        Returns:
+            The updated Resume object.
+        """
+        # Reactive Resume v4 supports PATCH with JSON Patch or direct body updates
+        response = self._client._request("PATCH", f"/api/openapi/resume/{resume_id}", json=data)
+        return Resume.model_validate(response)
+
+    def delete(self, resume_id: str) -> None:
+        """Delete a resume by ID.
+
+        Args:
+            resume_id: Unique identifier for the resume.
+        """
+        self._client._request("DELETE", f"/api/openapi/resume/{resume_id}")
+
+    def get_pdf_url(self, resume_id: str) -> str:
+        """Get the URL to download the PDF for a specific resume.
+
+        Args:
+            resume_id: Unique identifier for the resume.
+
+        Returns:
+            The absolute PDF download URL.
+        """
+        # The print/pdf download URL format in Reactive Resume V4 API
+        # Typically of form: {base_url}/api/openapi/resume/{resume_id}/pdf
+        return f"{self._client.base_url}/api/openapi/resume/{resume_id}/pdf"
+
+
+class AsyncResumesAPI:
+    """Asynchronous Resume operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def list(self) -> List[Resume]:
+        """List all resumes asynchronously.
+
+        Returns:
+            A list of Resume objects.
+        """
+        response = await self._client._request("GET", "/api/openapi/resumes")
+        if isinstance(response, dict) and "data" in response:
+            items = response["data"]
+        else:
+            items = response
+        return [Resume.model_validate(item) for item in items]
+
+    async def get(self, resume_id: str) -> Resume:
+        """Retrieve a specific resume asynchronously.
+
+        Args:
+            resume_id: Unique identifier for the resume.
+
+        Returns:
+            The Resume object.
+        """
+        response = await self._client._request("GET", f"/api/openapi/resume/{resume_id}")
+        return Resume.model_validate(response)
+
+    async def create(self, data: ResumeImportData) -> Resume:
+        """Create or import a new resume asynchronously.
+
+        Args:
+            data: ResumeImportData object.
+
+        Returns:
+            The created Resume object.
+        """
+        payload = data.model_dump(by_alias=True, exclude_none=True)
+        response = await self._client._request("POST", "/api/openapi/resumes", json=payload)
+        return Resume.model_validate(response)
+
+    async def import_resume(self, data: ResumeImportData) -> Resume:
+        """Alias for create, importing a resume asynchronously."""
+        return await self.create(data)
+
+    async def update(self, resume_id: str, data: Dict[str, Any]) -> Resume:
+        """Update a resume asynchronously."""
+        response = await self._client._request(
+            "PATCH", f"/api/openapi/resume/{resume_id}", json=data
+        )
+        return Resume.model_validate(response)
+
+    async def delete(self, resume_id: str) -> None:
+        """Delete a resume asynchronously."""
+        await self._client._request("DELETE", f"/api/openapi/resume/{resume_id}")
+
+    async def get_pdf_url(self, resume_id: str) -> str:
+        """Get the URL to download the PDF asynchronously.
+
+        Args:
+            resume_id: Unique identifier for the resume.
+
+        Returns:
+            The absolute PDF download URL.
+        """
+        return f"{self._client.base_url}/api/openapi/resume/{resume_id}/pdf"

reactive_resume/core/__init__.py

@@ -0,0 +1,17 @@
+"""Core functionality and HTTP client structures."""
+
+from .exceptions import (
+    ReactiveResumeError,
+    ReactiveResumeAPIError,
+    AuthenticationError,
+    NotFoundError,
+    ValidationError,
+)
+
+__all__ = [
+    "ReactiveResumeError",
+    "ReactiveResumeAPIError",
+    "AuthenticationError",
+    "NotFoundError",
+    "ValidationError",
+]

reactive_resume/core/async_client.py

@@ -0,0 +1,151 @@
+"""Asynchronous API Client implementation."""
+
+from typing import Any, Optional
+import httpx
+
+from .exceptions import (
+    ReactiveResumeError,
+    ReactiveResumeAPIError,
+    AuthenticationError,
+    NotFoundError,
+)
+from ..api.auth import AsyncAuthAPI
+from ..api.resumes import AsyncResumesAPI
+
+
+class AsyncRxResumeClient:
+    """Asynchronous client for Reactive Resume v4 API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+        verify: bool = True,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            base_url: The base URL of the Reactive Resume instance.
+            api_key: API Key for x-api-key authentication.
+            token: Bearer Token for Authorization authentication.
+            timeout: Request timeout in seconds.
+            verify: Verify SSL certificates.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.verify = verify
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "rxresume-python/0.1.0",
+        }
+
+        if api_key:
+            headers["x-api-key"] = api_key
+        elif token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        self.client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers=headers,
+            timeout=self.timeout,
+            verify=self.verify,
+        )
+
+        # Initialize API sections
+        self.auth = AsyncAuthAPI(self)
+        self.resumes = AsyncResumesAPI(self)
+
+    def set_token(self, token: str) -> None:
+        """Update client headers with a new Bearer token."""
+        self.client.headers["Authorization"] = f"Bearer {token}"
+        if "x-api-key" in self.client.headers:
+            del self.client.headers["x-api-key"]
+
+    def set_api_key(self, api_key: str) -> None:
+        """Update client headers with a new API key."""
+        self.client.headers["x-api-key"] = api_key
+        if "Authorization" in self.client.headers:
+            del self.client.headers["Authorization"]
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Perform an asynchronous HTTP request and handle errors.
+
+        Args:
+            method: HTTP method (GET, POST, etc.).
+            url: Target URL path (appended to base_url).
+            **kwargs: Extra arguments for httpx request.
+
+        Returns:
+            Decoded JSON response or raw content.
+        """
+        try:
+            response = await self.client.request(method, url, **kwargs)
+            return self._handle_response(response)
+        except httpx.HTTPError as e:
+            if not isinstance(e, httpx.HTTPStatusError):
+                raise ReactiveResumeError(f"Network or connection error occurred: {e}") from e
+            raise
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Process response data or raise descriptive exceptions.
+
+        Args:
+            response: Response object from httpx.
+        """
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            status_code = response.status_code
+            error_data = None
+            try:
+                error_data = response.json()
+            except ValueError:
+                error_data = response.text
+
+            message = ""
+            if isinstance(error_data, dict):
+                message = error_data.get("message") or error_data.get("error") or str(error_data)
+            else:
+                message = str(error_data)
+
+            if status_code in (401, 403):
+                raise AuthenticationError(
+                    f"Authentication failed: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+            elif status_code == 404:
+                raise NotFoundError(
+                    f"Resource not found: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+            else:
+                raise ReactiveResumeAPIError(
+                    f"API error: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+
+        # Success path
+        if response.headers.get("content-type", "").startswith("application/json"):
+            return response.json()
+        return response.content
+
+    async def close(self) -> None:
+        """Close the underlying HTTP client."""
+        await self.client.aclose()
+
+    async def __aenter__(self) -> "AsyncRxResumeClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self.close()

reactive_resume/core/client.py

@@ -0,0 +1,151 @@
+"""Synchronous API Client implementation."""
+
+from typing import Any, Optional
+import httpx
+
+from .exceptions import (
+    ReactiveResumeError,
+    ReactiveResumeAPIError,
+    AuthenticationError,
+    NotFoundError,
+)
+from ..api.auth import AuthAPI
+from ..api.resumes import ResumesAPI
+
+
+class RxResumeClient:
+    """Synchronous client for Reactive Resume v4 API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: Optional[str] = None,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+        verify: bool = True,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            base_url: The base URL of the Reactive Resume instance.
+            api_key: API Key for x-api-key authentication.
+            token: Bearer Token for Authorization authentication.
+            timeout: Request timeout in seconds.
+            verify: Verify SSL certificates.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.verify = verify
+
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "rxresume-python/0.1.0",
+        }
+
+        if api_key:
+            headers["x-api-key"] = api_key
+        elif token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        self.client = httpx.Client(
+            base_url=self.base_url,
+            headers=headers,
+            timeout=self.timeout,
+            verify=self.verify,
+        )
+
+        # Initialize API sections
+        self.auth = AuthAPI(self)
+        self.resumes = ResumesAPI(self)
+
+    def set_token(self, token: str) -> None:
+        """Update client headers with a new Bearer token."""
+        self.client.headers["Authorization"] = f"Bearer {token}"
+        if "x-api-key" in self.client.headers:
+            del self.client.headers["x-api-key"]
+
+    def set_api_key(self, api_key: str) -> None:
+        """Update client headers with a new API key."""
+        self.client.headers["x-api-key"] = api_key
+        if "Authorization" in self.client.headers:
+            del self.client.headers["Authorization"]
+
+    def _request(
+        self,
+        method: str,
+        url: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Perform a synchronous HTTP request and handle errors.
+
+        Args:
+            method: HTTP method (GET, POST, etc.).
+            url: Target URL path (appended to base_url).
+            **kwargs: Extra arguments for httpx request.
+
+        Returns:
+            Decoded JSON response or raw content.
+        """
+        try:
+            response = self.client.request(method, url, **kwargs)
+            return self._handle_response(response)
+        except httpx.HTTPError as e:
+            if not isinstance(e, httpx.HTTPStatusError):
+                raise ReactiveResumeError(f"Network or connection error occurred: {e}") from e
+            raise
+
+    def _handle_response(self, response: httpx.Response) -> Any:
+        """Process response data or raise descriptive exceptions.
+
+        Args:
+            response: Response object from httpx.
+        """
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            status_code = response.status_code
+            error_data = None
+            try:
+                error_data = response.json()
+            except ValueError:
+                error_data = response.text
+
+            message = ""
+            if isinstance(error_data, dict):
+                message = error_data.get("message") or error_data.get("error") or str(error_data)
+            else:
+                message = str(error_data)
+
+            if status_code in (401, 403):
+                raise AuthenticationError(
+                    f"Authentication failed: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+            elif status_code == 404:
+                raise NotFoundError(
+                    f"Resource not found: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+            else:
+                raise ReactiveResumeAPIError(
+                    f"API error: {message}",
+                    status_code=status_code,
+                    response_body=error_data,
+                ) from e
+
+        # Success path
+        if response.headers.get("content-type", "").startswith("application/json"):
+            return response.json()
+        return response.content
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self.client.close()
+
+    def __enter__(self) -> "RxResumeClient":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()

reactive_resume/core/exceptions.py

@@ -0,0 +1,45 @@
+"""Custom exceptions for the Reactive Resume API Client."""
+
+from typing import Optional, Any
+
+
+class ReactiveResumeError(Exception):
+    """Base exception for all Reactive Resume client errors."""
+
+    pass
+
+
+class ValidationError(ReactiveResumeError):
+    """Raised when request data fails client-side validation."""
+
+    pass
+
+
+class ReactiveResumeAPIError(ReactiveResumeError):
+    """Raised when the Reactive Resume API returns an error response."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_body: Optional[Any] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body
+
+    def __str__(self) -> str:
+        code_str = f" [Status {self.status_code}]" if self.status_code else ""
+        return f"{super().__str__()}{code_str}"
+
+
+class AuthenticationError(ReactiveResumeAPIError):
+    """Raised when authentication fails (401/403)."""
+
+    pass
+
+
+class NotFoundError(ReactiveResumeAPIError):
+    """Raised when a requested resource is not found (404)."""
+
+    pass

reactive_resume/models/__init__.py

@@ -0,0 +1,49 @@
+"""Models module for Pydantic schema validation."""
+
+from .user import User
+from .resume import (
+    URLModel,
+    Profile,
+    Basics,
+    Item,
+    WorkItem,
+    EducationItem,
+    ProjectItem,
+    SkillItem,
+    LanguageItem,
+    CertificationItem,
+    AwardItem,
+    InterestItem,
+    ReferenceItem,
+    PublicationItem,
+    VolunteerItem,
+    CustomItem,
+    Section,
+    ResumeData,
+    Resume,
+    ResumeImportData,
+)
+
+__all__ = [
+    "User",
+    "URLModel",
+    "Profile",
+    "Basics",
+    "Item",
+    "WorkItem",
+    "EducationItem",
+    "ProjectItem",
+    "SkillItem",
+    "LanguageItem",
+    "CertificationItem",
+    "AwardItem",
+    "InterestItem",
+    "ReferenceItem",
+    "PublicationItem",
+    "VolunteerItem",
+    "CustomItem",
+    "Section",
+    "ResumeData",
+    "Resume",
+    "ResumeImportData",
+]

reactive_resume/models/resume.py

@@ -0,0 +1,206 @@
+"""Pydantic models representing resume data in Reactive Resume."""
+
+from pydantic import BaseModel, Field, ConfigDict
+from datetime import datetime
+from typing import Optional, List, Dict, Any, Union
+
+
+class URLModel(BaseModel):
+    """Represents a URL structure in Reactive Resume."""
+
+    label: str = ""
+    href: str = ""
+
+
+class Profile(BaseModel):
+    """Represents a social media profile link."""
+
+    id: Optional[str] = None
+    network: str = ""
+    username: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class Basics(BaseModel):
+    """Represents the basic personal information of a candidate."""
+
+    name: str = ""
+    headline: str = ""
+    email: str = ""
+    phone: str = ""
+    website: Union[URLModel, str] = ""
+    location: str = ""
+    picture: str = ""
+    profiles: List[Profile] = Field(default_factory=list)
+
+
+# General item model for list items
+class Item(BaseModel):
+    """Base model for list items within sections."""
+
+    id: str
+    visible: bool = True
+
+
+class WorkItem(Item):
+    """Represents a work experience entry."""
+
+    company: str = ""
+    position: str = ""
+    location: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class EducationItem(Item):
+    """Represents an education entry."""
+
+    institution: str = ""
+    study_type: str = Field("", alias="studyType")
+    area: str = ""
+    score: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class ProjectItem(Item):
+    """Represents a project entry."""
+
+    name: str = ""
+    description: str = ""
+    date: str = ""
+    summary: str = ""
+    keywords: List[str] = Field(default_factory=list)
+    url: Union[URLModel, str] = ""
+
+
+class SkillItem(Item):
+    """Represents a skill entry."""
+
+    name: str = ""
+    description: str = ""
+    level: str = ""
+    keywords: List[str] = Field(default_factory=list)
+
+
+class LanguageItem(Item):
+    """Represents a language entry."""
+
+    name: str = ""
+    description: str = ""
+    level: str = ""
+
+
+class CertificationItem(Item):
+    """Represents a certification entry."""
+
+    name: str = ""
+    issuer: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class AwardItem(Item):
+    """Represents an award or honor entry."""
+
+    title: str = ""
+    awarder: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class InterestItem(Item):
+    """Represents an interest entry."""
+
+    name: str = ""
+    keywords: List[str] = Field(default_factory=list)
+
+
+class ReferenceItem(Item):
+    """Represents a reference entry."""
+
+    name: str = ""
+    relationship: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class PublicationItem(Item):
+    """Represents a publication entry."""
+
+    name: str = ""
+    publisher: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class VolunteerItem(Item):
+    """Represents a volunteer work entry."""
+
+    organization: str = ""
+    position: str = ""
+    location: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+class CustomItem(Item):
+    """Represents a custom item entry in custom sections."""
+
+    title: str = ""
+    subtitle: str = ""
+    date: str = ""
+    summary: str = ""
+    url: Union[URLModel, str] = ""
+
+
+# Section Models
+class Section(BaseModel):
+    """Base schema for a resume section."""
+
+    id: str
+    name: str
+    columns: int = 1
+    visible: bool = True
+    items: List[Any] = Field(default_factory=list)
+
+
+class ResumeData(BaseModel):
+    """Contains all actual resume sections and basic details."""
+
+    basics: Basics = Field(default_factory=Basics)
+    sections: Dict[str, Section] = Field(default_factory=dict)
+
+
+class Resume(BaseModel):
+    """Represents a complete resume object returned by the API."""
+
+    id: str
+    name: str
+    slug: str
+    user_id: str = Field(..., alias="userId")
+    visibility: str = "public"
+    locked: bool = False
+    data: ResumeData
+    created_at: datetime = Field(..., alias="createdAt")
+    updated_at: datetime = Field(..., alias="updatedAt")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class ResumeImportData(BaseModel):
+    """Schema for importing/creating a new resume."""
+
+    title: str = Field(..., description="The name/title of the resume")
+    slug: Optional[str] = Field(None, description="Optional custom URL slug")
+    basics: Optional[Basics] = None
+    sections: Optional[Dict[str, Section]] = None
+    metadata: Optional[Dict[str, Any]] = None

reactive_resume/models/user.py

@@ -0,0 +1,24 @@
+"""Pydantic models representing user accounts in Reactive Resume."""
+
+from pydantic import BaseModel, EmailStr, Field, ConfigDict
+from datetime import datetime
+
+
+class User(BaseModel):
+    """Represents a user account in Reactive Resume."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str = Field(..., description="Unique identifier for the user")
+    name: str = Field(..., description="Full name of the user")
+    username: str = Field(..., description="Username of the user")
+    email: EmailStr = Field(..., description="Email address of the user")
+    provider: str = Field(
+        "email", description="Authentication provider (e.g., email, github, google)"
+    )
+    created_at: datetime = Field(
+        ..., alias="createdAt", description="Timestamp when the user was created"
+    )
+    updated_at: datetime = Field(
+        ..., alias="updatedAt", description="Timestamp when the user was last updated"
+    )

rxresume_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: rxresume-python
+Version: 0.1.0
+Summary: Unofficial Python API client (SDK) for Reactive Resume v4
+Author: Ata Can Yaymacı
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic[email]>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.20.0; extra == "dev"
+Requires-Dist: respx>=0.20.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: bandit>=1.7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# Reactive Resume Python SDK (`rxresume-python`)
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![Pydantic v2](https://img.shields.io/badge/pydantic-v2-red.svg)](https://docs.pydantic.dev/)
+[![HTTPX](https://img.shields.io/badge/http--client-httpx-brightgreen.svg)](https://www.python-httpx.org/)
+
+An unofficial modern, type-safe Python API Client (SDK) for **Reactive Resume v4**.
+
+It supports both synchronous (`httpx.Client`) and asynchronous (`httpx.AsyncClient`) clients, ensures fully typed request/response schemas using **Pydantic v2**, and maps API errors to clean, descriptive Python exceptions.
+
+---
+
+## Features
+
+- **Dual client modes**: Support for both sync and async APIs.
+- **Type safety**: Fully typed models for Resumes, Sections, Basics, and Users using Pydantic V2.
+- **Robust error handling**: Raw API status errors are automatically parsed into specific exceptions (`AuthenticationError`, `NotFoundError`, etc.).
+- **Developer Experience (DX)**: Code-completion ready with clear typing and docstrings.
+
+---
+
+## Installation
+
+Install the package via `pip` or your favorite package manager:
+
+```bash
+pip install rxresume-python
+```
+
+---
+
+## Quick Start
+
+### 1. Asynchronous Client (FastAPI / Asynchronous Code)
+
+```python
+import asyncio
+from reactive_resume import AsyncRxResumeClient
+from reactive_resume.models import ResumeImportData, Basics
+
+async def main():
+    # Initialize the async client
+    async with AsyncRxResumeClient(base_url="https://rxresu.me", api_key="your_api_key") as client:
+        # Create a new resume
+        import_data = ResumeImportData(
+            title="Ata Can Yaymacı - Backend Engineer",
+            basics=Basics(
+                name="Ata Can Yaymacı",
+                headline="Backend Engineer",
+                email="ata@example.com",
+                phone="+905555555555",
+                website="https://example.com"
+            ),
+            sections={}
+        )
+
+        try:
+            # Import/Create a new resume
+            new_resume = await client.resumes.import_resume(import_data)
+            print(f"Created resume: {new_resume.name} (ID: {new_resume.id})")
+
+            # Fetch the generated PDF URL
+            pdf_url = await client.resumes.get_pdf_url(new_resume.id)
+            print(f"PDF URL: {pdf_url}")
+
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### 2. Synchronous Client
+
+```python
+from reactive_resume import RxResumeClient
+from reactive_resume.models import ResumeImportData
+
+with RxResumeClient(base_url="https://rxresu.me", api_key="your_api_key") as client:
+    resumes = client.resumes.list()
+    for resume in resumes:
+        print(f"Resume: {resume.name} (Slug: {resume.slug})")
+```
+
+---
+
+## Error Handling
+
+All client API calls map HTTP errors to specific exception classes:
+
+```python
+from reactive_resume import RxResumeClient, AuthenticationError, NotFoundError
+
+try:
+    with RxResumeClient(base_url="https://rxresu.me", api_key="wrong_key") as client:
+        client.resumes.list()
+except AuthenticationError as e:
+    print(f"Auth error (Status {e.status_code}): {e}")
+except NotFoundError as e:
+    print(f"Not found: {e}")
+except Exception as e:
+    print(f"Generic error: {e}")
+```
+
+---
+
+## Development & Testing
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/your-username/reactive-resume-api-client-py.git
+   cd reactive-resume-api-client-py
+   ```
+
+2. Install dependencies:
+   ```bash
+   python3 -m venv .venv
+   source .venv/bin/activate
+   pip install -e ".[dev]"
+   ```
+
+3. Run the tests:
+   ```bash
+   pytest
+   ```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

rxresume_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+reactive_resume/__init__.py,sha256=F5Ze9bu2L1pwIrtYLnXAXeV6cL2p72xDy5I8qnJQfPM,581
+reactive_resume/api/__init__.py,sha256=t4sq_czaOLuPxyMhnXFoFTAWsr3qidF5i3RTlESRn8M,221
+reactive_resume/api/auth.py,sha256=YkuUjWSOEhxmuY2znOmLf9b2i915I4seNblkk1icBvI,2177
+reactive_resume/api/resumes.py,sha256=fiysbrwWxIccYwSzmuI_5KdrPVSkaPLTTKMf0c-Im4c,5701
+reactive_resume/core/__init__.py,sha256=TXvcDN-AFX5ctGXoaqHck1eoi0jxLLBCh5J-6ySFZe8,343
+reactive_resume/core/async_client.py,sha256=n779xddhVoWhzta3_SdDom0hRPBH5sbH20xR02B5j7Y,4866
+reactive_resume/core/client.py,sha256=XfPqleKefk7A0VxXjSydWIWuwwuPMFdEfzJUrmaf_Ps,4782
+reactive_resume/core/exceptions.py,sha256=cFOPfpmowDu4D5YSLkpnH0brUyTAvwydnwRg1-bpGl4,1124
+reactive_resume/models/__init__.py,sha256=OFiJN0Aep4gKOKn0vVSg6AzMDL8_hvWi3ZazE5ys0u4,819
+reactive_resume/models/resume.py,sha256=BoBkk77v_eEBIrHUCqBiYQrQEsm3VXUtIc1bQpn8hrY,4620
+reactive_resume/models/user.py,sha256=uR8NS0R4Dca63cEh40TjJlrgtDuPmO6TKE6VEvCKTUU,939
+rxresume_python-0.1.0.dist-info/licenses/LICENSE,sha256=Mlna-n1TpPV1TDC0tRQe0QsOMi2-5jTgvnypocbGghw,1073
+rxresume_python-0.1.0.dist-info/METADATA,sha256=_OdWwgUifd71EhyNRen4B1GTZuPkbO8rFnj5xPwTQTg,4647
+rxresume_python-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+rxresume_python-0.1.0.dist-info/top_level.txt,sha256=XqM8_KWS_Y5kNXEG18kAShCVtNwErO1NfCeCZ1u-INo,16
+rxresume_python-0.1.0.dist-info/RECORD,,

rxresume_python-0.1.0.dist-info/WHEEL

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

rxresume_python-0.1.0.dist-info/licenses/LICENSE

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

rxresume_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+reactive_resume