aiondtech 2.0.0__py3-none-any.whl

aiondtech/models.py

@@ -0,0 +1,428 @@
+"""
+Data models and exceptions for the AiondTech SDK v2.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+
+# ============================================================================
+# EXCEPTIONS
+# ============================================================================
+
+class APIError(Exception):
+    """Base exception for all API errors."""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response: Optional[Dict[str, Any]] = None
+    ):
+        self.message = message
+        self.status_code = status_code
+        self.response = response or {}
+        super().__init__(self.message)
+    
+    def __str__(self):
+        if self.status_code:
+            return f"[{self.status_code}] {self.message}"
+        return self.message
+
+
+class AuthenticationError(APIError):
+    """Raised when API key is invalid or missing."""
+    pass
+
+
+class RateLimitError(APIError):
+    """Raised when rate limit is exceeded."""
+    
+    def __init__(
+        self,
+        message: str = "Rate limit exceeded",
+        retry_after: Optional[int] = None,
+        **kwargs
+    ):
+        self.retry_after = retry_after
+        super().__init__(message, **kwargs)
+
+
+class ValidationError(APIError):
+    """Raised when request validation fails."""
+    pass
+
+
+class NotFoundError(APIError):
+    """Raised when a resource is not found."""
+    pass
+
+
+class InsufficientCreditsError(APIError):
+    """Raised when user has insufficient API credits."""
+    
+    def __init__(
+        self,
+        message: str = "Insufficient API credits",
+        credits_remaining: int = 0,
+        credits_required: int = 0,
+        **kwargs
+    ):
+        self.credits_remaining = credits_remaining
+        self.credits_required = credits_required
+        super().__init__(message, **kwargs)
+
+
+# ============================================================================
+# RESPONSE MODELS
+# ============================================================================
+
+@dataclass
+class ResumeUploadResult:
+    """Result from uploading a resume (upload only, no parsing)."""
+    resume_id: int
+    message: str
+    credits_used: int = 1
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "ResumeUploadResult":
+        return cls(
+            resume_id=data.get("resume_id"),
+            message=data.get("message", "Resume uploaded successfully"),
+            credits_used=data.get("credits_used", 1),
+            _raw=data
+        )
+    
+    def __repr__(self):
+        return f"<ResumeUploadResult resume_id={self.resume_id}>"
+
+
+@dataclass
+class ResumeAnalysisResult:
+    """Result from uploading and analyzing a resume."""
+    resume_id: int
+    parsed_data: Dict[str, Any]
+    credits_used: int = 3
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "ResumeAnalysisResult":
+        return cls(
+            resume_id=data.get("resume_id"),
+            parsed_data=data.get("parsed_data", {}),
+            credits_used=data.get("credits_used", 3),
+            _raw=data
+        )
+    
+    @property
+    def full_name(self) -> Optional[str]:
+        return self.parsed_data.get("full_name")
+    
+    @property
+    def email(self) -> Optional[str]:
+        return self.parsed_data.get("email")
+    
+    @property
+    def skills(self) -> List[str]:
+        skills = self.parsed_data.get("skills", [])
+        if isinstance(skills, str):
+            return [s.strip() for s in skills.split(",") if s.strip()]
+        return skills or []
+    
+    @property
+    def job_titles(self) -> List[str]:
+        titles = self.parsed_data.get("job_titles", [])
+        if isinstance(titles, str):
+            return [t.strip() for t in titles.split(",") if t.strip()]
+        return titles or []
+    
+    @property
+    def total_experience(self) -> Optional[str]:
+        return self.parsed_data.get("total_experience")
+    
+    def __repr__(self):
+        name = self.full_name or "Unknown"
+        return f"<ResumeAnalysisResult resume_id={self.resume_id} name='{name}'>"
+
+
+@dataclass
+class ResumeComparisonResult:
+    """Result from comparing a resume to a job posting."""
+    resume_id: int
+    job_id: int
+    comparison_score: float
+    comparison_reason: str
+    parsed_data: Optional[Dict[str, Any]] = None
+    matched_keywords: List[str] = field(default_factory=list)
+    missing_keywords: List[str] = field(default_factory=list)
+    suggestions: List[str] = field(default_factory=list)
+    credits_used: int = 3
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "ResumeComparisonResult":
+        return cls(
+            resume_id=data.get("resume_id"),
+            job_id=data.get("job_id"),
+            comparison_score=data.get("comparison_score", 0) or data.get("ats_score", 0),
+            comparison_reason=data.get("comparison_reason", "") or data.get("reason", ""),
+            parsed_data=data.get("parsed_data"),
+            matched_keywords=data.get("matched_keywords", []),
+            missing_keywords=data.get("missing_keywords", []),
+            suggestions=data.get("suggestions", []),
+            credits_used=data.get("credits_used", 3),
+            _raw=data
+        )
+    
+    @property
+    def is_good_match(self) -> bool:
+        """Returns True if score is 70% or higher."""
+        return self.comparison_score >= 70
+    
+    @property
+    def match_level(self) -> str:
+        """Returns match level: 'excellent', 'good', 'fair', 'poor'."""
+        if self.comparison_score >= 85:
+            return "excellent"
+        elif self.comparison_score >= 70:
+            return "good"
+        elif self.comparison_score >= 50:
+            return "fair"
+        return "poor"
+    
+    def __repr__(self):
+        return f"<ResumeComparisonResult resume_id={self.resume_id} score={self.comparison_score}%>"
+
+
+@dataclass
+class JobResult:
+    """Result from creating a job posting."""
+    job_id: int
+    title: str
+    description: str
+    created_by: str
+    created_at: Optional[str] = None
+    credits_used: int = 1
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "JobResult":
+        return cls(
+            job_id=data.get("job_id"),
+            title=data.get("title", ""),
+            description=data.get("description", ""),
+            created_by=data.get("created_by", ""),
+            created_at=data.get("created_at"),
+            credits_used=data.get("credits_used", 1),
+            _raw=data
+        )
+    
+    def __repr__(self):
+        return f"<JobResult job_id={self.job_id} title='{self.title}'>"
+
+
+@dataclass
+class ParsedResumeResult:
+    """Result from parsing/analyzing a resume by ID."""
+    resume_id: int
+    partner: str
+    parsed_data: Dict[str, Any]
+    credits_used: int = 2
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "ParsedResumeResult":
+        return cls(
+            resume_id=data.get("resume_id"),
+            partner=data.get("partner", ""),
+            parsed_data=data.get("parsed_data", {}),
+            credits_used=data.get("credits_used", 2),
+            _raw=data
+        )
+    
+    @property
+    def full_name(self) -> Optional[str]:
+        return self.parsed_data.get("full_name")
+    
+    @property
+    def email(self) -> Optional[str]:
+        return self.parsed_data.get("email")
+    
+    @property
+    def phone(self) -> Optional[str]:
+        return self.parsed_data.get("contact_number")
+    
+    @property
+    def linkedin(self) -> Optional[str]:
+        return self.parsed_data.get("linkedin")
+    
+    @property
+    def location(self) -> Optional[str]:
+        return self.parsed_data.get("location")
+    
+    @property
+    def skills(self) -> List[str]:
+        skills = self.parsed_data.get("skills", [])
+        if isinstance(skills, str):
+            return [s.strip() for s in skills.split(",") if s.strip()]
+        return skills or []
+    
+    @property
+    def job_titles(self) -> List[str]:
+        titles = self.parsed_data.get("job_titles", [])
+        if isinstance(titles, str):
+            return [t.strip() for t in titles.split(",") if t.strip()]
+        return titles or []
+    
+    @property
+    def companies(self) -> List[str]:
+        companies = self.parsed_data.get("companies", [])
+        if isinstance(companies, str):
+            return [c.strip() for c in companies.split(",") if c.strip()]
+        return companies or []
+    
+    @property
+    def education(self) -> List[str]:
+        edu = self.parsed_data.get("education", [])
+        if isinstance(edu, str):
+            return [e.strip() for e in edu.split(",") if e.strip()]
+        return edu or []
+    
+    @property
+    def total_experience(self) -> Optional[str]:
+        return self.parsed_data.get("total_experience")
+    
+    @property
+    def certifications(self) -> List[str]:
+        certs = self.parsed_data.get("certifications", [])
+        if isinstance(certs, str):
+            return [c.strip() for c in certs.split(",") if c.strip()]
+        return certs or []
+    
+    def __repr__(self):
+        name = self.full_name or "Unknown"
+        return f"<ParsedResumeResult resume_id={self.resume_id} name='{name}'>"
+
+
+@dataclass
+class ResumeListItem:
+    """Single resume in a list."""
+    id: int
+    filename: str
+    full_name: Optional[str] = None
+    email: Optional[str] = None
+    uploaded_at: Optional[str] = None
+    is_parsed: bool = False
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ResumeListItem":
+        return cls(
+            id=data.get("id"),
+            filename=data.get("filename", ""),
+            full_name=data.get("full_name"),
+            email=data.get("email"),
+            uploaded_at=data.get("uploaded_at"),
+            is_parsed=data.get("is_parsed", False)
+        )
+
+
+@dataclass
+class ResumeListResult:
+    """Result from listing resumes."""
+    resumes: List[Dict[str, Any]]
+    total: int
+    page: int
+    limit: int
+    has_more: bool
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "ResumeListResult":
+        return cls(
+            resumes=data.get("resumes", []),
+            total=data.get("total", 0),
+            page=data.get("page", 1),
+            limit=data.get("limit", 50),
+            has_more=data.get("has_more", False),
+            _raw=data
+        )
+    
+    def __len__(self):
+        return len(self.resumes)
+    
+    def __iter__(self):
+        return iter(self.resumes)
+    
+    def __repr__(self):
+        return f"<ResumeListResult count={len(self.resumes)} total={self.total}>"
+
+
+@dataclass
+class JobListItem:
+    """Single job in a list."""
+    id: int
+    title: str
+    description: str
+    created_at: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "JobListItem":
+        return cls(
+            id=data.get("id"),
+            title=data.get("title", ""),
+            description=data.get("description", ""),
+            created_at=data.get("created_at")
+        )
+
+
+@dataclass
+class JobListResult:
+    """Result from listing jobs."""
+    jobs: List[Dict[str, Any]]
+    total: int
+    page: int
+    limit: int
+    has_more: bool
+    _raw: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "JobListResult":
+        return cls(
+            jobs=data.get("jobs", []),
+            total=data.get("total", 0),
+            page=data.get("page", 1),
+            limit=data.get("limit", 50),
+            has_more=data.get("has_more", False),
+            _raw=data
+        )
+    
+    def __len__(self):
+        return len(self.jobs)
+    
+    def __iter__(self):
+        return iter(self.jobs)
+    
+    def __repr__(self):
+        return f"<JobListResult count={len(self.jobs)} total={self.total}>"
+
+
+@dataclass
+class CreditBalance:
+    """Credit balance information."""
+    total: int
+    used_mtd: int
+    remaining: int
+    plan_name: str
+    resets_at: Optional[str] = None
+    
+    @classmethod
+    def from_response(cls, data: Dict[str, Any]) -> "CreditBalance":
+        return cls(
+            total=data.get("total", 0),
+            used_mtd=data.get("used_mtd", 0),
+            remaining=data.get("remaining", 0),
+            plan_name=data.get("plan_name", ""),
+            resets_at=data.get("resets_at")
+        )

aiondtech-2.0.0.dist-info/METADATA

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: aiondtech
+Version: 2.0.0
+Summary: Official Python SDK for AiondTech Resume Analyser API
+Author-email: AiondTech <support@aiondtech.com>
+Maintainer-email: AiondTech <support@aiondtech.com>
+License: MIT
+Project-URL: Homepage, https://aiondtech.com
+Project-URL: Documentation, https://docs.aiondtech.com
+Project-URL: Repository, https://github.com/aiondtech/aiondtech-python
+Project-URL: Bug Tracker, https://github.com/aiondtech/aiondtech-python/issues
+Project-URL: Changelog, https://github.com/aiondtech/aiondtech-python/blob/main/CHANGELOG.md
+Keywords: aiondtech,resume,cv,parser,analyzer,ats,recruitment,hr,api,sdk
+Classifier: Development Status :: 5 - Production/Stable
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Spreadsheet
+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.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# AiondTech Resume Analyser SDK
+
+Official Python SDK for the [AiondTech Resume Analyser API](https://aiondtech.com).
+
+[![PyPI version](https://badge.fury.io/py/aiondtech.svg)](https://badge.fury.io/py/aiondtech)
+[![Python Versions](https://img.shields.io/pypi/pyversions/aiondtech.svg)](https://pypi.org/project/aiondtech/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install aiondtech
+```
+
+## Quick Start
+
+```python
+from aiondtech import ResumeAnalyser
+
+# Initialize client
+client = ResumeAnalyser(api_key="your-api-key")
+
+# Or use environment variable
+# export AIONDTECH_API_KEY="your-api-key"
+client = ResumeAnalyser()
+
+# Upload a resume (1 credit)
+result = client.resumes.upload("resume.pdf")
+print(f"Resume ID: {result.resume_id}")
+
+# Upload and analyze (3 credits)
+analysis = client.resumes.upload_and_analyze("resume.pdf")
+print(f"Name: {analysis.full_name}")
+print(f"Skills: {analysis.skills}")
+
+# Create a job posting (1 credit)
+job = client.jobs.create(
+    title="Senior Python Developer",
+    description="We are looking for an experienced Python developer..."
+)
+print(f"Job ID: {job.job_id}")
+
+# Compare resume to job (3 credits)
+comparison = client.matching.compare(
+    resume_id=result.resume_id,
+    job_id=job.job_id
+)
+print(f"Match Score: {comparison.comparison_score}%")
+print(f"Reason: {comparison.comparison_reason}")
+
+# Check credit balance (free)
+balance = client.credits.balance()
+print(f"Remaining: {balance['remaining_credits']}")
+```
+
+## API Endpoints
+
+| Method | Endpoint | Credits | Description |
+|--------|----------|---------|-------------|
+| `resumes.upload()` | POST /external/upload-resume | 1 | Upload PDF |
+| `resumes.upload_and_analyze()` | POST /external/upload-resume-analyze | 3 | Upload + AI parsing |
+| `resumes.upload_analyze_compare()` | POST /external/upload-resume-analyze-compare | 5 | Upload + parse + compare |
+| `resumes.analyze()` | POST /external/analyze-resume-by-id | 2 | Parse existing resume |
+| `resumes.list()` | GET /external/list-resumes | 0 | List all resumes |
+| `jobs.create()` | POST /external/create-job | 1 | Create job posting |
+| `jobs.list()` | GET /external/list-jobs | 0 | List all jobs |
+| `matching.compare()` | POST /external/compare-resumes | 3 | Compare resume to job |
+| `credits.balance()` | GET /external/credits/balance | 0 | Check balance |
+| `credits.usage()` | GET /external/credits/usage | 0 | View history |
+
+## Detailed Examples
+
+### Upload and Analyze Resume
+
+```python
+from aiondtech import ResumeAnalyser
+
+client = ResumeAnalyser(api_key="your-api-key")
+
+# Upload and get structured data
+analysis = client.resumes.upload_and_analyze("john_doe_resume.pdf")
+
+print(f"Name: {analysis.full_name}")
+print(f"Email: {analysis.email}")
+print(f"Skills: {', '.join(analysis.skills)}")
+print(f"Experience: {analysis.total_experience}")
+print(f"Job Titles: {', '.join(analysis.job_titles)}")
+
+# Access raw parsed data
+print(analysis.parsed_data)
+```
+
+### Full Recruitment Workflow
+
+```python
+from aiondtech import ResumeAnalyser
+
+client = ResumeAnalyser(api_key="your-api-key")
+
+# 1. Create a job posting
+job = client.jobs.create(
+    title="Senior Python Developer",
+    description="""
+    Requirements:
+    - 5+ years Python experience
+    - FastAPI or Django expertise
+    - PostgreSQL knowledge
+    - AWS experience preferred
+    """
+)
+
+# 2. Upload and compare multiple resumes
+resumes = ["candidate1.pdf", "candidate2.pdf", "candidate3.pdf"]
+results = []
+
+for resume_path in resumes:
+    result = client.resumes.upload_analyze_compare(
+        file_path=resume_path,
+        job_id=job.job_id
+    )
+    results.append({
+        "resume_id": result.resume_id,
+        "name": result.parsed_data.get("full_name"),
+        "score": result.comparison_score,
+        "matched": result.matched_keywords,
+        "missing": result.missing_keywords
+    })
+
+# 3. Rank candidates by score
+ranked = sorted(results, key=lambda x: x["score"], reverse=True)
+
+for i, candidate in enumerate(ranked, 1):
+    print(f"{i}. {candidate['name']} - {candidate['score']}% match")
+```
+
+### Error Handling
+
+```python
+from aiondtech import (
+    ResumeAnalyser,
+    AuthenticationError,
+    RateLimitError,
+    InsufficientCreditsError,
+    ValidationError,
+    NotFoundError,
+)
+
+client = ResumeAnalyser(api_key="your-api-key")
+
+try:
+    result = client.resumes.upload_and_analyze("resume.pdf")
+except AuthenticationError:
+    print("Invalid API key")
+except InsufficientCreditsError as e:
+    print(f"Not enough credits. Remaining: {e.credits_remaining}")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Invalid input: {e.message}")
+except NotFoundError:
+    print("Resource not found")
+```
+
+### Using Environment Variables
+
+```bash
+# Set your API key
+export AIONDTECH_API_KEY="your-api-key"
+
+# Optional: Use production URL
+export AIONDTECH_BASE_URL="https://api.aiondtech.com"
+```
+
+```python
+from aiondtech import ResumeAnalyser
+
+# Client automatically uses environment variables
+client = ResumeAnalyser()
+```
+
+### Production vs Development
+
+```python
+from aiondtech import ResumeAnalyser
+
+# Development (default)
+client = ResumeAnalyser(api_key="your-key")
+# Uses: https://api.dev.aiondtech.com
+
+# Production
+client = ResumeAnalyser(api_key="your-key", production=True)
+# Uses: https://api.aiondtech.com
+
+# Custom URL
+client = ResumeAnalyser(api_key="your-key", base_url="https://custom.api.com")
+```
+
+## Response Models
+
+All API responses are converted to typed Python objects:
+
+```python
+# ResumeUploadResult
+result.resume_id      # int
+result.message        # str
+result.credits_used   # int
+
+# ResumeAnalysisResult
+analysis.resume_id    # int
+analysis.parsed_data  # dict
+analysis.full_name    # str (shortcut)
+analysis.email        # str (shortcut)
+analysis.skills       # List[str] (shortcut)
+
+# ResumeComparisonResult
+comparison.resume_id         # int
+comparison.job_id            # int
+comparison.comparison_score  # float (0-100)
+comparison.comparison_reason # str
+comparison.matched_keywords  # List[str]
+comparison.missing_keywords  # List[str]
+comparison.is_good_match     # bool (score >= 70)
+comparison.match_level       # str ("excellent", "good", "fair", "poor")
+
+# JobResult
+job.job_id       # int
+job.title        # str
+job.description  # str
+job.created_at   # str
+```
+
+## Rate Limits
+
+| Tier | Per Minute | Per Day |
+|------|------------|---------|
+| Starter | 50 | 500 |
+| Growth | 100 | 1,000 |
+| Enterprise | 500 | Unlimited |
+
+## Support
+
+- **Documentation**: [https://docs.aiondtech.com](https://docs.aiondtech.com)
+- **API Reference**: [https://api.aiondtech.com/docs](https://api.aiondtech.com/docs)
+- **Email**: support@aiondtech.com
+- **Issues**: [GitHub Issues](https://github.com/aiondtech/aiondtech-python/issues)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.