careerlm 1.0.0__tar.gz

careerlm-1.0.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: careerlm
+Version: 1.0.0
+Summary: Official Python SDK for the CareerLM API — world's first career intelligence API
+Home-page: https://careerstudiomax.com/api/docs
+Author: Career Studio
+Author-email: api@careerstudiomax.com
+Project-URL: Documentation, https://careerstudiomax.com/api/docs
+Project-URL: Source, https://github.com/owolat4real/career-studio
+Project-URL: Bug Tracker, https://github.com/owolat4real/career-studio/issues
+Keywords: career,ai,cv,resume,salary,api,careerlm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CareerLM Python SDK
+
+Official Python client for the [CareerLM API](https://careerstudiomax.com/api/docs) — world's first career intelligence API.
+
+## Install
+
+```bash
+pip install careerlm
+```
+
+## Quickstart
+
+```python
+from careerlm import CareerLM
+
+client = CareerLM(api_key="csk_live_v1_your_key_here")
+
+score = client.cv.score(cv_text, job_description)
+print(score["ats_score"])   # 87
+print(score["grade"])       # "B+"
+```
+
+## What you can do
+
+| Method | Description |
+|---|---|
+| `client.cv.score(cv_text, job_description)` | Score a CV against a job description |
+| `client.cv.optimise(cv_text, job_description)` | Rewrite and optimise a CV for a target role |
+| `client.salary.benchmark(role, country)` | Salary benchmarking across 196 countries, PPP-adjusted |
+| `client.cover_letter.generate(cv_text, job_description, mode=1)` | Generate a cover letter in one of 15 professional modes |
+| `client.job.match(candidate, job)` | Score how well a candidate matches a job |
+| `client.interview.questions(role)` | Tailored interview questions with model answers |
+| `client.skills.gap(current_skills, target_role)` | Skill-gap analysis with learning ROI and timeline |
+| `client.chat.completions.create(messages)` | OpenAI-compatible career chat completions |
+| `client.context.save(profile)` / `.get(id)` / `.delete(id)` | Persistent career context across calls |
+
+## Example: salary benchmark
+
+```python
+salary = client.salary.benchmark("Data Engineer", "NG", city="Lagos", currency="NGN")
+print(salary["salary_range"]["median"])   # 6800000
+```
+
+## Example: cover letter
+
+```python
+letter = client.cover_letter.generate(
+    cv_text, job_description,
+    mode=5, company_name="Paystack", tone="confident",
+)
+print(letter["content"])
+```
+
+## Errors
+
+```python
+from careerlm import CareerLM, CareerLMError
+
+try:
+    client.cv.score(cv_text, job_description)
+except CareerLMError as e:
+    print(e.code, e.status, str(e))
+```
+
+## Context manager
+
+```python
+with CareerLM(api_key="...") as client:
+    ...
+```
+
+Full endpoint reference: [careerstudiomax.com/api/docs](https://careerstudiomax.com/api/docs)

careerlm-1.0.0/README.md

@@ -0,0 +1,72 @@
+# CareerLM Python SDK
+
+Official Python client for the [CareerLM API](https://careerstudiomax.com/api/docs) — world's first career intelligence API.
+
+## Install
+
+```bash
+pip install careerlm
+```
+
+## Quickstart
+
+```python
+from careerlm import CareerLM
+
+client = CareerLM(api_key="csk_live_v1_your_key_here")
+
+score = client.cv.score(cv_text, job_description)
+print(score["ats_score"])   # 87
+print(score["grade"])       # "B+"
+```
+
+## What you can do
+
+| Method | Description |
+|---|---|
+| `client.cv.score(cv_text, job_description)` | Score a CV against a job description |
+| `client.cv.optimise(cv_text, job_description)` | Rewrite and optimise a CV for a target role |
+| `client.salary.benchmark(role, country)` | Salary benchmarking across 196 countries, PPP-adjusted |
+| `client.cover_letter.generate(cv_text, job_description, mode=1)` | Generate a cover letter in one of 15 professional modes |
+| `client.job.match(candidate, job)` | Score how well a candidate matches a job |
+| `client.interview.questions(role)` | Tailored interview questions with model answers |
+| `client.skills.gap(current_skills, target_role)` | Skill-gap analysis with learning ROI and timeline |
+| `client.chat.completions.create(messages)` | OpenAI-compatible career chat completions |
+| `client.context.save(profile)` / `.get(id)` / `.delete(id)` | Persistent career context across calls |
+
+## Example: salary benchmark
+
+```python
+salary = client.salary.benchmark("Data Engineer", "NG", city="Lagos", currency="NGN")
+print(salary["salary_range"]["median"])   # 6800000
+```
+
+## Example: cover letter
+
+```python
+letter = client.cover_letter.generate(
+    cv_text, job_description,
+    mode=5, company_name="Paystack", tone="confident",
+)
+print(letter["content"])
+```
+
+## Errors
+
+```python
+from careerlm import CareerLM, CareerLMError
+
+try:
+    client.cv.score(cv_text, job_description)
+except CareerLMError as e:
+    print(e.code, e.status, str(e))
+```
+
+## Context manager
+
+```python
+with CareerLM(api_key="...") as client:
+    ...
+```
+
+Full endpoint reference: [careerstudiomax.com/api/docs](https://careerstudiomax.com/api/docs)

careerlm-1.0.0/careerlm/__init__.py

@@ -0,0 +1,505 @@
+"""
+CareerLM Python SDK
+pip install careerlm
+
+from careerlm import CareerLM
+client = CareerLM(api_key="csk_live_v1_your_key_here")
+
+score = client.cv.score(cv_text, job_description)
+print(score["ats_score"])  # 87
+"""
+
+import httpx
+from typing import Optional, List, Dict, Any
+
+__version__ = "1.0.0"
+__all__ = ["CareerLM", "CareerLMError"]
+
+_BASE_URL = "https://careerlm-api.careerstudiomax.com/v1"
+
+
+class CareerLMError(Exception):
+    """Raised when the CareerLM API returns an error response."""
+    def __init__(self, message: str, code: str = "api_error", status: int = 500):
+        super().__init__(message)
+        self.code   = code
+        self.status = status
+
+
+class _Namespace:
+    """Base class for API namespaces."""
+    def __init__(self, client: "CareerLM"):
+        self._c = client
+
+    def _post(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        return self._c._post(endpoint, **kwargs)
+
+    def _get(self, endpoint: str) -> Dict[str, Any]:
+        return self._c._get(endpoint)
+
+    def _delete(self, endpoint: str) -> Dict[str, Any]:
+        return self._c._delete(endpoint)
+
+
+class _CV(_Namespace):
+    def score(
+        self,
+        cv_text: str,
+        job_description: Optional[str] = None,
+        *,
+        target_role: Optional[str] = None,
+        target_country: str = "GB",
+        include_suggestions: bool = True,
+        include_keywords: bool = True,
+        format: str = "detailed",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Score a CV against a job description.
+
+        Returns ats_score, grade, keyword_match, section_scores, top_suggestions.
+
+        Example:
+            score = client.cv.score(cv_text, job_desc, target_role="Senior Engineer")
+            print(score["ats_score"])   # 87
+            print(score["grade"])       # "B+"
+        """
+        return self._post(
+            "/career/cv/score",
+            cv_text=cv_text,
+            job_description=job_description,
+            target_role=target_role,
+            target_country=target_country,
+            options=dict(
+                include_suggestions=include_suggestions,
+                include_keywords=include_keywords,
+                format=format,
+                **kwargs,
+            ),
+        )
+
+    def optimise(
+        self,
+        cv_text: str,
+        job_description: Optional[str] = None,
+        *,
+        target_role: Optional[str] = None,
+        target_country: str = "GB",
+        rewrite_level: str = "moderate",
+        preserve_voice: bool = True,
+        add_metrics: bool = True,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Rewrite and optimise a CV for a target role.
+
+        Requires Starter tier or above.
+
+        Returns optimised_cv, changes, before_score, after_score.
+
+        Example:
+            result = client.cv.optimise(cv_text, jd, target_role="Data Engineer")
+            print(result["after_score"])  # 91
+        """
+        return self._post(
+            "/career/cv/optimise",
+            cv_text=cv_text,
+            job_description=job_description,
+            target_role=target_role,
+            target_country=target_country,
+            options=dict(
+                rewrite_level=rewrite_level,
+                preserve_voice=preserve_voice,
+                add_metrics=add_metrics,
+                **kwargs,
+            ),
+        )
+
+
+class _Salary(_Namespace):
+    def benchmark(
+        self,
+        role: str,
+        country: str = "GB",
+        *,
+        city: Optional[str] = None,
+        years_experience: int = 0,
+        skills: Optional[List[str]] = None,
+        company_size: Optional[str] = None,
+        currency: Optional[str] = None,
+        include_equity: bool = False,
+        include_benefits: bool = False,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Benchmark salary across 196 countries with PPP adjustment.
+
+        Requires Starter tier or above.
+
+        Returns salary_range (low/median/high/top_10_percent), usd_equivalent,
+        skill_premiums, negotiation_target, negotiation_script.
+
+        Example:
+            s = client.salary.benchmark("Data Engineer", "NG",
+                                        city="Lagos", currency="NGN")
+            print(s["salary_range"]["median"])  # 6800000
+        """
+        options: Dict[str, Any] = {}
+        if currency:       options["currency"]         = currency
+        if include_equity: options["include_equity"]   = include_equity
+        if include_benefits: options["include_benefits"] = include_benefits
+        options.update(kwargs)
+        return self._post(
+            "/career/salary/benchmark",
+            role=role,
+            country=country,
+            city=city,
+            years_experience=years_experience,
+            skills=skills or [],
+            company_size=company_size,
+            options=options or None,
+        )
+
+
+class _CoverLetter(_Namespace):
+    """Generate cover letters in 15 professional modes."""
+
+    MODES = {
+        1: "Achievement-led",    2: "Insight-led",       3: "Problem-solution",
+        4: "Narrative arc",      5: "Company-specific",  6: "Question-led",
+        7: "Bold statement",     8: "Data-driven",       9: "Cultural fit",
+        10: "Career transition", 11: "Promotion-within", 12: "Referral",
+        13: "Remote confidence", 14: "Multilingual",     15: "Executive gravitas",
+    }
+
+    def generate(
+        self,
+        cv_text: Optional[str] = None,
+        job_description: Optional[str] = None,
+        *,
+        mode: int = 1,
+        company_name: Optional[str] = None,
+        candidate_name: Optional[str] = None,
+        target_country: str = "GB",
+        tone: str = "confident",
+        word_limit: int = 280,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Generate a cover letter in one of 15 professional modes.
+
+        Requires Starter tier or above.
+
+        Modes:
+          1  Achievement-led      2  Insight-led          3  Problem-solution
+          4  Narrative arc        5  Company-specific      6  Question-led
+          7  Bold statement       8  Data-driven           9  Cultural fit
+          10 Career transition    11 Promotion-within      12 Referral
+          13 Remote confidence    14 Multilingual          15 Executive gravitas
+
+        Example:
+            letter = client.cover_letter.generate(
+                cv_text, jd,
+                mode=5, company_name="Paystack", tone="confident"
+            )
+            print(letter["content"])
+        """
+        if not 1 <= mode <= 15:
+            raise CareerLMError("mode must be between 1 and 15", "invalid_mode", 400)
+        return self._post(
+            "/career/cover-letter/generate",
+            cv_text=cv_text,
+            job_description=job_description,
+            mode=mode,
+            company_name=company_name,
+            candidate_name=candidate_name,
+            target_country=target_country,
+            tone=tone,
+            options={"word_limit": word_limit, **kwargs},
+        )
+
+
+class _Job(_Namespace):
+    def match(
+        self,
+        candidate: Dict[str, Any],
+        job: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Score how well a candidate matches a job.
+
+        Args:
+            candidate: { cv_text?, skills, years_experience, location, salary_expectation? }
+            job:       { title, description?, required_skills, salary_min?, salary_max?,
+                         location?, remote? }
+
+        Returns overall_score, grade, dimensions, gaps, strengths, interview_probability,
+        apply_recommendation.
+
+        Example:
+            result = client.job.match(
+                candidate={"skills": ["Python","SQL"], "years_experience": 5},
+                job={"title": "Data Engineer", "required_skills": ["Python","Spark","dbt"]}
+            )
+            print(result["interview_probability"])  # 0.72
+        """
+        return self._post("/career/job/match", candidate=candidate, job=job)
+
+
+class _Interview(_Namespace):
+    def questions(
+        self,
+        role: str,
+        *,
+        company: Optional[str] = None,
+        interview_type: str = "behavioural",
+        cv_text: Optional[str] = None,
+        count: int = 10,
+        include_answers: bool = True,
+        seniority: str = "mid",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Generate tailored interview questions with model answers.
+
+        Requires Starter tier or above.
+
+        Args:
+            role:           Target job role
+            company:        Specific company (makes questions more targeted)
+            interview_type: "behavioural" | "technical" | "case" | "all"
+            count:          Number of questions (max 20)
+            seniority:      "junior" | "mid" | "senior" | "director"
+
+        Example:
+            qs = client.interview.questions(
+                "Product Manager", company="Spotify",
+                interview_type="behavioural", count=10
+            )
+        """
+        return self._post(
+            "/career/interview/questions",
+            role=role,
+            company=company,
+            interview_type=interview_type,
+            cv_text=cv_text,
+            count=min(count, 20),
+            include_answers=include_answers,
+            seniority=seniority,
+            **kwargs,
+        )
+
+
+class _Skills(_Namespace):
+    def gap(
+        self,
+        current_skills: List[str],
+        target_role: str,
+        *,
+        target_country: str = "GB",
+        years_to_achieve: int = 12,
+        current_salary: Optional[int] = None,
+        include_roi: bool = False,
+        include_resources: bool = True,
+        currency: str = "GBP",
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Analyse skill gaps with learning ROI and timeline.
+
+        Returns readiness_score, gaps (with learn_hours, salary_impact, free_resources),
+        estimated_time_to_ready, total_salary_unlock.
+
+        Example:
+            gap = client.skills.gap(
+                ["Python", "SQL", "Excel"],
+                "Senior Data Scientist",
+                target_country="DE",
+                currency="EUR",
+                include_roi=True,
+            )
+            print(gap["estimated_time_to_ready"])   # "14 months"
+            print(gap["total_salary_unlock"])        # "+€22,000/year"
+        """
+        return self._post(
+            "/career/skills/gap",
+            current_skills=current_skills,
+            target_role=target_role,
+            target_country=target_country,
+            years_to_achieve=years_to_achieve,
+            current_salary=current_salary,
+            options=dict(
+                include_roi=include_roi,
+                include_resources=include_resources,
+                currency=currency,
+                **kwargs,
+            ),
+        )
+
+
+class _Chat(_Namespace):
+    """OpenAI-compatible career chat completions."""
+
+    class _Completions:
+        def __init__(self, client: "CareerLM"):
+            self._c = client
+
+        def create(
+            self,
+            messages: List[Dict[str, str]],
+            *,
+            model: str = "careerlm-standard",
+            max_tokens: int = 800,
+            temperature: float = 0.7,
+            **kwargs,
+        ) -> Dict[str, Any]:
+            """Career-aware chat completions (OpenAI-compatible).
+
+            Drop-in replacement for openai.chat.completions.create().
+
+            Example:
+                resp = client.chat.completions.create([
+                    {"role": "user", "content": "How do I negotiate salary?"}
+                ])
+                print(resp["choices"][0]["message"]["content"])
+            """
+            return self._c._post(
+                "/career/chat/completions",
+                messages=messages,
+                model=model,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                **kwargs,
+            )
+
+    def __init__(self, client: "CareerLM"):
+        super().__init__(client)
+        self.completions = self._Completions(client)
+
+
+class _Context(_Namespace):
+    def save(
+        self,
+        profile: Dict[str, Any],
+        context_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Save or update a career context for persistent memory across API calls.
+
+        Example:
+            ctx = client.context.save({
+                "current_role": "Software Engineer",
+                "target_role": "Engineering Manager",
+                "skills": ["Python", "Go", "AWS"],
+                "country": "GB",
+            })
+            context_id = ctx["context_id"]
+        """
+        return self._post("/career/context", profile=profile, context_id=context_id)
+
+    def get(self, context_id: str) -> Dict[str, Any]:
+        """Retrieve a career context by ID."""
+        return self._get(f"/career/context/{context_id}")
+
+    def delete(self, context_id: str) -> Dict[str, Any]:
+        """Delete a career context."""
+        return self._delete(f"/career/context/{context_id}")
+
+
+class CareerLM:
+    """CareerLM Python SDK — world's first career intelligence API.
+
+    Usage:
+        from careerlm import CareerLM
+
+        client = CareerLM(api_key="csk_live_v1_your_key_here")
+
+        # Score a CV
+        score = client.cv.score(cv_text, job_description)
+        print(score["ats_score"])   # 87
+
+        # Benchmark salary (196 countries)
+        salary = client.salary.benchmark("Data Engineer", "NG",
+                                          city="Lagos", currency="NGN")
+        print(salary["salary_range"]["median"])  # 6800000
+
+        # Generate cover letter
+        letter = client.cover_letter.generate(cv_text, jd,
+                                               mode=5, company_name="Paystack")
+        print(letter["content"])
+
+        # Skill gap analysis
+        gap = client.skills.gap(["Python", "SQL"], "Senior Data Scientist",
+                                  target_country="DE", include_roi=True)
+        print(gap["estimated_time_to_ready"])  # "14 months"
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = _BASE_URL,
+        timeout: float = 30.0,
+    ):
+        if not api_key:
+            raise CareerLMError(
+                "API key is required — get yours free at careerstudiomax.com/api",
+                "missing_api_key",
+                0,
+            )
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._http = httpx.Client(
+            headers={
+                "X-Api-Key":    api_key,
+                "Content-Type": "application/json",
+                "User-Agent":   f"careerlm-python/{__version__}",
+            },
+            timeout=timeout,
+        )
+        # Namespace instances
+        self.cv           = _CV(self)
+        self.salary       = _Salary(self)
+        self.cover_letter = _CoverLetter(self)
+        self.job          = _Job(self)
+        self.interview    = _Interview(self)
+        self.skills       = _Skills(self)
+        self.chat         = _Chat(self)
+        self.context      = _Context(self)
+
+    def _request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
+        url = f"{self._base_url}{endpoint}"
+        # Strip None values so optional params don't pollute the JSON body
+        body = {k: v for k, v in kwargs.items() if v is not None} if kwargs else None
+        try:
+            resp = self._http.request(method, url, json=body)
+        except httpx.TimeoutException:
+            raise CareerLMError("Request timed out — try a shorter input", "timeout", 504)
+        except httpx.ConnectError:
+            raise CareerLMError(
+                "Could not reach the CareerLM API — check your network connection",
+                "connection_error",
+                0,
+            )
+
+        if not resp.is_success:
+            try:
+                data = resp.json()
+                msg  = data.get("error", {}).get("message") or "Request failed"
+                code = data.get("error", {}).get("code")    or "api_error"
+            except Exception:
+                msg, code = resp.text[:200] or "Request failed", "api_error"
+            raise CareerLMError(msg, code, resp.status_code)
+
+        return resp.json()
+
+    def _post(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        return self._request("POST", endpoint, **kwargs)
+
+    def _get(self, endpoint: str) -> Dict[str, Any]:
+        return self._request("GET", endpoint)
+
+    def _delete(self, endpoint: str) -> Dict[str, Any]:
+        return self._request("DELETE", endpoint)
+
+    def close(self):
+        """Close the underlying HTTP client."""
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()

careerlm-1.0.0/careerlm.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: careerlm
+Version: 1.0.0
+Summary: Official Python SDK for the CareerLM API — world's first career intelligence API
+Home-page: https://careerstudiomax.com/api/docs
+Author: Career Studio
+Author-email: api@careerstudiomax.com
+Project-URL: Documentation, https://careerstudiomax.com/api/docs
+Project-URL: Source, https://github.com/owolat4real/career-studio
+Project-URL: Bug Tracker, https://github.com/owolat4real/career-studio/issues
+Keywords: career,ai,cv,resume,salary,api,careerlm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CareerLM Python SDK
+
+Official Python client for the [CareerLM API](https://careerstudiomax.com/api/docs) — world's first career intelligence API.
+
+## Install
+
+```bash
+pip install careerlm
+```
+
+## Quickstart
+
+```python
+from careerlm import CareerLM
+
+client = CareerLM(api_key="csk_live_v1_your_key_here")
+
+score = client.cv.score(cv_text, job_description)
+print(score["ats_score"])   # 87
+print(score["grade"])       # "B+"
+```
+
+## What you can do
+
+| Method | Description |
+|---|---|
+| `client.cv.score(cv_text, job_description)` | Score a CV against a job description |
+| `client.cv.optimise(cv_text, job_description)` | Rewrite and optimise a CV for a target role |
+| `client.salary.benchmark(role, country)` | Salary benchmarking across 196 countries, PPP-adjusted |
+| `client.cover_letter.generate(cv_text, job_description, mode=1)` | Generate a cover letter in one of 15 professional modes |
+| `client.job.match(candidate, job)` | Score how well a candidate matches a job |
+| `client.interview.questions(role)` | Tailored interview questions with model answers |
+| `client.skills.gap(current_skills, target_role)` | Skill-gap analysis with learning ROI and timeline |
+| `client.chat.completions.create(messages)` | OpenAI-compatible career chat completions |
+| `client.context.save(profile)` / `.get(id)` / `.delete(id)` | Persistent career context across calls |
+
+## Example: salary benchmark
+
+```python
+salary = client.salary.benchmark("Data Engineer", "NG", city="Lagos", currency="NGN")
+print(salary["salary_range"]["median"])   # 6800000
+```
+
+## Example: cover letter
+
+```python
+letter = client.cover_letter.generate(
+    cv_text, job_description,
+    mode=5, company_name="Paystack", tone="confident",
+)
+print(letter["content"])
+```
+
+## Errors
+
+```python
+from careerlm import CareerLM, CareerLMError
+
+try:
+    client.cv.score(cv_text, job_description)
+except CareerLMError as e:
+    print(e.code, e.status, str(e))
+```
+
+## Context manager
+
+```python
+with CareerLM(api_key="...") as client:
+    ...
+```
+
+Full endpoint reference: [careerstudiomax.com/api/docs](https://careerstudiomax.com/api/docs)

careerlm-1.0.0/careerlm.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+setup.py
+careerlm/__init__.py
+careerlm.egg-info/PKG-INFO
+careerlm.egg-info/SOURCES.txt
+careerlm.egg-info/dependency_links.txt
+careerlm.egg-info/requires.txt
+careerlm.egg-info/top_level.txt

careerlm-1.0.0/careerlm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

careerlm-1.0.0/careerlm.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.24.0

careerlm-1.0.0/careerlm.egg-info/top_level.txt

@@ -0,0 +1 @@
+careerlm

careerlm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

careerlm-1.0.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="careerlm",
+    version="1.0.0",
+    description="Official Python SDK for the CareerLM API — world's first career intelligence API",
+    long_description=open("README.md").read() if __import__("os").path.exists("README.md") else "",
+    long_description_content_type="text/markdown",
+    author="Career Studio",
+    author_email="api@careerstudiomax.com",
+    url="https://careerstudiomax.com/api/docs",
+    project_urls={
+        "Documentation": "https://careerstudiomax.com/api/docs",
+        "Source":        "https://github.com/owolat4real/career-studio",
+        "Bug Tracker":   "https://github.com/owolat4real/career-studio/issues",
+    },
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=["httpx>=0.24.0"],
+    keywords=["career", "ai", "cv", "resume", "salary", "api", "careerlm"],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)