rxresume-python 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

reactive_resume/api/__init__.py

@@ -2,10 +2,28 @@
 
 from .auth import AuthAPI, AsyncAuthAPI
 from .resumes import ResumesAPI, AsyncResumesAPI
+from .statistics import StatisticsAPI, AsyncStatisticsAPI
+from .agent import AgentAPI, AsyncAgentAPI
+from .ai_providers import AiProvidersAPI, AsyncAiProvidersAPI
+from .flags import FlagsAPI, AsyncFlagsAPI
+from .ai import AIAPI, AsyncAIAPI
+from .applications import ApplicationsAPI, AsyncApplicationsAPI
 
 __all__ = [
     "AuthAPI",
     "AsyncAuthAPI",
     "ResumesAPI",
     "AsyncResumesAPI",
+    "StatisticsAPI",
+    "AsyncStatisticsAPI",
+    "AgentAPI",
+    "AsyncAgentAPI",
+    "AiProvidersAPI",
+    "AsyncAiProvidersAPI",
+    "FlagsAPI",
+    "AsyncFlagsAPI",
+    "AIAPI",
+    "AsyncAIAPI",
+    "ApplicationsAPI",
+    "AsyncApplicationsAPI",
 ]

reactive_resume/api/agent.py

@@ -0,0 +1,243 @@
+"""Agent API endpoints implementation."""
+
+from typing import List, Dict, Any, Optional
+
+
+class AgentAPI:
+    """Synchronous AI Agent operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def list_threads(self) -> List[Dict[str, Any]]:
+        """List all active agent threads."""
+        response = self._client._request("GET", "/api/openapi/agent/threads")
+        return list(response)
+
+    def get_thread(self, thread_id: str) -> Dict[str, Any]:
+        """Get details of a specific agent thread by ID."""
+        response = self._client._request("GET", f"/api/openapi/agent/threads/{thread_id}")
+        return dict(response)
+
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete an agent thread by ID."""
+        self._client._request("DELETE", f"/api/openapi/agent/threads/{thread_id}")
+
+    def create_thread(
+        self, ai_provider_id: Optional[str] = None, source_resume_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a new agent thread."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = self._client._request("POST", "/api/openapi/agent/threads", json=payload)
+        return dict(response)
+
+    def get_or_create_thread_for_resume(
+        self, ai_provider_id: Optional[str] = None, source_resume_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Get or create an in-resume agent thread."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = self._client._request(
+            "POST", "/api/openapi/agent/threads/for-resume", json=payload
+        )
+        return dict(response)
+
+    def send_message(
+        self, thread_id: str, message: Any, attachment_ids: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Send an agent message."""
+        payload = {
+            "threadId": thread_id,
+            "message": message,
+        }
+        if attachment_ids is not None:
+            payload["attachmentIds"] = attachment_ids
+        response = self._client._request("POST", "/api/openapi/agent/messages/send", json=payload)
+        return dict(response)
+
+    def archive_thread(
+        self,
+        thread_id: str,
+        ai_provider_id: Optional[str] = None,
+        source_resume_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Archive an agent thread."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = self._client._request(
+            "POST", f"/api/openapi/agent/threads/{thread_id}/archive", json=payload
+        )
+        return dict(response)
+
+    def stop_run(self, thread_id: str, partial_message: Optional[Any] = None) -> Dict[str, Any]:
+        """Stop active agent run."""
+        payload = {
+            "threadId": thread_id,
+        }
+        if partial_message is not None:
+            payload["partialMessage"] = partial_message
+        response = self._client._request("POST", "/api/openapi/agent/messages/stop", json=payload)
+        return dict(response)
+
+    def resume_message_stream(self, thread_id: str) -> Any:
+        """Resume agent message stream."""
+        return self._client._request(
+            "GET", f"/api/openapi/agent/messages/resume?threadId={thread_id}"
+        )
+
+    def create_attachment(
+        self, thread_id: str, filename: str, media_type: str, data: str
+    ) -> Dict[str, Any]:
+        """Create agent attachment."""
+        payload = {
+            "threadId": thread_id,
+            "filename": filename,
+            "mediaType": media_type,
+            "data": data,
+        }
+        response = self._client._request("POST", "/api/openapi/agent/attachments", json=payload)
+        return dict(response)
+
+    def delete_attachment(self, attachment_id: str) -> None:
+        """Delete agent attachment."""
+        self._client._request("DELETE", f"/api/openapi/agent/attachments/{attachment_id}")
+
+    def revert_action(self, action_id: str) -> Dict[str, Any]:
+        """Restore agent action snapshot."""
+        response = self._client._request("POST", f"/api/openapi/agent/actions/{action_id}/revert")
+        return dict(response)
+
+
+class AsyncAgentAPI:
+    """Asynchronous AI Agent operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def list_threads(self) -> List[Dict[str, Any]]:
+        """List all active agent threads asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/agent/threads")
+        return list(response)
+
+    async def get_thread(self, thread_id: str) -> Dict[str, Any]:
+        """Get details of a specific agent thread by ID asynchronously."""
+        response = await self._client._request("GET", f"/api/openapi/agent/threads/{thread_id}")
+        return dict(response)
+
+    async def delete_thread(self, thread_id: str) -> None:
+        """Delete an agent thread by ID asynchronously."""
+        await self._client._request("DELETE", f"/api/openapi/agent/threads/{thread_id}")
+
+    async def create_thread(
+        self, ai_provider_id: Optional[str] = None, source_resume_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a new agent thread asynchronously."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = await self._client._request("POST", "/api/openapi/agent/threads", json=payload)
+        return dict(response)
+
+    async def get_or_create_thread_for_resume(
+        self, ai_provider_id: Optional[str] = None, source_resume_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Get or create an in-resume agent thread asynchronously."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = await self._client._request(
+            "POST", "/api/openapi/agent/threads/for-resume", json=payload
+        )
+        return dict(response)
+
+    async def send_message(
+        self, thread_id: str, message: Any, attachment_ids: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Send an agent message asynchronously."""
+        payload = {
+            "threadId": thread_id,
+            "message": message,
+        }
+        if attachment_ids is not None:
+            payload["attachmentIds"] = attachment_ids
+        response = await self._client._request(
+            "POST", "/api/openapi/agent/messages/send", json=payload
+        )
+        return dict(response)
+
+    async def archive_thread(
+        self,
+        thread_id: str,
+        ai_provider_id: Optional[str] = None,
+        source_resume_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Archive an agent thread asynchronously."""
+        payload = {}
+        if ai_provider_id is not None:
+            payload["aiProviderId"] = ai_provider_id
+        if source_resume_id is not None:
+            payload["sourceResumeId"] = source_resume_id
+        response = await self._client._request(
+            "POST", f"/api/openapi/agent/threads/{thread_id}/archive", json=payload
+        )
+        return dict(response)
+
+    async def stop_run(
+        self, thread_id: str, partial_message: Optional[Any] = None
+    ) -> Dict[str, Any]:
+        """Stop active agent run asynchronously."""
+        payload = {
+            "threadId": thread_id,
+        }
+        if partial_message is not None:
+            payload["partialMessage"] = partial_message
+        response = await self._client._request(
+            "POST", "/api/openapi/agent/messages/stop", json=payload
+        )
+        return dict(response)
+
+    async def resume_message_stream(self, thread_id: str) -> Any:
+        """Resume agent message stream asynchronously."""
+        return await self._client._request(
+            "GET", f"/api/openapi/agent/messages/resume?threadId={thread_id}"
+        )
+
+    async def create_attachment(
+        self, thread_id: str, filename: str, media_type: str, data: str
+    ) -> Dict[str, Any]:
+        """Create agent attachment asynchronously."""
+        payload = {
+            "threadId": thread_id,
+            "filename": filename,
+            "mediaType": media_type,
+            "data": data,
+        }
+        response = await self._client._request(
+            "POST", "/api/openapi/agent/attachments", json=payload
+        )
+        return dict(response)
+
+    async def delete_attachment(self, attachment_id: str) -> None:
+        """Delete agent attachment asynchronously."""
+        await self._client._request("DELETE", f"/api/openapi/agent/attachments/{attachment_id}")
+
+    async def revert_action(self, action_id: str) -> Dict[str, Any]:
+        """Restore agent action snapshot asynchronously."""
+        response = await self._client._request(
+            "POST", f"/api/openapi/agent/actions/{action_id}/revert"
+        )
+        return dict(response)

reactive_resume/api/ai.py

@@ -0,0 +1,89 @@
+"""AI API endpoints implementation."""
+
+from typing import Dict, Any
+
+
+class AIAPI:
+    """Synchronous AI operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def parse_pdf(self, file_name: str, file_data: str, provider_id: str) -> Dict[str, Any]:
+        """Parse a PDF file into resume data.
+
+        Args:
+            file_name: Name of the file.
+            file_data: Base64 or binary data representation.
+            provider_id: The ID of the configured AI provider.
+        """
+        payload = {
+            "file": {"name": file_name, "data": file_data},
+            "aiProviderId": provider_id,
+        }
+        response = self._client._request("POST", "/api/openapi/ai/parse-pdf", json=payload)
+        return dict(response)
+
+    def parse_docx(self, file_name: str, file_data: str, provider_id: str) -> Dict[str, Any]:
+        """Parse a DOCX file into resume data."""
+        payload = {
+            "file": {"name": file_name, "data": file_data},
+            "aiProviderId": provider_id,
+        }
+        response = self._client._request("POST", "/api/openapi/ai/parse-docx", json=payload)
+        return dict(response)
+
+    def chat(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Chat with AI to modify resume."""
+        response = self._client._request("POST", "/api/openapi/ai/chat", json=payload)
+        return dict(response)
+
+    def analyze_resume(self, resume_id: str, provider_id: str) -> Dict[str, Any]:
+        """Analyze a resume and persist the latest analysis."""
+        payload = {
+            "resumeId": resume_id,
+            "aiProviderId": provider_id,
+        }
+        response = self._client._request("POST", "/api/openapi/ai/analyze-resume", json=payload)
+        return dict(response)
+
+
+class AsyncAIAPI:
+    """Asynchronous AI operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def parse_pdf(self, file_name: str, file_data: str, provider_id: str) -> Dict[str, Any]:
+        """Parse a PDF file into resume data asynchronously."""
+        payload = {
+            "file": {"name": file_name, "data": file_data},
+            "aiProviderId": provider_id,
+        }
+        response = await self._client._request("POST", "/api/openapi/ai/parse-pdf", json=payload)
+        return dict(response)
+
+    async def parse_docx(self, file_name: str, file_data: str, provider_id: str) -> Dict[str, Any]:
+        """Parse a DOCX file into resume data asynchronously."""
+        payload = {
+            "file": {"name": file_name, "data": file_data},
+            "aiProviderId": provider_id,
+        }
+        response = await self._client._request("POST", "/api/openapi/ai/parse-docx", json=payload)
+        return dict(response)
+
+    async def chat(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Chat with AI asynchronously to modify resume."""
+        response = await self._client._request("POST", "/api/openapi/ai/chat", json=payload)
+        return dict(response)
+
+    async def analyze_resume(self, resume_id: str, provider_id: str) -> Dict[str, Any]:
+        """Analyze a resume asynchronously and persist the latest analysis."""
+        payload = {
+            "resumeId": resume_id,
+            "aiProviderId": provider_id,
+        }
+        response = await self._client._request(
+            "POST", "/api/openapi/ai/analyze-resume", json=payload
+        )
+        return dict(response)

reactive_resume/api/ai_providers.py

@@ -0,0 +1,89 @@
+"""AI Providers API endpoints implementation."""
+
+from typing import List, Dict, Any
+
+
+class AiProvidersAPI:
+    """Synchronous AI Providers operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def list(self) -> List[Dict[str, Any]]:
+        """List all configured AI Providers."""
+        response = self._client._request("GET", "/api/openapi/ai-providers")
+        if isinstance(response, list):
+            return response
+        return [response]
+
+    def create(self, label: str, model: str, api_key: str, base_url: str = "") -> Dict[str, Any]:
+        """Create a new AI provider configuration."""
+        payload = {
+            "label": label,
+            "model": model,
+            "apiKey": api_key,
+            "baseURL": base_url,
+        }
+        response = self._client._request("POST", "/api/openapi/ai-providers", json=payload)
+        return dict(response)
+
+    def delete(self, provider_id: str) -> None:
+        """Delete an AI provider configuration."""
+        self._client._request("DELETE", f"/api/openapi/ai-providers/{provider_id}")
+
+    def test(self, provider_id: str) -> bool:
+        """Test the connection of a saved AI provider."""
+        response = self._client._request("POST", f"/api/openapi/ai-providers/{provider_id}/test")
+        return bool(response.get("success", True))
+
+    def update(self, provider_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an AI provider configuration."""
+        response = self._client._request(
+            "PATCH", f"/api/openapi/ai-providers/{provider_id}", json=data
+        )
+        return dict(response)
+
+
+class AsyncAiProvidersAPI:
+    """Asynchronous AI Providers operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def list(self) -> List[Dict[str, Any]]:
+        """List all configured AI Providers asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/ai-providers")
+        if isinstance(response, list):
+            return response
+        return [response]
+
+    async def create(
+        self, label: str, model: str, api_key: str, base_url: str = ""
+    ) -> Dict[str, Any]:
+        """Create a new AI provider configuration asynchronously."""
+        payload = {
+            "label": label,
+            "model": model,
+            "apiKey": api_key,
+            "baseURL": base_url,
+        }
+        response = await self._client._request("POST", "/api/openapi/ai-providers", json=payload)
+        return dict(response)
+
+    async def delete(self, provider_id: str) -> None:
+        """Delete an AI provider configuration asynchronously."""
+        await self._client._request("DELETE", f"/api/openapi/ai-providers/{provider_id}")
+
+    async def test(self, provider_id: str) -> bool:
+        """Test the connection of a saved AI provider asynchronously."""
+        response = await self._client._request(
+            "POST", f"/api/openapi/ai-providers/{provider_id}/test"
+        )
+        return bool(response.get("success", True))
+
+    async def update(self, provider_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update an AI provider configuration asynchronously."""
+        response = await self._client._request(
+            "PATCH", f"/api/openapi/ai-providers/{provider_id}", json=data
+        )
+        return dict(response)

reactive_resume/api/applications.py

@@ -0,0 +1,100 @@
+"""Applications API endpoints implementation."""
+
+from typing import List, Dict, Any
+from ..models.application import Application, ApplicationCreate
+
+
+class ApplicationsAPI:
+    """Synchronous Job Applications operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def list(self) -> List[Application]:
+        """List all job applications."""
+        response = self._client._request("GET", "/api/openapi/applications")
+        if isinstance(response, dict) and "data" in response:
+            items = response["data"]
+        else:
+            items = response
+        return [Application.model_validate(item) for item in items]
+
+    def get(self, app_id: str) -> Application:
+        """Retrieve a specific job application by ID."""
+        response = self._client._request("GET", f"/api/openapi/applications/{app_id}")
+        return Application.model_validate(response)
+
+    def create(self, data: ApplicationCreate) -> Application:
+        """Log/create a new job application."""
+        payload = data.model_dump(by_alias=True, exclude_none=True)
+        response = self._client._request("POST", "/api/openapi/applications", json=payload)
+        return Application.model_validate(response)
+
+    def delete(self, app_id: str) -> None:
+        """Delete a job application by ID."""
+        self._client._request("DELETE", f"/api/openapi/applications/{app_id}")
+
+    def list_tags(self) -> List[str]:
+        """List all application tags."""
+        response = self._client._request("GET", "/api/openapi/applications/tags")
+        return list(response)
+
+    def get_pipeline_stats(self) -> Dict[str, Any]:
+        """Get application pipeline statistics."""
+        response = self._client._request("GET", "/api/openapi/applications/stats")
+        return dict(response)
+
+    def bulk_import(self, items: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Bulk import job applications."""
+        payload = {"items": items}
+        response = self._client._request("POST", "/api/openapi/applications/import", json=payload)
+        return dict(response)
+
+
+class AsyncApplicationsAPI:
+    """Asynchronous Job Applications operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def list(self) -> List[Application]:
+        """List all job applications asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/applications")
+        if isinstance(response, dict) and "data" in response:
+            items = response["data"]
+        else:
+            items = response
+        return [Application.model_validate(item) for item in items]
+
+    async def get(self, app_id: str) -> Application:
+        """Retrieve a specific job application by ID asynchronously."""
+        response = await self._client._request("GET", f"/api/openapi/applications/{app_id}")
+        return Application.model_validate(response)
+
+    async def create(self, data: ApplicationCreate) -> Application:
+        """Log/create a new job application asynchronously."""
+        payload = data.model_dump(by_alias=True, exclude_none=True)
+        response = await self._client._request("POST", "/api/openapi/applications", json=payload)
+        return Application.model_validate(response)
+
+    async def delete(self, app_id: str) -> None:
+        """Delete a job application by ID asynchronously."""
+        await self._client._request("DELETE", f"/api/openapi/applications/{app_id}")
+
+    async def list_tags(self) -> List[str]:
+        """List all application tags asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/applications/tags")
+        return list(response)
+
+    async def get_pipeline_stats(self) -> Dict[str, Any]:
+        """Get application pipeline statistics asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/applications/stats")
+        return dict(response)
+
+    async def bulk_import(self, items: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Bulk import job applications asynchronously."""
+        payload = {"items": items}
+        response = await self._client._request(
+            "POST", "/api/openapi/applications/import", json=payload
+        )
+        return dict(response)

reactive_resume/api/auth.py

@@ -1,7 +1,6 @@
 """Authentication endpoints implementation."""
 
-from typing import Tuple
-from ..models.user import User
+from typing import List, Dict, Any
 
 
 class AuthAPI:
@@ -10,30 +9,19 @@ class AuthAPI:
     def __init__(self, client) -> None:
         self._client = client
 
-    def login(self, email: str, password: str) -> Tuple[str, User]:
-        """Log in with email and password.
+    def list_providers(self) -> List[str]:
+        """List all configured authentication providers."""
+        response = self._client._request("GET", "/api/openapi/auth/providers")
+        return list(response)
 
-        Args:
-            email: User's email.
-            password: User's password.
+    def export_account(self) -> Dict[str, Any]:
+        """Export user account data."""
+        response = self._client._request("GET", "/api/openapi/auth/account/export")
+        return dict(response)
 
-        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)
+    def delete_account(self) -> None:
+        """Delete user account."""
+        self._client._request("DELETE", "/api/openapi/auth/account")
 
 
 class AsyncAuthAPI:
@@ -42,25 +30,16 @@ class AsyncAuthAPI:
     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)
+    async def list_providers(self) -> List[str]:
+        """List all configured authentication providers asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/auth/providers")
+        return list(response)
 
-        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 export_account(self) -> Dict[str, Any]:
+        """Export user account data asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/auth/account/export")
+        return dict(response)
 
-    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)
+    async def delete_account(self) -> None:
+        """Delete user account asynchronously."""
+        await self._client._request("DELETE", "/api/openapi/auth/account")

reactive_resume/api/flags.py

@@ -0,0 +1,27 @@
+"""Flags API endpoints implementation."""
+
+from typing import Dict, Any
+
+
+class FlagsAPI:
+    """Synchronous Flags operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    def list(self) -> Dict[str, Any]:
+        """List all available feature flags."""
+        response = self._client._request("GET", "/api/openapi/flags")
+        return dict(response)
+
+
+class AsyncFlagsAPI:
+    """Asynchronous Flags operations."""
+
+    def __init__(self, client) -> None:
+        self._client = client
+
+    async def list(self) -> Dict[str, Any]:
+        """List all available feature flags asynchronously."""
+        response = await self._client._request("GET", "/api/openapi/flags")
+        return dict(response)