profileout 0.1.0__tar.gz

profileout-0.1.0/LICENSE

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

profileout-0.1.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: profileout
+Version: 0.1.0
+Summary: Official Python SDK for the ProfileOut API
+Author: ProfileOut
+License-Expression: MIT
+Project-URL: Homepage, https://docs.profileout.com
+Project-URL: Documentation, https://docs.profileout.com
+Project-URL: Repository, https://github.com/ProfileOut/profileout-python
+Project-URL: Issues, https://github.com/ProfileOut/profileout-python/issues
+Keywords: profileout,sdk,people-data,resume-parsing,contact-enrichment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ProfileOut Python SDK
+
+Official synchronous Python client for the [ProfileOut API](https://docs.profileout.com).
+
+Requires Python 3.10 or newer. No runtime dependencies.
+
+## Install
+
+```sh
+pip install profileout
+```
+
+The installation command above becomes available after the first PyPI publication. Until then, install a local checkout with `pip install /path/to/profileout-python`.
+
+## Quick start
+
+Get an API key from the [ProfileOut console](https://console.profileout.com). The account must be active and email-verified, with sufficient credits.
+
+```python
+import os
+from profileout import ProfileOut
+
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"])
+request = client.create_people_data({"linkedin_id": "example-person"})
+response = (
+    request if request["status"] in ("completed", "failed")
+    else client.wait_for_people_data(request["request_id"])
+)
+
+if response["status"] == "failed":
+    print(response.get("error"))
+else:
+    print(response["result"])
+```
+
+Responses are dictionaries with the API's original snake_case fields. Nested profile fields can vary.
+
+## APIs
+
+| Operation | Method |
+| --- | --- |
+| Submit / read a profile | `create_people_data(input)` / `get_people_data(request_id)` |
+| Download profile image | `get_people_data_image(request_id)` → `bytes` |
+| Upload / read a resume | `create_profile_parsing(path)` / `get_profile_parsing(request_id)` |
+| Submit / read contact enrichment | `create_contact_enrichment(input)` / `get_contact_enrichment(request_id)` |
+| Start / continue a search | `create_people_search({"message": ...})` / `continue_people_search(session_id, {"message": ...})` |
+| Read a search | `get_people_search(session_id)` |
+| Check service health | `get_health()` (does not send the API key) |
+
+People Data and Contact Enrichment accept exactly one identity form:
+
+```python
+{"linkedin_id": "example-person"}
+{"profile_url": "https://www.linkedin.com/in/example-person"}
+{"platform": "github", "account_id": "example-person"}
+```
+
+Platforms: `linkedin`, `github`, `x`, `twitter`, `facebook`. Facebook numeric IDs must be strings.
+
+### Resume upload
+
+```python
+from pathlib import Path
+
+request = client.create_profile_parsing(Path("resume.pdf"))
+response = client.wait_for_profile_parsing(request["request_id"])
+print(response["status"], response["result"], response.get("error"))
+```
+
+Accepts a filesystem path, reads at most 10 MiB plus one byte to check the limit, and sends exactly one multipart `file` field. Files must be nonempty PDF, PNG, JPEG, or TIFF with a matching extension; the service validates the file signature.
+
+### Search conversation
+
+```python
+session = client.create_people_search({"message": "Find senior backend engineers in Seoul."})
+response = client.wait_for_people_search(session["session_id"])
+print(response["status"], response["follow_up"], response["role_summary"], response["filters"])
+
+# After reviewing the response, optionally send a new paid revision:
+revision = client.continue_people_search(session["session_id"], {"message": "Require Python experience."})
+print(revision["revision"])
+```
+
+Wait methods read the current request/session state; they do not pin a search revision. Avoid concurrently updating a session while waiting for a particular revision.
+
+## Polling, errors, and timeouts
+
+`wait_for_people_data`, `wait_for_profile_parsing`, `wait_for_contact_enrichment`, and `wait_for_people_search` accept an ID. They wait at least five seconds before the first GET and between pending results, honor longer `next_poll_after_seconds` hints, and return on either `completed` or `failed`. Always inspect `status`; HTTP 200 can contain a failed job, and search outputs can contain their own errors.
+
+```python
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"], timeout=120)
+response = client.wait_for_people_data(request_id, timeout=1800)
+```
+
+Timeout values use **seconds**. The client default is a 120-second timeout for blocking network operations. Wait methods default to a 20-minute polling deadline and cap each request's socket timeout by the remaining time. Python's standard HTTP transport uses a per-operation socket timeout; a slowly streaming response can overrun the polling deadline until that read finishes. A wait deadline raises `TimeoutError`. Local timeouts or interruption do not cancel processing on the server. This client is synchronous; calls block the calling thread.
+
+```python
+from profileout import ProfileOutError
+
+try:
+    response = client.get_people_data(request_id)
+    print(response["status"])
+except ProfileOutError as error:
+    print(error.status, error.code, error.request_id)
+    # error.body contains the response; error.headers includes retry-after if present.
+```
+
+HTTP failures and invalid response objects raise `ProfileOutError`. Network errors use the standard library's `urllib.error.URLError`, `OSError`, or HTTP exceptions; invalid local inputs raise `ValueError` or `TypeError`.
+
+**No requests are automatically retried.** Each accepted POST, including repeated submissions and search revisions, can reserve credits. After an ambiguous failure, recover a known request ID and use GET instead of blindly repeating POST. GET polling does not reserve additional credits. See [billing](https://docs.profileout.com/guides/billing).
+
+The optional `base_url` defaults to `https://api.profileout.com`. HTTPS is required except on localhost; redirects are rejected so credentials and paid requests cannot be forwarded.
+
+## Publishing to PyPI (maintainers)
+
+Distribution and import name: `profileout`. Initial version: `0.1.0`. This repository is ready to package, but no registry account or project is created by cloning it.
+
+1. [Create a PyPI account](https://pypi.org/account/register/), verify your email, and configure two-factor authentication.
+2. Check whether [the project name](https://pypi.org/project/profileout/) is available. If another owner takes it, change `project.name` in `pyproject.toml` and installation examples; the Python import can remain `profileout`.
+3. Create a PyPI API token with upload access. For a first upload, the project does not yet exist; use an account-scoped token, then replace it with a project-scoped token after publication. Store it outside the repository, and never paste it into chat.
+4. From this repository, prepare build tools in a local virtual environment:
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install build twine
+python -m build --outdir dist/0.1.0
+python -m twine check dist/0.1.0/*
+```
+
+The standard build command installs the declared setuptools backend in an isolated build environment. Runtime installation of the SDK has no third-party dependencies.
+
+5. Upload the verified wheel and source distribution:
+
+```sh
+python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/0.1.0/*
+```
+
+When prompted for an API token, paste your token including its `pypi-` prefix. If your Twine version asks for a username and password, use `__token__` as the username and your API token as the password. Uploading creates the project on the first successful publication. Build tools may also obtain credentials through the system keyring.
+
+Confirm the release at [PyPI](https://pypi.org/project/profileout/). For each later release, change the version in `pyproject.toml` and use a matching, new output directory; do not upload old artifacts. A published name/version cannot be reused. The files that are published become public.
+
+See the [official Python packaging guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/).
+
+## API compatibility
+
+Targets the ProfileOut v1 public API. When that contract changes, review both SDKs against the service's OpenAPI specification and update methods and examples together.
+
+## License
+
+[MIT](LICENSE). The license covers SDK code; API access and credits are provided separately by ProfileOut.

profileout-0.1.0/README.md

@@ -0,0 +1,151 @@
+# ProfileOut Python SDK
+
+Official synchronous Python client for the [ProfileOut API](https://docs.profileout.com).
+
+Requires Python 3.10 or newer. No runtime dependencies.
+
+## Install
+
+```sh
+pip install profileout
+```
+
+The installation command above becomes available after the first PyPI publication. Until then, install a local checkout with `pip install /path/to/profileout-python`.
+
+## Quick start
+
+Get an API key from the [ProfileOut console](https://console.profileout.com). The account must be active and email-verified, with sufficient credits.
+
+```python
+import os
+from profileout import ProfileOut
+
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"])
+request = client.create_people_data({"linkedin_id": "example-person"})
+response = (
+    request if request["status"] in ("completed", "failed")
+    else client.wait_for_people_data(request["request_id"])
+)
+
+if response["status"] == "failed":
+    print(response.get("error"))
+else:
+    print(response["result"])
+```
+
+Responses are dictionaries with the API's original snake_case fields. Nested profile fields can vary.
+
+## APIs
+
+| Operation | Method |
+| --- | --- |
+| Submit / read a profile | `create_people_data(input)` / `get_people_data(request_id)` |
+| Download profile image | `get_people_data_image(request_id)` → `bytes` |
+| Upload / read a resume | `create_profile_parsing(path)` / `get_profile_parsing(request_id)` |
+| Submit / read contact enrichment | `create_contact_enrichment(input)` / `get_contact_enrichment(request_id)` |
+| Start / continue a search | `create_people_search({"message": ...})` / `continue_people_search(session_id, {"message": ...})` |
+| Read a search | `get_people_search(session_id)` |
+| Check service health | `get_health()` (does not send the API key) |
+
+People Data and Contact Enrichment accept exactly one identity form:
+
+```python
+{"linkedin_id": "example-person"}
+{"profile_url": "https://www.linkedin.com/in/example-person"}
+{"platform": "github", "account_id": "example-person"}
+```
+
+Platforms: `linkedin`, `github`, `x`, `twitter`, `facebook`. Facebook numeric IDs must be strings.
+
+### Resume upload
+
+```python
+from pathlib import Path
+
+request = client.create_profile_parsing(Path("resume.pdf"))
+response = client.wait_for_profile_parsing(request["request_id"])
+print(response["status"], response["result"], response.get("error"))
+```
+
+Accepts a filesystem path, reads at most 10 MiB plus one byte to check the limit, and sends exactly one multipart `file` field. Files must be nonempty PDF, PNG, JPEG, or TIFF with a matching extension; the service validates the file signature.
+
+### Search conversation
+
+```python
+session = client.create_people_search({"message": "Find senior backend engineers in Seoul."})
+response = client.wait_for_people_search(session["session_id"])
+print(response["status"], response["follow_up"], response["role_summary"], response["filters"])
+
+# After reviewing the response, optionally send a new paid revision:
+revision = client.continue_people_search(session["session_id"], {"message": "Require Python experience."})
+print(revision["revision"])
+```
+
+Wait methods read the current request/session state; they do not pin a search revision. Avoid concurrently updating a session while waiting for a particular revision.
+
+## Polling, errors, and timeouts
+
+`wait_for_people_data`, `wait_for_profile_parsing`, `wait_for_contact_enrichment`, and `wait_for_people_search` accept an ID. They wait at least five seconds before the first GET and between pending results, honor longer `next_poll_after_seconds` hints, and return on either `completed` or `failed`. Always inspect `status`; HTTP 200 can contain a failed job, and search outputs can contain their own errors.
+
+```python
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"], timeout=120)
+response = client.wait_for_people_data(request_id, timeout=1800)
+```
+
+Timeout values use **seconds**. The client default is a 120-second timeout for blocking network operations. Wait methods default to a 20-minute polling deadline and cap each request's socket timeout by the remaining time. Python's standard HTTP transport uses a per-operation socket timeout; a slowly streaming response can overrun the polling deadline until that read finishes. A wait deadline raises `TimeoutError`. Local timeouts or interruption do not cancel processing on the server. This client is synchronous; calls block the calling thread.
+
+```python
+from profileout import ProfileOutError
+
+try:
+    response = client.get_people_data(request_id)
+    print(response["status"])
+except ProfileOutError as error:
+    print(error.status, error.code, error.request_id)
+    # error.body contains the response; error.headers includes retry-after if present.
+```
+
+HTTP failures and invalid response objects raise `ProfileOutError`. Network errors use the standard library's `urllib.error.URLError`, `OSError`, or HTTP exceptions; invalid local inputs raise `ValueError` or `TypeError`.
+
+**No requests are automatically retried.** Each accepted POST, including repeated submissions and search revisions, can reserve credits. After an ambiguous failure, recover a known request ID and use GET instead of blindly repeating POST. GET polling does not reserve additional credits. See [billing](https://docs.profileout.com/guides/billing).
+
+The optional `base_url` defaults to `https://api.profileout.com`. HTTPS is required except on localhost; redirects are rejected so credentials and paid requests cannot be forwarded.
+
+## Publishing to PyPI (maintainers)
+
+Distribution and import name: `profileout`. Initial version: `0.1.0`. This repository is ready to package, but no registry account or project is created by cloning it.
+
+1. [Create a PyPI account](https://pypi.org/account/register/), verify your email, and configure two-factor authentication.
+2. Check whether [the project name](https://pypi.org/project/profileout/) is available. If another owner takes it, change `project.name` in `pyproject.toml` and installation examples; the Python import can remain `profileout`.
+3. Create a PyPI API token with upload access. For a first upload, the project does not yet exist; use an account-scoped token, then replace it with a project-scoped token after publication. Store it outside the repository, and never paste it into chat.
+4. From this repository, prepare build tools in a local virtual environment:
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install build twine
+python -m build --outdir dist/0.1.0
+python -m twine check dist/0.1.0/*
+```
+
+The standard build command installs the declared setuptools backend in an isolated build environment. Runtime installation of the SDK has no third-party dependencies.
+
+5. Upload the verified wheel and source distribution:
+
+```sh
+python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/0.1.0/*
+```
+
+When prompted for an API token, paste your token including its `pypi-` prefix. If your Twine version asks for a username and password, use `__token__` as the username and your API token as the password. Uploading creates the project on the first successful publication. Build tools may also obtain credentials through the system keyring.
+
+Confirm the release at [PyPI](https://pypi.org/project/profileout/). For each later release, change the version in `pyproject.toml` and use a matching, new output directory; do not upload old artifacts. A published name/version cannot be reused. The files that are published become public.
+
+See the [official Python packaging guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/).
+
+## API compatibility
+
+Targets the ProfileOut v1 public API. When that contract changes, review both SDKs against the service's OpenAPI specification and update methods and examples together.
+
+## License
+
+[MIT](LICENSE). The license covers SDK code; API access and credits are provided separately by ProfileOut.

profileout-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "profileout"
+version = "0.1.0"
+description = "Official Python SDK for the ProfileOut API"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "ProfileOut"}]
+keywords = ["profileout", "sdk", "people-data", "resume-parsing", "contact-enrichment"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://docs.profileout.com"
+Documentation = "https://docs.profileout.com"
+Repository = "https://github.com/ProfileOut/profileout-python"
+Issues = "https://github.com/ProfileOut/profileout-python/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+profileout = ["py.typed"]

profileout-0.1.0/setup.cfg

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

profileout-0.1.0/src/profileout/__init__.py

@@ -0,0 +1,217 @@
+"""Official synchronous Python client for the ProfileOut API."""
+
+import json
+import math
+import re
+import time
+import uuid
+from os import PathLike
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError
+from urllib.parse import urlsplit
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+__all__ = ["ProfileOut", "ProfileOutError"]
+
+
+def _seconds(value: float, name: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or value <= 0:
+        raise ValueError(f"{name} must be a positive finite number.")
+    return value
+
+
+def _id_path(resource: str, identifier: str) -> str:
+    if not isinstance(identifier, str) or not re.fullmatch(r"[a-f\d]{8}(?:-[a-f\d]{4}){3}-[a-f\d]{12}", identifier, re.I | re.ASCII):
+        raise ValueError("A UUID request_id or session_id is required.")
+    return f"/v1/{resource}/{identifier}"
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        # Never forward API keys or replay a paid POST through a redirect.
+        return None
+
+
+class ProfileOutError(Exception):
+    """HTTP/API protocol failure; processing failures remain in the response."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int | None = None,
+        code: str | None = None,
+        request_id: str | None = None,
+        body: Any = None,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.body = body
+        self.headers = headers or {}
+
+
+class ProfileOut:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = "https://api.profileout.com",
+        timeout: float = 120,
+    ) -> None:
+        if not isinstance(api_key, str) or not re.fullmatch(r"[\x21-\x7e]+", api_key):
+            raise ValueError("api_key must be a nonempty API key without whitespace.")
+        if not isinstance(base_url, str) or re.search(r"[\x00-\x20\x7f\\]", base_url):
+            raise ValueError("base_url must be a valid URL.")
+        url = urlsplit(base_url)
+        local = url.hostname in {"localhost", "127.0.0.1", "::1"}
+        if (
+            not url.hostname
+            or (url.scheme != "https" and not (url.scheme == "http" and local))
+            or url.username is not None or url.password is not None or url.query or url.fragment
+        ):
+            raise ValueError("base_url must use HTTPS (HTTP is allowed on localhost) without credentials, query, or fragment.")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = _seconds(timeout, "timeout")
+        self._opener = build_opener(_NoRedirect())
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        data: dict[str, Any] | bytes | None = None,
+        *,
+        content_type: str | None = None,
+        timeout: float | None = None,
+        binary: bool = False,
+    ) -> Any:
+        headers = {"Accept": "image/*" if binary else "application/json"}
+        if path != "/health":
+            headers["Authorization"] = f"Bearer {self._api_key}"
+        if data is not None and not isinstance(data, bytes):
+            data = json.dumps(data, ensure_ascii=False, allow_nan=False).encode("utf-8")
+            content_type = "application/json"
+        if content_type:
+            headers["Content-Type"] = content_type
+        request = Request(self._base_url + path, data=data, headers=headers, method=method)
+        try:
+            response = self._opener.open(request, timeout=self._timeout if timeout is None else timeout)
+        except HTTPError as error:
+            response = error
+        with response:
+            status = response.status
+            response_headers = {key.lower(): value for key, value in response.headers.items()}
+            raw = response.read()
+        if 200 <= status < 300 and binary:
+            return raw
+        try:
+            body = json.loads(raw)
+        except (ValueError, UnicodeDecodeError):
+            body = raw.decode("utf-8", errors="replace")
+        details = dict(status=status, request_id=response_headers.get("x-request-id"), body=body, headers=response_headers)
+        if not 200 <= status < 300:
+            issue = body.get("error") if isinstance(body, dict) else None
+            issue = issue if isinstance(issue, dict) else {}
+            message = issue.get("message")
+            code = issue.get("code")
+            raise ProfileOutError(
+                message if isinstance(message, str) else f"ProfileOut returned HTTP {status}.",
+                code=code if isinstance(code, str) else None,
+                **details,
+            )
+        if not isinstance(body, dict):
+            raise ProfileOutError("ProfileOut returned an invalid JSON object.", code="invalid_response", **details)
+        return body
+
+    def _wait(self, path: str, timeout: float) -> dict[str, Any]:
+        deadline = time.monotonic() + _seconds(timeout, "timeout")
+        delay = 5.0
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError("Timed out waiting for ProfileOut; server-side processing may continue.")
+            time.sleep(min(delay, remaining))
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError("Timed out waiting for ProfileOut; server-side processing may continue.")
+            data = self._request("GET", path, timeout=min(self._timeout, remaining))
+            if time.monotonic() >= deadline:
+                raise TimeoutError("Timed out waiting for ProfileOut; server-side processing may continue.")
+            if data.get("status") in ("completed", "failed"):
+                return data
+            if data.get("status") not in ("queued", "pending", "processing"):
+                raise ProfileOutError("ProfileOut returned an unknown processing status.", code="invalid_response", body=data)
+            hint = data.get("next_poll_after_seconds")
+            delay = max(5.0, hint) if isinstance(hint, (int, float)) and math.isfinite(hint) and hint > 0 else 5.0
+
+    def create_people_data(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/v1/people-data", input)
+
+    def get_people_data(self, request_id: str) -> dict[str, Any]:
+        return self._request("GET", _id_path("people-data", request_id))
+
+    def get_people_data_image(self, request_id: str) -> bytes:
+        return self._request("GET", _id_path("people-data", request_id) + "/image", binary=True)
+
+    def wait_for_people_data(self, request_id: str, *, timeout: float = 1200) -> dict[str, Any]:
+        return self._wait(_id_path("people-data", request_id), timeout)
+
+    def create_profile_parsing(self, file: str | PathLike[str]) -> dict[str, Any]:
+        path = Path(file)
+        filename = path.name
+        media_types = {
+            ".pdf": "application/pdf", ".png": "image/png",
+            ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+            ".tif": "image/tiff", ".tiff": "image/tiff",
+        }
+        if (
+            len(filename.encode("utf-16-le")) // 2 > 255
+            or re.search(r"[\x00-\x1f\x7f\\]", filename)
+            or path.suffix.lower() not in media_types
+        ):
+            raise ValueError("file must have a PDF, PNG, JPEG, or TIFF filename of at most 255 characters.")
+        with path.open("rb") as source:
+            content = source.read(10 * 1024 * 1024 + 1)
+        if not content or len(content) > 10 * 1024 * 1024:
+            raise ValueError("file must be nonempty and no larger than 10 MiB.")
+        boundary = uuid.uuid4().hex
+        filename = filename.replace('"', "%22")
+        body = (
+            f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="{filename}"\r\n'
+            f'Content-Type: {media_types[path.suffix.lower()]}\r\n\r\n'
+        ).encode("utf-8") + content + f"\r\n--{boundary}--\r\n".encode("ascii")
+        return self._request("POST", "/v1/profile-parsings", body, content_type=f"multipart/form-data; boundary={boundary}")
+
+    def get_profile_parsing(self, request_id: str) -> dict[str, Any]:
+        return self._request("GET", _id_path("profile-parsings", request_id))
+
+    def wait_for_profile_parsing(self, request_id: str, *, timeout: float = 1200) -> dict[str, Any]:
+        return self._wait(_id_path("profile-parsings", request_id), timeout)
+
+    def create_contact_enrichment(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/v1/contact-enrichments", input)
+
+    def get_contact_enrichment(self, request_id: str) -> dict[str, Any]:
+        return self._request("GET", _id_path("contact-enrichments", request_id))
+
+    def wait_for_contact_enrichment(self, request_id: str, *, timeout: float = 1200) -> dict[str, Any]:
+        return self._wait(_id_path("contact-enrichments", request_id), timeout)
+
+    def create_people_search(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/v1/people-searches", input)
+
+    def continue_people_search(self, session_id: str, input: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", _id_path("people-searches", session_id), input)
+
+    def get_people_search(self, session_id: str) -> dict[str, Any]:
+        return self._request("GET", _id_path("people-searches", session_id))
+
+    def wait_for_people_search(self, session_id: str, *, timeout: float = 1200) -> dict[str, Any]:
+        return self._wait(_id_path("people-searches", session_id), timeout)
+
+    def get_health(self) -> dict[str, Any]:
+        return self._request("GET", "/health")

profileout-0.1.0/src/profileout.egg-info/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: profileout
+Version: 0.1.0
+Summary: Official Python SDK for the ProfileOut API
+Author: ProfileOut
+License-Expression: MIT
+Project-URL: Homepage, https://docs.profileout.com
+Project-URL: Documentation, https://docs.profileout.com
+Project-URL: Repository, https://github.com/ProfileOut/profileout-python
+Project-URL: Issues, https://github.com/ProfileOut/profileout-python/issues
+Keywords: profileout,sdk,people-data,resume-parsing,contact-enrichment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ProfileOut Python SDK
+
+Official synchronous Python client for the [ProfileOut API](https://docs.profileout.com).
+
+Requires Python 3.10 or newer. No runtime dependencies.
+
+## Install
+
+```sh
+pip install profileout
+```
+
+The installation command above becomes available after the first PyPI publication. Until then, install a local checkout with `pip install /path/to/profileout-python`.
+
+## Quick start
+
+Get an API key from the [ProfileOut console](https://console.profileout.com). The account must be active and email-verified, with sufficient credits.
+
+```python
+import os
+from profileout import ProfileOut
+
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"])
+request = client.create_people_data({"linkedin_id": "example-person"})
+response = (
+    request if request["status"] in ("completed", "failed")
+    else client.wait_for_people_data(request["request_id"])
+)
+
+if response["status"] == "failed":
+    print(response.get("error"))
+else:
+    print(response["result"])
+```
+
+Responses are dictionaries with the API's original snake_case fields. Nested profile fields can vary.
+
+## APIs
+
+| Operation | Method |
+| --- | --- |
+| Submit / read a profile | `create_people_data(input)` / `get_people_data(request_id)` |
+| Download profile image | `get_people_data_image(request_id)` → `bytes` |
+| Upload / read a resume | `create_profile_parsing(path)` / `get_profile_parsing(request_id)` |
+| Submit / read contact enrichment | `create_contact_enrichment(input)` / `get_contact_enrichment(request_id)` |
+| Start / continue a search | `create_people_search({"message": ...})` / `continue_people_search(session_id, {"message": ...})` |
+| Read a search | `get_people_search(session_id)` |
+| Check service health | `get_health()` (does not send the API key) |
+
+People Data and Contact Enrichment accept exactly one identity form:
+
+```python
+{"linkedin_id": "example-person"}
+{"profile_url": "https://www.linkedin.com/in/example-person"}
+{"platform": "github", "account_id": "example-person"}
+```
+
+Platforms: `linkedin`, `github`, `x`, `twitter`, `facebook`. Facebook numeric IDs must be strings.
+
+### Resume upload
+
+```python
+from pathlib import Path
+
+request = client.create_profile_parsing(Path("resume.pdf"))
+response = client.wait_for_profile_parsing(request["request_id"])
+print(response["status"], response["result"], response.get("error"))
+```
+
+Accepts a filesystem path, reads at most 10 MiB plus one byte to check the limit, and sends exactly one multipart `file` field. Files must be nonempty PDF, PNG, JPEG, or TIFF with a matching extension; the service validates the file signature.
+
+### Search conversation
+
+```python
+session = client.create_people_search({"message": "Find senior backend engineers in Seoul."})
+response = client.wait_for_people_search(session["session_id"])
+print(response["status"], response["follow_up"], response["role_summary"], response["filters"])
+
+# After reviewing the response, optionally send a new paid revision:
+revision = client.continue_people_search(session["session_id"], {"message": "Require Python experience."})
+print(revision["revision"])
+```
+
+Wait methods read the current request/session state; they do not pin a search revision. Avoid concurrently updating a session while waiting for a particular revision.
+
+## Polling, errors, and timeouts
+
+`wait_for_people_data`, `wait_for_profile_parsing`, `wait_for_contact_enrichment`, and `wait_for_people_search` accept an ID. They wait at least five seconds before the first GET and between pending results, honor longer `next_poll_after_seconds` hints, and return on either `completed` or `failed`. Always inspect `status`; HTTP 200 can contain a failed job, and search outputs can contain their own errors.
+
+```python
+client = ProfileOut(api_key=os.environ["PROFILEOUT_API_KEY"], timeout=120)
+response = client.wait_for_people_data(request_id, timeout=1800)
+```
+
+Timeout values use **seconds**. The client default is a 120-second timeout for blocking network operations. Wait methods default to a 20-minute polling deadline and cap each request's socket timeout by the remaining time. Python's standard HTTP transport uses a per-operation socket timeout; a slowly streaming response can overrun the polling deadline until that read finishes. A wait deadline raises `TimeoutError`. Local timeouts or interruption do not cancel processing on the server. This client is synchronous; calls block the calling thread.
+
+```python
+from profileout import ProfileOutError
+
+try:
+    response = client.get_people_data(request_id)
+    print(response["status"])
+except ProfileOutError as error:
+    print(error.status, error.code, error.request_id)
+    # error.body contains the response; error.headers includes retry-after if present.
+```
+
+HTTP failures and invalid response objects raise `ProfileOutError`. Network errors use the standard library's `urllib.error.URLError`, `OSError`, or HTTP exceptions; invalid local inputs raise `ValueError` or `TypeError`.
+
+**No requests are automatically retried.** Each accepted POST, including repeated submissions and search revisions, can reserve credits. After an ambiguous failure, recover a known request ID and use GET instead of blindly repeating POST. GET polling does not reserve additional credits. See [billing](https://docs.profileout.com/guides/billing).
+
+The optional `base_url` defaults to `https://api.profileout.com`. HTTPS is required except on localhost; redirects are rejected so credentials and paid requests cannot be forwarded.
+
+## Publishing to PyPI (maintainers)
+
+Distribution and import name: `profileout`. Initial version: `0.1.0`. This repository is ready to package, but no registry account or project is created by cloning it.
+
+1. [Create a PyPI account](https://pypi.org/account/register/), verify your email, and configure two-factor authentication.
+2. Check whether [the project name](https://pypi.org/project/profileout/) is available. If another owner takes it, change `project.name` in `pyproject.toml` and installation examples; the Python import can remain `profileout`.
+3. Create a PyPI API token with upload access. For a first upload, the project does not yet exist; use an account-scoped token, then replace it with a project-scoped token after publication. Store it outside the repository, and never paste it into chat.
+4. From this repository, prepare build tools in a local virtual environment:
+
+```sh
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install build twine
+python -m build --outdir dist/0.1.0
+python -m twine check dist/0.1.0/*
+```
+
+The standard build command installs the declared setuptools backend in an isolated build environment. Runtime installation of the SDK has no third-party dependencies.
+
+5. Upload the verified wheel and source distribution:
+
+```sh
+python -m twine upload --repository-url https://upload.pypi.org/legacy/ dist/0.1.0/*
+```
+
+When prompted for an API token, paste your token including its `pypi-` prefix. If your Twine version asks for a username and password, use `__token__` as the username and your API token as the password. Uploading creates the project on the first successful publication. Build tools may also obtain credentials through the system keyring.
+
+Confirm the release at [PyPI](https://pypi.org/project/profileout/). For each later release, change the version in `pyproject.toml` and use a matching, new output directory; do not upload old artifacts. A published name/version cannot be reused. The files that are published become public.
+
+See the [official Python packaging guide](https://packaging.python.org/en/latest/tutorials/packaging-projects/).
+
+## API compatibility
+
+Targets the ProfileOut v1 public API. When that contract changes, review both SDKs against the service's OpenAPI specification and update methods and examples together.
+
+## License
+
+[MIT](LICENSE). The license covers SDK code; API access and credits are provided separately by ProfileOut.

profileout-0.1.0/src/profileout.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/profileout/__init__.py
+src/profileout/py.typed
+src/profileout.egg-info/PKG-INFO
+src/profileout.egg-info/SOURCES.txt
+src/profileout.egg-info/dependency_links.txt
+src/profileout.egg-info/top_level.txt

profileout-0.1.0/src/profileout.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

profileout-0.1.0/src/profileout.egg-info/top_level.txt

@@ -0,0 +1 @@
+profileout