philo-sdk 0.1.0__cp312-none-any.whl

philo_sdk/__init__.pyi

@@ -0,0 +1,12 @@
+from ._l2_inputs import InputStream as InputStream
+from .assets import Image as Image, ReferenceAudio as ReferenceAudio
+from .characters import Character as Character, ReferenceVoice as ReferenceVoice
+from .client import PhiloClient as PhiloClient
+from .errors import CapabilityUnavailable as CapabilityUnavailable, PhiloError as PhiloError
+from .managed_assets import AssetRef as AssetRef
+from .media import MediaChunk as MediaChunk
+from .memory import MemoryState as MemoryState
+from .sessions import Session as Session, SessionSnapshot as SessionSnapshot, SessionUsage as SessionUsage
+from _typeshed import Incomplete
+
+__all__: Incomplete

philo_sdk/_http.pyi

@@ -0,0 +1,17 @@
+import httpx
+from .errors import PhiloError as PhiloError
+from _typeshed import Incomplete
+
+_MAX_JSON_BYTES: Incomplete
+
+def validate_base_url(value: str) -> str: ...
+
+class Http:
+    base_url: Incomplete
+    timeout: Incomplete
+    _api_key: Incomplete
+    _client: Incomplete
+    def __init__(self, api_key: str, base_url: str, timeout: float, *, transport: httpx.AsyncBaseTransport | None = None) -> None: ...
+    def redact(self, value: str) -> str: ...
+    async def request(self, method: str, path: str, body: dict | None = None, *, params: dict | None = None, binary: bool = False) -> dict | bytes: ...
+    async def close(self) -> None: ...

philo_sdk/_l1_protocol.pyi

@@ -0,0 +1 @@
+def fetch_reply(need: dict, *, pcm16: bytes | None = None, prompt: str | None = None, final: bool = False) -> dict: ...

philo_sdk/_l2_inputs.pyi

@@ -0,0 +1,21 @@
+from .errors import PhiloError as PhiloError
+from _typeshed import Incomplete
+from datetime import datetime
+
+class InputStream:
+    _conversation: Incomplete
+    kind: Incomplete
+    stream_id: Incomplete
+    command_id: Incomplete
+    state: str
+    _sequence: int
+    _captured_at: datetime | None
+    _changed: Incomplete
+    _lock: Incomplete
+    _stop_id: str | None
+    def __init__(self, conversation, kind: str) -> None: ...
+    def _observe(self, event: dict) -> None: ...
+    async def wait_ready(self, *, timeout: float = 10) -> None: ...
+    async def send(self, data: bytes, *, captured_at: datetime) -> int: ...
+    async def stop(self) -> str: ...
+    def _closed(self) -> None: ...

philo_sdk/_l2_stream.pyi

@@ -0,0 +1,44 @@
+import asyncio
+from ._l2_inputs import InputStream as InputStream
+from ._stream import Stream as Stream
+from .errors import CapabilityUnavailable as CapabilityUnavailable, PhiloError as PhiloError
+from .media import DEFAULT_CODECS as DEFAULT_CODECS, MAX_FRAME_BYTES as MAX_FRAME_BYTES, MAX_HEADER_BYTES as MAX_HEADER_BYTES, MediaChunk as MediaChunk, decode_frame as decode_frame, encode_frame as encode_frame
+from _typeshed import Incomplete
+from collections.abc import Generator
+
+class ConversationStream(Stream):
+    _session_id: Incomplete
+    _seq: int
+    _send_lock: Incomplete
+    _heartbeat_task: asyncio.Task | None
+    _heartbeat_failure: PhiloError | None
+    welcome: dict | None
+    _media: Incomplete
+    _codecs: Incomplete
+    _connection_id: str | None
+    _event_seq: int
+    _feedback_lock: Incomplete
+    _progress: dict[tuple[str, int], dict]
+    _latest_epoch: dict[str, int]
+    _captures: dict[str, InputStream]
+    _cuts: dict[str, dict]
+    _iterating: bool
+    _closed_stream: bool
+    def __init__(self, socket, http, session_id: str, *, media: bool = False, codecs=None) -> None: ...
+    async def _send(self, fields: dict, *, payload: bytes | None = None) -> None: ...
+    _max_frame: Incomplete
+    _max_header: Incomplete
+    async def start(self) -> None: ...
+    async def _heartbeat(self, interval: int) -> None: ...
+    def _check_event(self, event) -> None: ...
+    async def _messages(self) -> Generator[Incomplete]: ...
+    async def _received(self, chunk: MediaChunk) -> None: ...
+    async def feedback(self, chunk: MediaChunk, *, committed: int | None = None, played: int | None = None, released: int | None = None, buffered_ms: float = 0, paused: bool = False, played_at_ms: float | None = None) -> None: ...
+    async def acknowledge_cut(self, event: dict) -> None: ...
+    async def _start_input(self, kind: str) -> InputStream: ...
+    async def start_microphone(self) -> InputStream: ...
+    async def start_camera(self) -> InputStream: ...
+    async def send_text(self, text: str) -> str: ...
+    async def send_json(self, message: dict) -> None: ...
+    async def send_bytes(self, data: bytes) -> None: ...
+    async def close(self) -> None: ...

philo_sdk/_stream.pyi

@@ -0,0 +1,23 @@
+from ._http import Http as Http
+from ._l1_protocol import fetch_reply as fetch_reply
+from .errors import PhiloError as PhiloError
+from _typeshed import Incomplete
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from websockets.asyncio.client import ClientConnection, connect
+
+_LOG: Incomplete
+
+class _NoRedirectConnect(connect):
+    def process_redirect(self, exc: Exception) -> Exception: ...
+
+class Stream:
+    def __init__(self, socket: ClientConnection, http: Http, kind: str) -> None: ...
+    def __aiter__(self) -> AsyncIterator[dict | bytes]: ...
+    async def _messages(self) -> AsyncIterator[dict | bytes]: ...
+    async def send_json(self, message: dict) -> None: ...
+    async def send_bytes(self, data: bytes) -> None: ...
+    async def reply(self, need: dict, *, pcm16: bytes | None = None, prompt: str | None = None, final: bool = False) -> None: ...
+
+@asynccontextmanager
+async def open_stream(http: Http, path: str, expected_path: str, kind: str, *, media: bool = False, codecs=None): ...

philo_sdk/assets.pyi

@@ -0,0 +1,25 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from pathlib import Path
+from typing import ClassVar, Self
+
+_MAX_ASSET_BYTES: Incomplete
+
+@dataclass(frozen=True, repr=False)
+class InlineAsset:
+    data: bytes
+    mime_type: str
+    allowed_types: ClassVar[frozenset[str]] = ...
+    def __post_init__(self) -> None: ...
+    def __repr__(self) -> str: ...
+    @classmethod
+    def from_file(cls, path: str | Path, *, mime_type: str) -> Self: ...
+    def to_dict(self) -> dict: ...
+    @classmethod
+    def from_dict(cls, value: dict) -> Self: ...
+
+class Image(InlineAsset):
+    allowed_types: Incomplete
+
+class ReferenceAudio(InlineAsset):
+    allowed_types: Incomplete

philo_sdk/characters.pyi

@@ -0,0 +1,28 @@
+from .assets import Image as Image, ReferenceAudio as ReferenceAudio
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+@dataclass(frozen=True)
+class ReferenceVoice:
+    audio: ReferenceAudio
+    transcript: str
+    language: str | None = ...
+    def __post_init__(self) -> None: ...
+    def to_dict(self) -> dict: ...
+    @classmethod
+    def from_dict(cls, value: dict) -> Self: ...
+
+@dataclass(frozen=True)
+class Character:
+    name: str
+    persona: str
+    image: Image
+    reference_voice: ReferenceVoice | None = ...
+    def __post_init__(self) -> None: ...
+    def to_dict(self) -> dict: ...
+    @classmethod
+    def from_dict(cls, value: dict) -> Self: ...
+    def save(self, path: str | Path) -> None: ...
+    @classmethod
+    def load(cls, path: str | Path) -> Self: ...

philo_sdk/client.pyi

@@ -0,0 +1,17 @@
+import httpx
+from ._http import Http as Http
+from .managed_assets import ManagedAssets as ManagedAssets
+from .sessions import Sessions as Sessions
+from .video import Video as Video
+from _typeshed import Incomplete
+
+class PhiloClient:
+    _http: Incomplete
+    assets: ManagedAssets
+    video: Video
+    sessions: Sessions
+    def __init__(self, *, api_key: str, base_url: str = 'https://developer.philoai.xyz', timeout: float = 30, _transport: httpx.AsyncBaseTransport | None = None) -> None: ...
+    async def capabilities(self) -> dict: ...
+    async def close(self) -> None: ...
+    async def __aenter__(self) -> PhiloClient: ...
+    async def __aexit__(self, exc_type, exc, tb) -> None: ...

philo_sdk/devices.pyi

@@ -0,0 +1,40 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+class DeviceError(RuntimeError): ...
+
+@dataclass(frozen=True)
+class CapturedInput:
+    data: bytes
+    captured_at: datetime
+
+def _dependency(module: str) -> Any: ...
+def microphone_devices() -> list[dict[str, Any]]: ...
+def _microphone_worker(options, frames, status, stop) -> None: ...
+def _encode_camera_frame(cv, frame) -> bytes: ...
+def _camera_worker(options, frames, status, stop) -> None: ...
+def _capture_worker(kind, options, frames, status, stop) -> None: ...
+
+class _Capture:
+    _timeout: Incomplete
+    _process: Incomplete
+    _closed: bool
+    _ready: bool
+    _stopped: bool
+    def __init__(self, kind: str, options: dict, *, startup_timeout: float = 10) -> None: ...
+    def _check_status(self) -> None: ...
+    _frames: Incomplete
+    _stop: Incomplete
+    async def __aenter__(self): ...
+    def __aiter__(self): ...
+    async def __anext__(self) -> CapturedInput: ...
+    async def aclose(self) -> None: ...
+    async def __aexit__(self, exc_type, exc, tb) -> None: ...
+
+class MicrophoneCapture(_Capture):
+    def __init__(self, device: int | str | None = None, *, startup_timeout: float = 10) -> None: ...
+
+class CameraCapture(_Capture):
+    def __init__(self, device: int = 0, *, fps: float = 1, startup_timeout: float = 10) -> None: ...

philo_sdk/errors.pyi

@@ -0,0 +1,14 @@
+from _typeshed import Incomplete
+
+class PhiloError(Exception):
+    code: Incomplete
+    message: Incomplete
+    status_code: Incomplete
+    request_id: Incomplete
+    retryable: Incomplete
+    outcome_unknown: Incomplete
+    def __init__(self, code: str, message: str, *, status_code: int | None = None, request_id: str | None = None, retryable: bool = False, outcome_unknown: bool = False) -> None: ...
+
+class CapabilityUnavailable(PhiloError):
+    capability: Incomplete
+    def __init__(self, capability: str) -> None: ...

philo_sdk/managed_assets.pyi

@@ -0,0 +1,47 @@
+from .assets import Image as Image, ReferenceAudio as ReferenceAudio
+from _typeshed import Incomplete
+from dataclasses import dataclass
+
+def asset_id(value): ...
+
+@dataclass(frozen=True)
+class AssetRef:
+    id: str
+    revision: int
+    def __post_init__(self) -> None: ...
+    def to_dict(self): ...
+
+class AssetLibrary:
+    def __init__(self, http, kind) -> None: ...
+    async def list(self, *, page: int = 1, page_size: int = 30, include_archived: bool = False, query: str = ''): ...
+    async def retrieve(self, id, *, revision=None): ...
+    async def archive(self, id, *, expected_revision, expected_metadata_revision=None): ...
+    async def restore(self, id, *, expected_revision, expected_metadata_revision=None): ...
+    async def _state(self, id, state, revision, metadata): ...
+    async def deletion_plan(self, id, *, expected_revision): ...
+    async def delete(self, id, *, plan_hash, request_id): ...
+
+class Images(AssetLibrary):
+    async def upload(self, *, name, image: Image): ...
+    async def update(self, id, *, name, image: Image, expected_revision, expected_metadata_revision): ...
+    async def rename(self, id, *, name, expected_revision, expected_metadata_revision): ...
+    async def download(self, reference: AssetRef): ...
+
+class Voices(Images):
+    async def upload(self, *, name, audio: ReferenceAudio, transcript, language): ...
+    async def update(self, id, *, name, audio: ReferenceAudio, transcript, language, expected_revision, expected_metadata_revision): ...
+    async def download(self, reference: AssetRef): ...
+
+class Characters(AssetLibrary):
+    @staticmethod
+    def _body(name, persona, image, voice): ...
+    async def create(self, *, name, persona, image: AssetRef, voice: AssetRef | None = None): ...
+    async def update(self, id, *, expected_revision, name, persona, image: AssetRef, voice: AssetRef | None = None): ...
+
+class ManagedAssets:
+    _http: Incomplete
+    images: Incomplete
+    voices: Incomplete
+    characters: Incomplete
+    def __init__(self, http) -> None: ...
+    async def deletion_receipt(self, request_id): ...

philo_sdk/media.pyi

@@ -0,0 +1,26 @@
+from .errors import PhiloError as PhiloError
+from _typeshed import Incomplete
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+MAX_FRAME_BYTES: Incomplete
+MAX_HEADER_BYTES: Incomplete
+DEFAULT_CODECS: Incomplete
+
+@dataclass(frozen=True)
+class MediaChunk:
+    header: Mapping
+    payload: bytes
+    @property
+    def stream_id(self) -> str: ...
+    @property
+    def epoch(self) -> int: ...
+    @property
+    def stream_seq(self) -> int: ...
+    @property
+    def chunk_kind(self) -> str: ...
+    @property
+    def content_type(self) -> str: ...
+
+def decode_frame(data: bytes, *, max_frame: int, max_header: int) -> MediaChunk: ...
+def encode_frame(header: dict, payload: bytes, *, max_frame: int, max_header: int) -> bytes: ...

philo_sdk/memory.pyi

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+@dataclass(frozen=True)
+class MemoryState:
+    format: str
+    data: dict
+    def __post_init__(self) -> None: ...
+    def to_dict(self) -> dict: ...
+    @classmethod
+    def from_dict(cls, value: dict) -> Self: ...
+    def save(self, path: str | Path) -> None: ...
+    @classmethod
+    def load(cls, path: str | Path) -> Self: ...

philo_sdk/sessions.pyi

@@ -0,0 +1,55 @@
+from ._http import Http as Http
+from ._stream import open_stream as open_stream
+from .characters import Character as Character
+from .errors import CapabilityUnavailable as CapabilityUnavailable, PhiloError as PhiloError
+from .managed_assets import AssetRef as AssetRef
+from .memory import MemoryState as MemoryState
+from _typeshed import Incomplete
+from dataclasses import dataclass
+
+def session_id(value: str) -> str: ...
+
+@dataclass(frozen=True)
+class SessionSnapshot:
+    id: str
+    state: str
+    stream_url: str
+    cleanup: dict
+    preparation: dict | None = ...
+    @classmethod
+    def parse(cls, value: dict, *, expected_id: str | None = None, mutation: bool = False): ...
+
+@dataclass(frozen=True)
+class SessionUsage:
+    session_id: str
+    unit: str
+    state: str
+    metering_state: str
+    connected_elapsed_ms: int | None
+    observed_ms: int | None
+    budget_seconds: int | None
+    charged_seconds: int | None
+    cleanup_confirmed: bool
+    @classmethod
+    def parse(cls, value: dict, *, expected_id: str): ...
+
+class Session:
+    snapshot: Incomplete
+    _stream_opened: bool
+    def __init__(self, http: Http, snapshot: SessionSnapshot, *, kind: str) -> None: ...
+    @property
+    def id(self) -> str: ...
+    @property
+    def _path(self) -> str: ...
+    async def refresh(self) -> SessionSnapshot: ...
+    async def export_memory(self) -> MemoryState: ...
+    async def usage(self) -> SessionUsage: ...
+    async def stop(self) -> SessionSnapshot: ...
+    async def wait_ready(self, *, timeout: float | None = None) -> SessionSnapshot: ...
+    def stream(self, *, media: bool = False, codecs: tuple[str, ...] | None = None): ...
+
+class Sessions:
+    _http: Incomplete
+    def __init__(self, http: Http) -> None: ...
+    async def create(self, *, language: str, character: Character | None = None, character_asset: AssetRef | None = None, memory: MemoryState | None = None) -> Session: ...
+    async def retrieve(self, id: str) -> Session: ...

philo_sdk/video.pyi

@@ -0,0 +1,11 @@
+from ._http import Http as Http
+from .assets import Image as Image
+from .errors import CapabilityUnavailable as CapabilityUnavailable
+from .sessions import Session as Session, SessionSnapshot as SessionSnapshot, session_id as session_id
+from _typeshed import Incomplete
+
+class Video:
+    _http: Incomplete
+    def __init__(self, http: Http) -> None: ...
+    async def create(self, *, image: Image, prompt: str, audio_mode: str = 'native', seed: int | None = None, max_frames: int | None = None) -> Session: ...
+    async def retrieve(self, id: str) -> Session: ...

philo_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.5
+Name: philo-sdk
+Version: 0.1.0
+Summary: Python client for Philo digital-life conversations and video APIs
+Project-URL: Homepage, https://developer.philoai.xyz
+Project-URL: Documentation, https://developer.philoai.xyz/docs/en/
+Project-URL: Getting started, https://developer.philoai.xyz/docs/en/get-started
+Project-URL: Support, https://developer.philoai.xyz/docs/en/support
+Author: Philo AI
+License-Expression: LicenseRef-Philo-Proprietary
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.11
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: opencv-python-headless<5,>=4.10
+Requires-Dist: sounddevice<0.6,>=0.5
+Requires-Dist: websockets<16,>=15
+Provides-Extra: camera
+Provides-Extra: devices
+Provides-Extra: microphone
+Description-Content-Type: text/markdown
+
+# Philo Python SDK
+
+Use **CPython 3.13** (supported: standard CPython 3.11–3.14).
+Install from [PyPI](https://pypi.org/project/philo-sdk/):
+
+```bash
+python -m pip install philo-sdk
+```
+
+For the version used by this guide:
+
+```bash
+python -m pip install "philo-sdk==0.1.0"
+```
+
+Microphone and camera Python dependencies are included. Installation opens no
+hardware or API session. The [preparation guide](https://developer.philoai.xyz/docs/en/api-token)
+covers Python setup, virtual environments, upgrades and OS device requirements.
+Using the service requires your own Developer API Token and available quota.
+
+## Start with a character
+
+Set `PHILO_API_KEY` through your normal secret configuration. First list the
+characters available to your Token; this does not start a session or upload media:
+
+```python
+import asyncio
+import os
+from philo_sdk import PhiloClient
+
+
+async def main():
+    async with PhiloClient(api_key=os.environ["PHILO_API_KEY"]) as client:
+        page = 1
+        while page is not None:
+            result = await client.assets.characters.list(page=page, page_size=100)
+            for role in result["items"]:
+                if role.get("state") == "active" and role.get("available"):
+                    print(role["id"], role["revision"], role["name"])
+            page = result["next_page"]
+
+
+asyncio.run(main())
+```
+
+Choose a character explicitly. Create an L2 session with
+`character_asset=AssetRef(id, revision)` and a conversation language. The service
+resolves its image, reference voice and persona. No local character materials
+are required. The [complete quick start](https://developer.philoai.xyz/docs/en/public-assets)
+includes selection, audiovisual output, stopping and usage; further examples
+reuse the same selection for conversation, microphone, camera and text Memory.
+Session creation can consume quota. Reading the character list cannot.
+
+## Interfaces
+
+| Interface | Purpose |
+| --- | --- |
+| `client.assets` | Authorized official characters and your private assets |
+| `client.sessions.create(character_asset=…, language=…)` | Start with an existing character |
+| `session.stream(media=True)` | Audiovisual output with explicit consumer feedback |
+| `start_microphone()` / `start_camera()` | Send captured PCM / JPEG inputs |
+| `session.export_memory()` | Export supported text state after a completed close |
+| `session.stop()` / `session.usage()` | Request cleanup and read observed usage |
+| `Character`, `Image`, `ReferenceVoice` | Advanced inline character materials |
+| `client.video.create(...)` | Advanced L1 generation with final prompt and image |
+
+Check capabilities and session readiness before use. Received media is distinct
+from actual playback; the SDK does not include a full player.
+Text Memory is explicitly exported/imported; it is not a running-session backup.
+No automatic replay of billable requests or reconnection is performed. Preserve
+session/request IDs when outcomes are uncertain.
+
+Tokens stay on your backend. The SDK connects only to its configured API origin,
+does not follow redirects, and never needs infrastructure credentials. Official
+assets are read-only; private asset updates require ownership and revision checks.
+
+## Real microphone and camera
+
+The standard SDK installation includes device capture. Download the
+[complete editable examples](https://developer.philoai.xyz/docs/en/examples)
+to run the microphone and camera programs. A versioned local-wheel bundle remains
+available as an alternative; its `install.py` selects the matching wheel, and
+third-party dependencies may still require internet access.
+
+`philo_sdk.devices.MicrophoneCapture` yields 16 kHz mono PCM16 chunks;
+`CameraCapture` yields proportionally resized JPEG frames. Both include UTC
+capture timestamps. Use `async with` and `async for` to send them through an
+already-ready `start_microphone()` or `start_camera()` input. Keep the session's
+receiver running concurrently. Close the capture, input and session in `finally`.
+The complete downloaded programs implement this lifecycle, device selection and
+Ctrl+C: `python microphone.py`, `python camera.py --microphone`.
+
+These commands reuse your selected managed character. To use local character
+materials instead, append `--character my_character.json` to either command;
+real devices work identically. `--wav speech.wav` and `--jpeg scene.jpg` are
+explicit offline alternatives. No synthetic input is substituted on failure.
+
+Run scripts on the computer that owns the devices, with a guarded
+`if __name__ == '__main__':` entry point. Allow microphone/camera access in the
+OS. Linux microphone capture may require `libportaudio2`; the microphone must
+support 16 kHz mono input. No echo cancellation or resampling is provided: use
+headphones. Audio overflow is an error, camera buffering keeps only the latest
+frame. Native drivers run in owned processes with bounded shutdown; a blocked
+driver is terminated without blocking session cleanup. Device libraries are loaded
+only when capture is used; installing the SDK does not open any hardware.
+
+## Python version and distribution
+
+Use **CPython 3.13** for the tutorial. Bytecode wheels are supplied separately for
+CPython 3.11, 3.12, 3.13 and 3.14; PyPy and other Python minors are not supported by
+this release. Each wheel is tagged for its interpreter (for example
+`cp313-none-any`), not a universal `py3` wheel. The SDK implementation is `.pyc`,
+with `.pyi` API signatures for IDEs; editable examples remain Python source.
+Bytecode is not encryption and contains no embedded credentials. Source archives
+are internal build artifacts, not part of the downloadable example bundle.
+
+The [installation guide](https://developer.philoai.xyz/docs/en/api-token) covers
+macOS, Linux and Windows, including Python installation and upgrades. Create a
+new virtual environment when upgrading Python, then reinstall the matching wheel;
+do not copy `site-packages` from the old environment. The SDK wheel has no native
+extension; its device dependencies and OS drivers still need platform support.
+Linux CPU qualification does not imply physical-device or macOS/Windows testing.
+
+## Documentation
+
+- [Quick start](https://developer.philoai.xyz/docs/en/get-started)
+- [Continue with the selected character](https://developer.philoai.xyz/docs/en/examples)
+- [Customization and advanced use](https://developer.philoai.xyz/docs/en/advanced)
+- [API and SDK reference](https://developer.philoai.xyz/docs/en/reference)
+
+The SDK is proprietary; see the bundled LICENSE. Editable examples may be adapted
+for your own Philo integrations. Third-party dependencies retain their own licenses.

philo_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+philo_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+philo_sdk/__init__.pyc,sha256=w93BdTuYcgqWHAmwi09gxuZbwH5V7jwqy23mL0QJvlk,816
+philo_sdk/__init__.pyi,sha256=zikN51uUoMtbaXc8Y2XgetThrKDiVq3BjnP2HbYN2cY,642
+philo_sdk/_http.pyc,sha256=moN3tPsmQ7_Vmjt2dTdm4c7XlidbkVK-pQm6NY5NUH0,7596
+philo_sdk/_http.pyi,sha256=AzEpYYeapijnUNXwdsVu1KG5Uu2fOVsXh1YOd66ms5I,649
+philo_sdk/_l1_protocol.pyc,sha256=41tNWTTeAv4CvLeY1dboWs97-6NkcPZWQWqyMahtzvw,2846
+philo_sdk/_l1_protocol.pyi,sha256=uoE8lG3kF3EVAczqLSCfYD8oI8x11OLxQUL5JPaiazo,120
+philo_sdk/_l2_inputs.pyc,sha256=9swzEyxZ-73ge_E6Iitxyq9OilTHWdlodWz03dOgkaY,8484
+philo_sdk/_l2_inputs.pyi,sha256=R-_DxxN3x0aSoncsN4QDGSY60-UW7sfq4-k5ihCLAfo,698
+philo_sdk/_l2_stream.pyc,sha256=wuIrylG8OD5QFsOt6TImjaMpwNC-GK2ZkhZc-0UReN8,23640
+philo_sdk/_l2_stream.pyi,sha256=hc9mgi-gJYbBWYQXFUBrewA0yM79LTFIgOo5y-SqqSE,2195
+philo_sdk/_stream.pyc,sha256=SS0XhY-CXyMErDvDRrdG10_VHIUWTqOuGBGv-n5vyIc,8040
+philo_sdk/_stream.pyi,sha256=bqR0MftxbxlCFVScZxghKNV5b9rk_uNRK8d5HjEcORQ,1042
+philo_sdk/assets.pyc,sha256=rFG7r91knAc5yUw6yI5NcsEAgptFLWDAbRLKTWrjLG8,4048
+philo_sdk/assets.pyi,sha256=HTPj9_V9Pacsle3hk8S5InSyKr48Xexuy4J6dk47waM,687
+philo_sdk/characters.pyc,sha256=oi8wHZ6u1Rw2bDDJsTEaMH0keCBURqicVpXmtvJZwsQ,6690
+philo_sdk/characters.pyi,sha256=UBL-rcjp2ECCQ3VADZLfutKajNkN3vhoyJ-A1wyodwQ,815
+philo_sdk/client.pyc,sha256=nLbu1lST90F00unXKoNroIlDTuYb5JHPwGEhwiTensU,2255
+philo_sdk/client.pyi,sha256=8Hysi3FalON5vL34O1XiPWnukcGxpJeunSSmIHSdEu0,695
+philo_sdk/devices.pyc,sha256=ifAW1HnlCJPjU6w1YVsGSo8DRsaiTHQSBKEUz_cCRyw,16872
+philo_sdk/devices.pyi,sha256=qdlDQE5yDhay1jQder9Et_X5ysnpk15H30TAIXnKZHE,1383
+philo_sdk/errors.pyc,sha256=LbtN8qMkSolrSQc6kAciZU-p0OnLCOVpDKLZQKOl-rQ,1758
+philo_sdk/errors.pyi,sha256=yXI6-gmvKv1bQ2D-DYXuavn_DqgXniFVAlEkIRAmKy4,526
+philo_sdk/managed_assets.pyc,sha256=fmq5nsNTThp9V-V9dx__sWx2cDGTRzqk0SzyI-1HKyU,11529
+philo_sdk/managed_assets.pyi,sha256=TBbYAiRWQ_cUSchZnxWwVtV_gr-M5CvqWUJReA2LoCk,2087
+philo_sdk/media.pyc,sha256=6JyO1tReEVLFrXFmciUtxgEKRZYMxcxTdVTJFU_T0rw,5381
+philo_sdk/media.pyi,sha256=7ckjxz0rw9I_ql0aHgbhlixO0sJT130fZG90V1mZ_UQ,749
+philo_sdk/memory.pyc,sha256=iFAJLDI6-wh7gxBDOZHQriU1o4pxcuhEKjTuG1SXG30,4494
+philo_sdk/memory.pyi,sha256=Di4xv3YfLL-ycDHkPezHUqZ2OHPgAmUouSifO5s8Sq0,416
+philo_sdk/sessions.pyc,sha256=95LBEy-R8XxU2u43zIavft8_uHCBfKadE4GxFq8SaRw,16084
+philo_sdk/sessions.pyi,sha256=YfH7UlCrjnbcjfM38d3vcghvCNdwfqpM2424HShLm7g,1970
+philo_sdk/video.pyc,sha256=VGMxZtDRnYUJ6_6LfwotqgyP3hGNIwudOGRQ74GVEDQ,3484
+philo_sdk/video.pyi,sha256=0ZBOs-H4MrD_L5_iKx9y9nWBQ4LIQDTiwWJkk6Mh0Vs,565
+philo_sdk-0.1.0.dist-info/METADATA,sha256=VWDv3t8SrGCA44P0QfEEEHdWQSlf4QkgYP5v92D1rfQ,7824
+philo_sdk-0.1.0.dist-info/WHEEL,sha256=W42mSZvXqZOhgG5BKkqFS8CDA1xDuga_DU8M52cvmEY,89
+philo_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=Y_6gBCNO7_PqhouGf7iDsRFeDuzmXVGnCQVUJ8w9yfc,819
+philo_sdk-0.1.0.dist-info/RECORD,,

philo_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: cp312-none-any

philo_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,15 @@
+Philo SDK License
+Copyright (c) 2026 Philo AI. All rights reserved.
+
+Permission is granted to download, install and use the Philo SDK to integrate
+applications with Philo services, subject to the applicable Philo service terms
+and account permissions. This permission does not grant access to Philo services
+without authorization or waive service usage charges.
+
+The SDK is proprietary software. No license to its implementation source code
+or to redistribute, sublicense or sell the SDK is granted by this permission.
+Separately distributed example programs may be modified for your own Philo
+integrations. Third-party dependencies remain subject to their own licenses.
+
+The SDK is provided "AS IS", without warranties, to the extent permitted by
+applicable law. Rights not expressly granted are reserved by Philo AI.