stophy 0.1.0__py3-none-any.whl

stophy/__init__.py

@@ -0,0 +1,6 @@
+from . import types
+from .client import Stophy
+from .errors import StophyError
+
+__all__ = ["Stophy", "StophyError", "types"]
+__version__ = "0.1.0"

stophy/client.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import random
+import time
+from email.utils import parsedate_to_datetime
+from typing import Any, Dict, List, Literal, Mapping, Optional, overload
+
+import httpx
+
+from .errors import StophyError
+from .types import (
+    ChannelResponse,
+    CommentsResponse,
+    CreditsResponse,
+    LiveChatResponse,
+    LogsResponse,
+    PlaylistResponse,
+    SearchResponse,
+    SuggestResponse,
+    TranscriptResponse,
+    UsageResponse,
+    VideoDetailsResponse,
+    VideoResponse,
+)
+
+DEFAULT_BASE_URL = "https://api.stophy.dev"
+RETRYABLE_STATUS = {429, 500, 502, 503, 504}
+
+
+def _compact(params: Mapping[str, Any]) -> Dict[str, Any]:
+    """Drop keys whose value is None so we only send what the caller set."""
+    return {k: v for k, v in params.items() if v is not None}
+
+
+class Stophy:
+    """Client for Stophy — YouTube context API for AI agents.
+
+    >>> stophy = Stophy(os.environ["STOPHY_API_KEY"])
+    >>> result = stophy.video(type="transcript", video_url=url)
+    >>> print(result["data"]["text"])
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        headers: Optional[Mapping[str, str]] = None,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        retry_initial_delay: float = 0.5,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("Stophy: api_key is required.")
+        self._max_retries = max_retries
+        self._retry_base = retry_initial_delay
+        self.client = httpx.Client(
+            base_url=base_url,
+            headers={"Authorization": f"Bearer {api_key}", **(headers or {})},
+            timeout=timeout,
+            transport=transport,
+        )
+
+    # --- endpoints ---------------------------------------------------------
+
+    @overload
+    def video(
+        self,
+        *,
+        type: Literal["details"],
+        video_url: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        chat_type: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> VideoDetailsResponse: ...
+
+    @overload
+    def video(
+        self,
+        *,
+        type: Literal["transcript"],
+        video_url: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        chat_type: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> TranscriptResponse: ...
+
+    @overload
+    def video(
+        self,
+        *,
+        type: Literal["comments", "replies"],
+        video_url: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        chat_type: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> CommentsResponse: ...
+
+    @overload
+    def video(
+        self,
+        *,
+        type: Literal["livechat"],
+        video_url: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        chat_type: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> LiveChatResponse: ...
+
+    def video(
+        self,
+        *,
+        type: str,
+        video_url: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        chat_type: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> VideoResponse:
+        """Video details, transcript, comments, replies, or live chat — pick with ``type``.
+
+        The shape of ``data`` depends on ``type`` (details / transcript /
+        comments / replies / livechat).
+        """
+        return self._post(
+            "/v1/video",
+            {
+                "type": type,
+                "videoUrl": video_url,
+                "sortBy": sort_by,
+                "chatType": chat_type,
+                "continuationToken": continuation_token,
+            },
+        )
+
+    def search(
+        self,
+        *,
+        q: str,
+        type: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        upload_date: Optional[str] = None,
+        duration: Optional[str] = None,
+        features: Optional[List[str]] = None,
+        continuation_token: Optional[str] = None,
+    ) -> SearchResponse:
+        """Search YouTube, optionally filtered by type, sort, date, duration, and features."""
+        return self._post(
+            "/v1/search",
+            {
+                "q": q,
+                "type": type,
+                "sortBy": sort_by,
+                "uploadDate": upload_date,
+                "duration": duration,
+                "features": features,
+                "continuationToken": continuation_token,
+            },
+        )
+
+    def channel(
+        self,
+        *,
+        channel_url: str,
+        tab: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        continuation_token: Optional[str] = None,
+    ) -> ChannelResponse:
+        """Channel metadata and content. Switch sections with ``tab``."""
+        return self._post(
+            "/v1/channel",
+            {
+                "channelUrl": channel_url,
+                "tab": tab,
+                "sortBy": sort_by,
+                "continuationToken": continuation_token,
+            },
+        )
+
+    def playlist(
+        self,
+        *,
+        playlist_url: str,
+        continuation_token: Optional[str] = None,
+    ) -> PlaylistResponse:
+        """Playlist items. Page through long playlists with ``continuation_token``."""
+        return self._post(
+            "/v1/playlist",
+            {"playlistUrl": playlist_url, "continuationToken": continuation_token},
+        )
+
+    def suggest(
+        self,
+        *,
+        q: str,
+        hl: Optional[str] = None,
+        gl: Optional[str] = None,
+    ) -> SuggestResponse:
+        """Search autocomplete suggestions."""
+        return self._get("/v1/suggest", {"q": q, "hl": hl, "gl": gl})
+
+    def credits(self) -> CreditsResponse:
+        """Your current credit balance."""
+        return self._get("/v1/credits")
+
+    def logs(
+        self,
+        *,
+        days: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        page: Optional[int] = None,
+    ) -> LogsResponse:
+        """Recent API request logs."""
+        return self._get("/v1/logs", {"days": days, "endpoint": endpoint, "page": page})
+
+    def usage(
+        self,
+        *,
+        days: Optional[str] = None,
+        tz: Optional[str] = None,
+    ) -> UsageResponse:
+        """Daily credit and request counts."""
+        return self._get("/v1/usage", {"days": days, "tz": tz})
+
+    # --- plumbing ----------------------------------------------------------
+
+    def _get(self, path: str, params: Optional[Mapping[str, Any]] = None) -> Any:
+        return self._handle(self._send("GET", path, params=_compact(params or {})))
+
+    def _post(self, path: str, body: Mapping[str, Any]) -> Any:
+        return self._handle(self._send("POST", path, json=_compact(body)))
+
+    def _send(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        """Send a request, retrying transient failures with backoff + jitter.
+
+        Every Stophy endpoint is a read, so retrying is always safe.
+        """
+        attempt = 0
+        while True:
+            try:
+                resp = self.client.request(method, path, **kwargs)
+            except httpx.TransportError:
+                if attempt >= self._max_retries:
+                    raise
+                time.sleep(self._backoff(attempt))
+                attempt += 1
+                continue
+            if attempt < self._max_retries and resp.status_code in RETRYABLE_STATUS:
+                time.sleep(self._retry_after(resp, attempt))
+                attempt += 1
+                continue
+            return resp
+
+    def _backoff(self, attempt: int) -> float:
+        window = self._retry_base * (2**attempt)
+        return window / 2 + random.random() * (window / 2)
+
+    def _retry_after(self, resp: httpx.Response, attempt: int) -> float:
+        header = resp.headers.get("retry-after")
+        if header:
+            try:
+                return float(header)
+            except ValueError:
+                try:
+                    delay = parsedate_to_datetime(header).timestamp() - time.time()
+                    return max(0.0, delay)
+                except (TypeError, ValueError):
+                    pass
+        return self._backoff(attempt)
+
+    def _handle(self, resp: httpx.Response) -> Dict[str, Any]:
+        try:
+            payload = resp.json()
+        except ValueError:
+            payload = None
+
+        if resp.is_success and isinstance(payload, dict):
+            return payload
+
+        err = payload if isinstance(payload, dict) else {}
+        raise StophyError(
+            err.get("error") or f"Stophy request failed with status {resp.status_code}",
+            status=resp.status_code,
+            code=err.get("code"),
+            request_id=resp.headers.get("x-request-id"),
+            details=err.get("details"),
+        )
+
+    # --- lifecycle ---------------------------------------------------------
+
+    def close(self) -> None:
+        self.client.close()
+
+    def __enter__(self) -> "Stophy":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

stophy/errors.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class StophyError(Exception):
+    """Raised when the Stophy API responds with a non-2xx status."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        code: Optional[str] = None,
+        request_id: Optional[str] = None,
+        details: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.details = details

stophy/types.py

@@ -0,0 +1,423 @@
+"""Response types mirroring the Stophy OpenAPI schemas.
+
+These are ``TypedDict``s with ``total=False`` — they describe the shape of the
+JSON the API returns so editors and type checkers can help, without forcing
+every optional/nullable field to be present.
+"""
+
+from __future__ import annotations
+
+from typing import List, Literal, Optional, TypedDict, Union
+
+CacheState = Literal["hit", "miss"]
+ErrorCode = Literal[
+    "UNAUTHORIZED",
+    "INSUFFICIENT_CREDITS",
+    "BAD_REQUEST",
+    "INVALID_INPUT",
+    "NOT_FOUND",
+    "CONCURRENCY_LIMITED",
+    "INTERNAL_ERROR",
+]
+
+
+class Thumbnail(TypedDict, total=False):
+    url: str
+    width: int
+    height: int
+
+
+class EmptyState(TypedDict, total=False):
+    code: str
+    message: str
+
+
+# --- transcript -----------------------------------------------------------
+class TranscriptLanguage(TypedDict, total=False):
+    code: Optional[str]
+    name: Optional[str]
+    isAutoGenerated: bool
+
+
+class TranscriptSegment(TypedDict, total=False):
+    start: float
+    duration: float
+    text: str
+
+
+class TranscriptResult(TypedDict, total=False):
+    language: TranscriptLanguage
+    segments: List[TranscriptSegment]
+    text: str
+    empty: EmptyState
+
+
+# --- video details --------------------------------------------------------
+class VideoDetails(TypedDict, total=False):
+    id: str
+    type: Literal["video"]
+    videoUrl: str
+    title: Optional[str]
+    author: Optional[str]
+    authorId: Optional[str]
+    category: Optional[str]
+    description: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    isLive: bool
+    likeCount: Optional[float]
+    likeCountText: Optional[str]
+    publishedAt: Optional[str]
+    tags: List[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class RelatedVideo(TypedDict, total=False):
+    id: str
+    type: Literal["video"]
+    videoUrl: str
+    title: Optional[str]
+    author: Optional[str]
+    authorId: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class VideoDetailsData(TypedDict, total=False):
+    video: VideoDetails
+    related: List[RelatedVideo]
+
+
+# --- comments / replies ---------------------------------------------------
+class Comment(TypedDict, total=False):
+    id: Optional[str]
+    text: Optional[str]
+    author: Optional[str]
+    authorId: Optional[str]
+    authorThumbnail: Optional[str]
+    hasChannelOwnerReplied: bool
+    isChannelOwner: bool
+    isHearted: bool
+    isPinned: bool
+    isVerified: bool
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    likeCount: Optional[float]
+    likeCountText: Optional[str]
+    replyCount: Optional[float]
+    replyCountText: Optional[str]
+    repliesToken: Optional[str]
+
+
+class CommentsData(TypedDict, total=False):
+    items: List[Comment]
+    continuationToken: Optional[str]
+    empty: EmptyState
+
+
+# --- live chat ------------------------------------------------------------
+class LiveChatMessage(TypedDict, total=False):
+    id: str
+    text: str
+    author: Optional[str]
+    authorId: Optional[str]
+    timestampUsec: Optional[str]
+    isOwner: bool
+    isModerator: bool
+    isVerified: bool
+    superChatAmount: Optional[str]
+    superChatCurrency: Optional[str]
+
+
+class LiveChatData(TypedDict, total=False):
+    status: str
+    isLive: bool
+    concurrentViewers: Optional[float]
+    pollIntervalMs: Optional[float]
+    messages: List[LiveChatMessage]
+    continuationToken: Optional[str]
+
+
+VideoData = Union[VideoDetailsData, TranscriptResult, CommentsData, LiveChatData]
+
+
+# --- search ---------------------------------------------------------------
+class SearchVideo(TypedDict, total=False):
+    type: Literal["video"]
+    id: str
+    videoUrl: str
+    title: str
+    author: Optional[str]
+    authorId: Optional[str]
+    description: Optional[str]
+    duration: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    isLive: bool
+    isUpcoming: bool
+    isVerified: bool
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class SearchShort(TypedDict, total=False):
+    type: Literal["short"]
+    id: str
+    shortUrl: str
+    title: str
+    author: Optional[str]
+    authorId: Optional[str]
+    description: Optional[str]
+    duration: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class SearchPlaylist(TypedDict, total=False):
+    type: Literal["playlist"]
+    id: str
+    playlistUrl: str
+    title: str
+    author: Optional[str]
+    authorId: Optional[str]
+    videoCount: Optional[float]
+    videoCountText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class SearchChannel(TypedDict, total=False):
+    type: Literal["channel"]
+    id: str
+    channelUrl: str
+    name: str
+    handle: Optional[str]
+    description: Optional[str]
+    subscriberCount: Optional[float]
+    subscriberCountText: Optional[str]
+    isVerified: bool
+    thumbnails: List[Thumbnail]
+
+
+SearchItem = Union[SearchVideo, SearchShort, SearchPlaylist, SearchChannel]
+
+
+class SearchData(TypedDict, total=False):
+    items: List[SearchItem]
+    continuationToken: Optional[str]
+    estimatedResults: int
+    empty: EmptyState
+
+
+# --- channel --------------------------------------------------------------
+class ChannelLink(TypedDict, total=False):
+    title: str
+    url: str
+
+
+class ChannelProfile(TypedDict, total=False):
+    id: Optional[str]
+    name: Optional[str]
+    handle: Optional[str]
+    channelUrl: Optional[str]
+    description: Optional[str]
+    subscriberCount: Optional[float]
+    subscriberCountText: Optional[str]
+    videoCount: Optional[float]
+    videoCountText: Optional[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    isVerified: bool
+    country: Optional[str]
+    joinedDate: Optional[str]
+    thumbnails: List[Thumbnail]
+    banners: List[Thumbnail]
+    links: Optional[List[ChannelLink]]
+
+
+class ContentItem(TypedDict, total=False):
+    id: str
+    type: str
+    title: Optional[str]
+    videoUrl: str
+    shortUrl: str
+    playlistUrl: str
+    author: Optional[str]
+    authorId: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class ChannelData(TypedDict, total=False):
+    channel: Optional[ChannelProfile]
+    tab: Optional[str]
+    items: List[ContentItem]
+    continuationToken: Optional[str]
+    empty: EmptyState
+
+
+# --- playlist -------------------------------------------------------------
+class PlaylistMeta(TypedDict, total=False):
+    id: str
+    type: Literal["playlist"]
+    playlistUrl: str
+    title: Optional[str]
+    author: Optional[str]
+    authorId: Optional[str]
+    description: Optional[str]
+    videoCount: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class PlaylistItem(TypedDict, total=False):
+    id: str
+    type: Literal["video"]
+    videoUrl: str
+    title: Optional[str]
+    author: Optional[str]
+    authorId: Optional[str]
+    durationSec: Optional[float]
+    durationText: Optional[str]
+    index: Optional[float]
+    isLive: bool
+    isPlayable: bool
+    isUpcoming: bool
+    upcomingAt: Optional[str]
+    viewCount: Optional[float]
+    viewCountText: Optional[str]
+    publishedAt: Optional[str]
+    publishedAtText: Optional[str]
+    thumbnails: List[Thumbnail]
+
+
+class PlaylistData(TypedDict, total=False):
+    playlist: Optional[PlaylistMeta]
+    items: List[PlaylistItem]
+    continuationToken: Optional[str]
+    empty: EmptyState
+
+
+# --- suggest / account ----------------------------------------------------
+class SuggestData(TypedDict, total=False):
+    q: str
+    hl: str
+    gl: str
+    suggestions: List[str]
+
+
+class CreditsData(TypedDict, total=False):
+    credits: int
+
+
+class LogEntry(TypedDict, total=False):
+    id: str
+    userId: str
+    apiKeyId: Optional[str]
+    apiKeyName: Optional[str]
+    endpoint: str
+    method: str
+    status: int
+    credits: int
+    durationMs: Optional[float]
+    response: Optional[str]
+    createdAt: str
+
+
+class LogsData(TypedDict, total=False):
+    logs: List[LogEntry]
+    total: int
+    page: int
+    pageSize: int
+    totalPages: int
+    endpoints: List[str]
+
+
+class UsageItem(TypedDict, total=False):
+    date: str
+    credits: int
+    requests: int
+
+
+class UsageData(TypedDict, total=False):
+    items: List[UsageItem]
+
+
+# --- response envelopes ---------------------------------------------------
+class _Envelope(TypedDict, total=False):
+    success: bool
+    requestId: str
+    cacheState: CacheState
+    creditsUsed: int
+    creditsRemaining: int
+
+
+class _AccountEnvelope(TypedDict, total=False):
+    success: bool
+    requestId: str
+
+
+class VideoResponse(_Envelope, total=False):
+    data: VideoData
+
+
+class VideoDetailsResponse(_Envelope, total=False):
+    data: VideoDetailsData
+
+
+class TranscriptResponse(_Envelope, total=False):
+    data: TranscriptResult
+
+
+class CommentsResponse(_Envelope, total=False):
+    data: CommentsData
+
+
+class LiveChatResponse(_Envelope, total=False):
+    data: LiveChatData
+
+
+class SearchResponse(_Envelope, total=False):
+    data: SearchData
+
+
+class ChannelResponse(_Envelope, total=False):
+    data: ChannelData
+
+
+class PlaylistResponse(_Envelope, total=False):
+    data: PlaylistData
+
+
+class SuggestResponse(_Envelope, total=False):
+    data: SuggestData
+
+
+class CreditsResponse(_AccountEnvelope, total=False):
+    data: CreditsData
+
+
+class LogsResponse(_AccountEnvelope, total=False):
+    data: LogsData
+
+
+class UsageResponse(_AccountEnvelope, total=False):
+    data: UsageData

stophy-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: stophy
+Version: 0.1.0
+Summary: Official Python SDK for Stophy - YouTube context API for AI agents.
+Project-URL: Homepage, https://stophy.dev
+Project-URL: Repository, https://github.com/stophy/stophy-sdk
+Author: Stophy
+License: MIT
+Keywords: ai-agents,sdk,stophy,transcript,youtube
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# stophy
+
+Official Python SDK for [Stophy](https://stophy.dev) **YouTube context API for AI agents**. Search videos, fetch transcripts, read comments and live chat, inspect channels and playlists, and get autocomplete suggestions, all returned as structured JSON.
+
+
+## Install
+
+```bash
+uv install stophy
+```
+
+Get an API key from your [Stophy dashboard](https://stophy.dev). The SDK sends it as `Authorization: Bearer <key>` on every request.
+
+## Quick start
+
+```python
+import os
+from stophy import Stophy
+
+stophy = Stophy(os.environ["STOPHY_API_KEY"])
+
+result = stophy.video(type="transcript", video_url="https://www.youtube.com/watch?v=D7liwdjvhWc")
+print(result["data"]["text"])
+```
+
+## Methods
+
+| Method | Description |
+| --- | --- |
+| `stophy.video(...)` | Details, transcript, comments, replies, or live chat (set `type`) |
+| `stophy.search(...)` | Search with filters for type, sort, date, duration, features |
+| `stophy.channel(...)` | Channel metadata + content by `tab` |
+| `stophy.playlist(...)` | Playlist items, paginated |
+| `stophy.suggest(...)` | Search autocomplete suggestions |
+| `stophy.credits()` | Current credit balance |
+| `stophy.logs(...)` | Recent request logs |
+| `stophy.usage(...)` | Daily credit/request counts |
+
+Arguments are keyword-only and snake_case; the SDK maps them to the API's field names for you. `video()` is overloaded on `type`, so the returned `data` is typed for the variant you asked for (transcript, comments, details, …).
+
+```python
+# Search
+results = stophy.search(q="typescript tutorial", sort_by="popularity", duration="long")
+
+# Comments, then replies to a comment
+comments = stophy.video(type="comments", video_url=url, sort_by="top")
+token = comments["data"]["items"][0].get("repliesToken")
+if token:
+    replies = stophy.video(type="replies", continuation_token=token)
+
+# Autocomplete and account
+print(stophy.suggest(q="react")["data"]["suggestions"])
+print(stophy.credits()["data"]["credits"])
+```
+
+### Pagination
+
+```python
+token = None
+while True:
+    page = stophy.search(q="lofi", continuation_token=token)
+    ...  # handle page["data"]["items"]
+    token = page["data"].get("continuationToken")
+    if not token:
+        break
+```
+
+## Errors
+
+Non-2xx responses raise `StophyError`:
+
+```python
+from stophy import Stophy, StophyError
+
+try:
+    stophy.credits()
+except StophyError as err:
+    print(err.status, err.code, err, err.request_id)
+    # err.code: "UNAUTHORIZED" | "INSUFFICIENT_CREDITS" | "BAD_REQUEST" |
+    #           "INVALID_INPUT" | "NOT_FOUND" | "CONCURRENCY_LIMITED" | "INTERNAL_ERROR"
+```
+
+## License
+
+MIT

stophy-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+stophy/__init__.py,sha256=XLWN31DbMafXDwdMdZeSA0Y7GktWdt7jxrknHAqrDgY,147
+stophy/client.py,sha256=nOPzLUxeL1ktjeAI_8wDv57y4G_yOD3NlZG5Idu5YuY,9167
+stophy/errors.py,sha256=G4JQWQJ8MZcG8JMFGGxzoHJDuMjkOlxLpDJWRBghd-Y,535
+stophy/types.py,sha256=tbGEbcV3S0nZSvFChSk-fFWlaj_c_NTLvGChZhAayRw,10046
+stophy-0.1.0.dist-info/METADATA,sha256=xc9HCfHYBc0aZalBHc0qL3MyNsYCshVytqqWGSJyack,3051
+stophy-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+stophy-0.1.0.dist-info/RECORD,,

stophy-0.1.0.dist-info/WHEEL

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