fileboy 0.1.0__py3-none-any.whl

fileboy/__init__.py

@@ -0,0 +1,93 @@
+"""Official Python client for Fileboy (https://fileboy.io).
+
+    import fileboy
+
+    fileboy.configure(public_key="YOUR_PUBLIC_KEY")
+    fileboy.client().upload_file("report.pdf")
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from . import mime, token, transforms
+from ._version import __version__
+from .client import DEFAULT_API_URL, Client, Uploadable
+from .errors import (
+    AuthenticationError,
+    BadRequestError,
+    ConfigurationError,
+    FileboyConnectionError,
+    FileboyError,
+    FileboyPermissionError,
+    InvalidArgumentError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+)
+from .file_data import FileData, Video
+from .webhooks import WebhookVerificationError, sign_webhook, verify_webhook
+
+
+@dataclass
+class Configuration:
+    """Settings for the shared client. Unset values fall back to environment variables."""
+
+    public_key: Optional[str] = field(default_factory=lambda: os.environ.get("FILEBOY_PUBLIC_KEY"))
+    private_key: Optional[str] = field(default_factory=lambda: os.environ.get("FILEBOY_PRIVATE_KEY"))
+    api_url: str = field(default_factory=lambda: os.environ.get("FILEBOY_API_URL") or DEFAULT_API_URL)
+    timeout: float = 60
+
+
+_configuration: Optional[Configuration] = None
+_client: Optional[Client] = None
+
+
+def configuration() -> Configuration:
+    """The current settings. Created from the environment on first use."""
+    global _configuration
+    if _configuration is None:
+        _configuration = Configuration()
+    return _configuration
+
+
+def configure(**settings: Any) -> Configuration:
+    """Set ``public_key``, ``private_key``, ``api_url`` and/or ``timeout`` for :func:`client`."""
+    global _client
+    config = configuration()
+    for key, value in settings.items():
+        if not hasattr(config, key):
+            raise ConfigurationError(f"Unknown setting {key!r}")
+        setattr(config, key, value)
+    _client = None
+    return config
+
+
+def client() -> Client:
+    """A client built from :func:`configuration`. Memoized, and rebuilt after :func:`configure`."""
+    global _client
+    if _client is None:
+        config = configuration()
+        _client = Client(
+            public_key=config.public_key or "",
+            private_key=config.private_key,
+            api_url=config.api_url,
+            timeout=config.timeout,
+        )
+    return _client
+
+
+def reset() -> None:
+    """Forget all settings and the shared client. Mostly useful in tests."""
+    global _configuration, _client
+    _configuration = None
+    _client = None
+
+
+__all__ = [
+    "__version__", "Client", "Configuration", "configuration", "configure", "client", "reset",
+    "FileData", "Video", "Uploadable", "DEFAULT_API_URL", "mime", "token", "transforms",
+    "FileboyError", "ConfigurationError", "InvalidArgumentError", "FileboyConnectionError",
+    "BadRequestError", "AuthenticationError", "FileboyPermissionError", "NotFoundError",
+    "RateLimitError", "ServerError", "WebhookVerificationError", "sign_webhook", "verify_webhook",
+]

fileboy/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

fileboy/client.py

@@ -0,0 +1,414 @@
+"""The Fileboy client."""
+
+import json
+import os
+import re
+from io import BytesIO
+from typing import Any, BinaryIO, Dict, List, Mapping, Optional, Sequence, Tuple, Union
+from urllib.parse import quote
+
+import requests
+
+from . import mime as _mime
+from . import token as _token
+from . import transforms as _transforms
+from ._version import __version__
+from .errors import (
+    AuthenticationError,
+    BadRequestError,
+    ConfigurationError,
+    FileboyConnectionError,
+    FileboyError,
+    FileboyPermissionError,
+    InvalidArgumentError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+)
+from .file_data import FileData, Video
+
+DEFAULT_API_URL = "https://api.fileboy.io"
+UUID = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", re.IGNORECASE)
+
+#: What ``upload_*`` accept: a path, an open binary file object, or raw bytes.
+Uploadable = Union[str, "os.PathLike[str]", BinaryIO, bytes]
+
+
+def _enc(value: str) -> str:
+    return quote(str(value), safe="")
+
+
+class Client:
+    """A client for one Fileboy app.
+
+    >>> fileboy = Client(public_key="YOUR_PUBLIC_KEY")
+    >>> file = fileboy.upload_file("report.pdf")
+    >>> fileboy.build_file_url(file.id)
+
+    Reading a file (``GET /files/get``, ``/images/get``, video data) needs no authorization, so URL
+    builders never sign anything. Uploads send your public key, or a signed token when you also
+    pass a private key.
+
+    Args:
+        public_key: your app's public key.
+        private_key: your app's private key, for signed requests.
+        api_url: override to point at another Fileboy server, for example a CDN host.
+        timeout: seconds to wait for a response (uploads included).
+        connect_timeout: seconds to wait for a connection.
+    """
+
+    def __init__(
+        self,
+        public_key: str,
+        private_key: Optional[str] = None,
+        api_url: str = DEFAULT_API_URL,
+        timeout: float = 60,
+        connect_timeout: float = 10,
+    ) -> None:
+        if not public_key:
+            raise ConfigurationError("public_key is required")
+        self.public_key = public_key
+        self._private_key = private_key or None
+        self.api_url = str(api_url).rstrip("/")
+        self._timeout = timeout
+        self._connect_timeout = connect_timeout
+        self._session = requests.Session()
+
+    # --- URLs ----------------------------------------------------------------------------------
+
+    def build_file_url(self, id_or_label: str, *, filename: Optional[str] = None, download: bool = False) -> str:
+        """URL that serves the original file.
+
+        Args:
+            id_or_label: a file id, or a label name.
+            filename: sets the downloaded file name.
+            download: ask the browser to download instead of showing inline.
+        """
+        url = f"{self.api_url}/files/get/{self._resolve(id_or_label)}"
+        if filename:
+            url += f"/{_enc(filename)}"
+        if download:
+            url += "?download"
+        return url
+
+    def build_image_url(
+        self,
+        id_or_label: str,
+        *,
+        transforms: _transforms.TransformsInput = None,
+        filename: Optional[str] = None,
+        download: bool = False,
+    ) -> str:
+        """URL that serves an image, optionally transformed.
+
+        >>> fileboy.build_image_url(id, transforms=[{"type": "resize", "width": 300}, {"type": "format", "format": "webp"}])
+        >>> fileboy.build_image_url(id, transforms={"resize": "300x_", "format": "webp", "quality": 75})
+
+        See :func:`fileboy.transforms.build` for the accepted forms.
+        """
+        url = f"{self.api_url}/images/get/{self._resolve(id_or_label)}"
+        if filename:
+            url += f"/{_enc(filename)}"
+        params: List[str] = []
+        transform = _transforms.build(transforms)
+        if transform:
+            params.append(f"transform={transform}")
+        if download:
+            params.append("download")
+        if params:
+            url += "?" + "&".join(params)
+        return url
+
+    def build_video_manifest_url(self, video_id: str, type: str = "auto") -> str:
+        """Manifest URL for adaptive playback. ``type`` is ``"auto"``, ``"hls"`` or ``"dash"``."""
+        type = str(type)
+        if type not in ("auto", "hls", "dash"):
+            raise InvalidArgumentError("type must be auto, hls or dash")
+        return f"{self.api_url}/videos/{video_id}/manifest?type={type}"
+
+    def build_video_poster_url(self, video_id: str) -> str:
+        """URL of a video's poster image."""
+        return f"{self.api_url}/videos/{video_id}/poster"
+
+    # --- Files ---------------------------------------------------------------------------------
+
+    def upload_file(
+        self,
+        file: Uploadable,
+        *,
+        name: Optional[str] = None,
+        mime: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
+    ) -> FileData:
+        """Upload a file from a path, an open binary file object or bytes.
+
+        Args:
+            name: name to store the file under. Defaults to the file name.
+            mime: content type. Guessed from the name when omitted.
+            metadata: custom string key/value pairs stored with the file.
+        """
+        stream, filename, opened = _open_upload(file, name)
+        try:
+            content_type = mime or _mime.for_filename(filename)
+            data: Dict[str, Any] = {"name": name or filename, "mime": content_type}
+            if metadata:
+                data["metadata"] = _stringify(metadata)
+            files = {"file": (filename, stream, content_type)}
+            body = self._request("POST", "/files/upload", files=files, form={"data": json.dumps(data)})
+        finally:
+            if opened:
+                stream.close()
+        return FileData.from_api(body["data"])
+
+    def upload_file_from_path(self, path: Union[str, "os.PathLike[str]"], **options: Any) -> FileData:
+        """Same as :meth:`upload_file` with a path."""
+        return self.upload_file(os.fspath(path), **options)
+
+    def upload_file_from_url(
+        self,
+        url: str,
+        *,
+        name: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
+        expect: Union[str, Sequence[str], None] = None,
+    ) -> FileData:
+        """Ask Fileboy to fetch a public http(s) URL and store the result.
+
+        Args:
+            expect: accepted types, like ``"image/*"`` or ``".png"``.
+        """
+        payload: Dict[str, Any] = {"url": url}
+        if name:
+            payload["name"] = name
+        if metadata:
+            payload["metadata"] = _stringify(metadata)
+        if expect:
+            payload["expect"] = expect if isinstance(expect, str) else list(expect)
+        return FileData.from_api(self._request("POST", "/files/upload", json_body=payload)["data"])
+
+    def fetch_file_data(self, id_or_label: str) -> FileData:
+        """The details of a stored file."""
+        return FileData.from_api(self._request("GET", f"/files/data/{self._resolve(id_or_label)}")["data"])
+
+    def download_file(self, id_or_label: str, *, range: Optional[Tuple[int, int]] = None) -> bytes:
+        """The bytes of a file. ``range`` is ``(first_byte, last_byte)``."""
+        return self._request("GET", f"/files/get/{self._resolve(id_or_label)}", raw=True, byte_range=range)
+
+    def download_image(
+        self,
+        id_or_label: str,
+        *,
+        transforms: _transforms.TransformsInput = None,
+        range: Optional[Tuple[int, int]] = None,
+    ) -> bytes:
+        """The bytes of an image, optionally transformed."""
+        url = self.build_image_url(id_or_label, transforms=transforms)
+        return self._request("GET", url[len(self.api_url):], raw=True, byte_range=range)
+
+    # --- Videos --------------------------------------------------------------------------------
+
+    def upload_video(self, file: Uploadable, *, name: Optional[str] = None, mime: Optional[str] = None) -> Video:
+        """Upload a video.
+
+        Videos are processed in the background: poll :meth:`fetch_video_data` and wait for
+        ``extractionStatus`` to finish. Not available with the shared demo key.
+        """
+        stream, filename, opened = _open_upload(file, name)
+        try:
+            files = {"file": (filename, stream, mime or _mime.for_filename(filename))}
+            form = {"data": json.dumps({"name": name or filename})}
+            body = self._request("POST", "/videos/upload", files=files, form=form)
+        finally:
+            if opened:
+                stream.close()
+        return Video.from_api(body)
+
+    def fetch_video_data(self, video_id: str) -> Dict[str, Any]:
+        """Processing state, renditions, poster ids and transcripts for a video.
+
+        Returns the ``data`` object of the response as a dict.
+        """
+        return self._request("GET", f"/videos/{video_id}/data")["data"]
+
+    def fetch_video_info(self, video_id: str) -> Dict[str, Any]:
+        """Lighter details for a video: id, name, rawVideoUrl, duration, createdAt."""
+        return self._request("GET", f"/videos/{video_id}/info")
+
+    def upload_video_poster(
+        self, video_id: str, image: Uploadable, *, name: Optional[str] = None, mime: Optional[str] = None
+    ) -> str:
+        """Set a custom poster image. Returns the id of the stored image file."""
+        stream, filename, opened = _open_upload(image, name)
+        try:
+            files = {"file": (filename, stream, mime or _mime.for_filename(filename))}
+            body = self._request("POST", f"/videos/{video_id}/poster/upload", files=files)
+        finally:
+            if opened:
+                stream.close()
+        return body["data"]["id"]
+
+    def upload_video_transcript(
+        self,
+        video_id: str,
+        file: Uploadable,
+        *,
+        language: str,
+        name: Optional[str] = None,
+        mime: Optional[str] = None,
+    ) -> str:
+        """Attach a text transcript (WebVTT or plain text) in a language. Returns the transcript id."""
+        if not language:
+            raise InvalidArgumentError("language is required")
+        stream, filename, opened = _open_upload(file, name)
+        try:
+            files = {"file": (filename, stream, mime or _text_mime(filename))}
+            form = {"data": json.dumps({"language": language})}
+            body = self._request("POST", f"/videos/{video_id}/transcripts/upload", files=files, form=form)
+        finally:
+            if opened:
+                stream.close()
+        return body["data"]["id"]
+
+    def fetch_video_transcript(self, video_id: str, transcript_id: str) -> str:
+        """The text of a transcript."""
+        raw = self._request("GET", f"/videos/{video_id}/transcripts/{transcript_id}", raw=True)
+        return raw.decode("utf-8", errors="replace")
+
+    def download_video_poster(self, video_id: str) -> bytes:
+        """The poster image bytes."""
+        return self._request("GET", f"/videos/{video_id}/poster", raw=True)
+
+    # --- Tokens --------------------------------------------------------------------------------
+
+    def create_access_token(
+        self, *, read: bool = False, write: bool = False, upload: bool = False, expires_in: float = 60
+    ) -> str:
+        """A short-lived signed token for handing a browser limited access. Needs a private key."""
+        if not self._private_key:
+            raise ConfigurationError("Cannot create access tokens without a private key")
+        return _token.build(
+            public_key=self.public_key,
+            private_key=self._private_key,
+            expires_in=expires_in,
+            payload={"access": {"read": read, "write": write, "upload": upload}},
+        )
+
+    # --- Internals -----------------------------------------------------------------------------
+
+    def _resolve(self, id_or_label: str) -> str:
+        """UUIDs are ids; anything with a ``+`` is passed through; the rest is a label of this app."""
+        value = "" if id_or_label is None else str(id_or_label)
+        if not value:
+            raise InvalidArgumentError("No id given")
+        if UUID.fullmatch(value) or "+" in value:
+            return value
+        return f"{self.public_key}+{_enc(value)}"
+
+    def _auth_header(self) -> str:
+        if self._private_key:
+            return "token " + _token.build(self.public_key, self._private_key, expires_in=10)
+        return f"public {self.public_key}"
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json_body: Any = None,
+        files: Any = None,
+        form: Optional[Mapping[str, str]] = None,
+        raw: bool = False,
+        byte_range: Optional[Tuple[int, int]] = None,
+    ) -> Any:
+        headers = {"Authorization": self._auth_header(), "User-Agent": f"fileboy-python/{__version__}"}
+        if not raw:
+            headers["Accept"] = "application/json"
+        if byte_range:
+            headers["Range"] = f"bytes={byte_range[0]}-{byte_range[1]}"
+
+        kwargs: Dict[str, Any] = {}
+        if json_body is not None:
+            headers["Content-Type"] = "application/json"
+            kwargs["data"] = json.dumps(json_body)
+        elif files is not None:
+            kwargs["files"] = files
+            kwargs["data"] = dict(form or {})
+
+        try:
+            response = self._session.request(
+                method,
+                f"{self.api_url}{path}",
+                headers=headers,
+                timeout=(self._connect_timeout, self._timeout),
+                **kwargs,
+            )
+        except requests.RequestException as exc:
+            raise FileboyConnectionError(f"Could not reach Fileboy at {self.api_url}: {exc}") from exc
+
+        if not 200 <= response.status_code < 300:
+            self._raise_for_status(response)
+        if raw:
+            return response.content
+        try:
+            return response.json()
+        except ValueError:
+            raise FileboyError(
+                "Fileboy sent a response that is not JSON", status=response.status_code, body=response.text
+            ) from None
+
+    @staticmethod
+    def _raise_for_status(response: "requests.Response") -> None:
+        status = response.status_code
+        text = response.text or ""
+        try:
+            parsed = json.loads(text)
+        except ValueError:
+            parsed = None
+        code = str(parsed.get("error") or "") if isinstance(parsed, dict) else ""
+        detail = str(parsed.get("message") or "") if isinstance(parsed, dict) else text.strip()
+        message = f"Fileboy responded {status}"
+        if code:
+            message += f" ({code})"
+        if detail:
+            message += f": {detail}"
+
+        if status == 401:
+            cls = AuthenticationError
+        elif status == 403:
+            cls = FileboyPermissionError
+        elif status == 404:
+            cls = NotFoundError
+        elif status == 429:
+            cls = RateLimitError
+        elif 400 <= status <= 499:
+            cls = BadRequestError
+        else:
+            cls = ServerError
+        raise cls(message, status=status, code=code or None, body=parsed if parsed is not None else text)
+
+
+def _stringify(metadata: Mapping[str, Any]) -> Dict[str, str]:
+    return {str(k): str(v) for k, v in dict(metadata).items()}
+
+
+def _text_mime(filename: str) -> str:
+    mime = _mime.for_filename(filename)
+    return mime if mime.startswith("text/") else "text/plain"
+
+
+def _open_upload(file: Any, name: Optional[str]) -> Tuple[Any, str, bool]:
+    """Return ``(stream, filename, opened_by_us)``."""
+    if isinstance(file, (bytes, bytearray, memoryview)):
+        return BytesIO(bytes(file)), name or "upload", False
+    if isinstance(file, (str, os.PathLike)):
+        path = os.fspath(file)
+        if not os.path.isfile(path):
+            raise InvalidArgumentError(f"No such file: {path}")
+        return open(path, "rb"), os.path.basename(path), True
+    if not hasattr(file, "read"):
+        raise InvalidArgumentError("Pass a path, bytes or a file object to upload")
+    path_attr = getattr(file, "name", None)
+    filename = name or (os.path.basename(path_attr) if isinstance(path_attr, str) and path_attr else "upload")
+    if hasattr(file, "seek"):
+        file.seek(0)
+    return file, filename, False

fileboy/errors.py

@@ -0,0 +1,62 @@
+"""Exceptions raised by the Fileboy client."""
+
+from typing import Any, Optional
+
+
+class FileboyError(Exception):
+    """Base class for everything this package raises on purpose.
+
+    Attributes:
+        status: HTTP status of the response, if there was one.
+        code: the ``error`` code the API sent back, for example ``"unauthorized"``.
+        body: parsed JSON body or the raw text of the response.
+    """
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        *,
+        status: Optional[int] = None,
+        code: Optional[str] = None,
+        body: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.body = body
+
+
+class ConfigurationError(FileboyError):
+    """The client was set up wrongly. Raised before any request is made."""
+
+
+class InvalidArgumentError(FileboyError):
+    """A method was called with bad arguments. Raised before any request is made."""
+
+
+class FileboyConnectionError(FileboyError):
+    """The network failed, timed out or the server could not be reached."""
+
+
+class BadRequestError(FileboyError):
+    """400, 413, 415, 422 and other 4xx responses not listed below."""
+
+
+class AuthenticationError(FileboyError):
+    """401."""
+
+
+class FileboyPermissionError(FileboyError):
+    """403, including plan limits."""
+
+
+class NotFoundError(FileboyError):
+    """404."""
+
+
+class RateLimitError(FileboyError):
+    """429."""
+
+
+class ServerError(FileboyError):
+    """5xx."""

fileboy/file_data.py

@@ -0,0 +1,65 @@
+"""Result types returned by the client."""
+
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, Mapping, Optional
+
+
+def _parse_time(value: Any) -> Optional[datetime]:
+    if value is None or value == "":
+        return None
+    text = str(value).strip()
+    if text.endswith(("Z", "z")):
+        text = text[:-1] + "+00:00"
+    # Go may send up to nine fractional digits; Python accepts at most six.
+    text = re.sub(r"(\.\d{6})\d+", r"\1", text)
+    try:
+        return datetime.fromisoformat(text)
+    except ValueError:
+        return None
+
+
+@dataclass
+class FileData:
+    """The details of one stored file, as returned by an upload or ``fetch_file_data``."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    original_filename: Optional[str] = None
+    mime: Optional[str] = None
+    metadata: Dict[str, str] = field(default_factory=dict)
+    file_size: Optional[int] = None
+    content_hash: Optional[str] = None
+    signed: Optional[bool] = None
+    dies_at: Optional[datetime] = None
+    created_at: Optional[datetime] = None
+
+    @classmethod
+    def from_api(cls, data: Mapping[str, Any]) -> "FileData":
+        """Build from the ``data`` object of an API response."""
+        return cls(
+            id=data.get("id"),
+            name=data.get("name"),
+            original_filename=data.get("originalFilename"),
+            mime=data.get("mime"),
+            metadata=data.get("metadata") or {},
+            file_size=data.get("fileSize"),
+            content_hash=data.get("hash"),
+            signed=data.get("signed"),
+            dies_at=_parse_time(data.get("diesAt")),
+            created_at=_parse_time(data.get("createdAt")),
+        )
+
+
+@dataclass
+class Video:
+    """The details of one video, as returned by ``upload_video``."""
+
+    id: Optional[str] = None
+    name: Optional[str] = None
+    raw_file_id: Optional[str] = None
+
+    @classmethod
+    def from_api(cls, data: Mapping[str, Any]) -> "Video":
+        return cls(id=data.get("id"), name=data.get("name"), raw_file_id=data.get("rawFileId"))

fileboy/mime.py

@@ -0,0 +1,27 @@
+"""A small MIME type table so uploads from a path get a sensible content type.
+
+Pass ``mime=`` to ``upload_file`` for anything not listed here.
+"""
+
+import os
+
+TYPES = {
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".gif": "image/gif",
+    ".webp": "image/webp", ".avif": "image/avif", ".heic": "image/heic",
+    ".svg": "image/svg+xml", ".bmp": "image/bmp", ".tif": "image/tiff", ".tiff": "image/tiff",
+    ".mp4": "video/mp4", ".m4v": "video/mp4", ".mov": "video/quicktime",
+    ".webm": "video/webm", ".mkv": "video/x-matroska", ".avi": "video/x-msvideo",
+    ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4", ".ogg": "audio/ogg",
+    ".pdf": "application/pdf", ".zip": "application/zip", ".json": "application/json",
+    ".txt": "text/plain", ".csv": "text/csv", ".html": "text/html", ".vtt": "text/vtt",
+    ".srt": "text/plain", ".md": "text/markdown",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".xls": "application/vnd.ms-excel", ".doc": "application/msword",
+}
+
+
+def for_filename(name: str) -> str:
+    """Return the content type for a file name, or ``application/octet-stream``."""
+    return TYPES.get(os.path.splitext(str(name))[1].lower(), "application/octet-stream")

fileboy/token.py

@@ -0,0 +1,53 @@
+"""Signed tokens for apps that use a private key.
+
+The format is ``PUBLIC_KEY$NONCE$JWT``, where the JWT is HS256-signed with the private key. This
+is what the Fileboy API verifies, and what the Node client's ``createAccessToken`` produces.
+"""
+
+import base64
+import hashlib
+import hmac
+import json
+import secrets
+import string
+import time
+from typing import Any, Dict, Optional
+
+from .errors import InvalidArgumentError
+
+_ALPHANUMERIC = string.ascii_letters + string.digits
+
+
+def _b64(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+
+
+def _json(value: Any) -> bytes:
+    return json.dumps(value, separators=(",", ":")).encode("utf-8")
+
+
+def jwt(claims: Dict[str, Any], secret: str) -> str:
+    """Encode ``claims`` as an HS256 JWT."""
+    header = _b64(_json({"alg": "HS256", "typ": "JWT"}))
+    body = _b64(_json(claims))
+    signature = hmac.new(secret.encode("utf-8"), f"{header}.{body}".encode("ascii"), hashlib.sha256).digest()
+    return f"{header}.{body}.{_b64(signature)}"
+
+
+def build(
+    public_key: str,
+    private_key: str,
+    expires_in: float = 60,
+    payload: Optional[Dict[str, Any]] = None,
+    now: Optional[float] = None,
+) -> str:
+    """Build a ``PUBLIC$NONCE$JWT`` token. ``now`` is a Unix timestamp, for tests."""
+    if "$" in public_key or "$" in private_key:
+        raise InvalidArgumentError("Keys must not contain a $ symbol")
+
+    nonce = "".join(secrets.choice(_ALPHANUMERIC) for _ in range(32))
+    iat = int(time.time() if now is None else now)
+    claims: Dict[str, Any] = {"v": 3, "token": nonce, "iat": iat, "exp": iat + int(expires_in)}
+    if payload:
+        claims["payload"] = payload
+    return "$".join([public_key, nonce, jwt(claims, private_key)])

fileboy/transforms.py

@@ -0,0 +1,149 @@
+"""Build the value of the ``transform`` query parameter on image URLs.
+
+For example ``resize:300x_~fit:cover;format:webp;quality:75``. It only emits what the Fileboy
+image service understands: resize, format, quality, background and invert.
+"""
+
+import re
+from typing import Any, Iterable, List, Mapping, Optional, Union
+
+from .errors import InvalidArgumentError
+
+FITS = ("contain", "cover", "fill", "inside", "outside")
+POSITIONS = (
+    "top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right",
+)
+FORMATS = ("jpeg", "jpg", "png", "bmp", "tiff", "tif", "webp")
+TYPES = ("resize", "format", "quality", "background", "invert")
+
+_HEX = r"(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})"
+_HEX_CALL = re.compile(r"hex\(" + _HEX + r"\)", re.IGNORECASE)
+_HEX_BARE = re.compile(_HEX, re.IGNORECASE)
+_AXIS_ORDER = ("top", "bottom", "left", "right")
+
+TransformsInput = Union[None, str, Mapping[str, Any], Iterable[Mapping[str, Any]]]
+
+
+def build(transforms: TransformsInput) -> str:
+    """Return the query value, or ``""`` when there is nothing to apply.
+
+    ``transforms`` can be:
+
+    * a list of dicts like ``{"type": "resize", "width": 300, "fit": "cover"}``, applied in order
+    * a dict of ``name -> value``, like ``{"resize": "300x_", "format": "webp", "quality": 75}``
+    * a string, passed through untouched
+    """
+    if transforms is None:
+        return ""
+    if isinstance(transforms, str):
+        return transforms
+    if isinstance(transforms, Mapping):
+        parts = (_shorthand(name, value) for name, value in transforms.items())
+        return ";".join(p for p in parts if p is not None)
+    if isinstance(transforms, (list, tuple)):
+        return ";".join(_build_one(t) for t in transforms)
+    raise InvalidArgumentError("transforms must be a list, dict or string")
+
+
+def _shorthand(name: Any, value: Any) -> Optional[str]:
+    if value is None or str(value) == "":
+        return None
+    if value is True:
+        return str(name)
+    return f"{name}:{value}"
+
+
+def _build_one(transform: Any) -> str:
+    if not isinstance(transform, Mapping):
+        raise InvalidArgumentError("Each transform must be a dict with a 'type'")
+    kind = str(transform.get("type"))
+    if kind not in TYPES:
+        raise InvalidArgumentError(f"Unknown transform {kind!r}. Use one of: {', '.join(TYPES)}")
+    return _BUILDERS[kind](transform)
+
+
+def _is_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def _build_invert(_t: Mapping[str, Any]) -> str:
+    return "invert"
+
+
+def _build_format(t: Mapping[str, Any]) -> str:
+    return f"format:{_format_name(t.get('format'))}"
+
+
+def _build_quality(t: Mapping[str, Any]) -> str:
+    value = t.get("value")
+    if not (_is_int(value) and 1 <= value <= 100):
+        raise InvalidArgumentError("quality must be a whole number from 1 to 100")
+    return f"quality:{value}"
+
+
+def _build_background(t: Mapping[str, Any]) -> str:
+    return f"background:{_color(t.get('color'))}"
+
+
+def _build_resize(t: Mapping[str, Any]) -> str:
+    width = t.get("width")
+    height = t.get("height")
+    if width is None and height is None:
+        raise InvalidArgumentError("resize needs a width, a height or both")
+    for n in (width, height):
+        if n is not None and not (_is_int(n) and n > 0):
+            raise InvalidArgumentError("resize width and height must be positive whole numbers")
+
+    out = f"resize:{'_' if width is None else width}x{'_' if height is None else height}"
+    if t.get("position"):
+        out += f"~position:{_position(t['position'])}"
+    if t.get("fit"):
+        out += f"~fit:{_choice(t['fit'], FITS, 'fit')}"
+    if t.get("background"):
+        out += f"~background:{_color(t['background'])}"
+    if t.get("format"):
+        out += f"~format:{_format_name(t['format'])}"
+    return out
+
+
+def _position(value: Any) -> str:
+    # "right top", "top right" and "top-right" all mean the same corner, which the image service
+    # spells top-right (vertical word first).
+    parts = [p for p in re.split(r"[\s-]+", str(value).lower().strip()) if p]
+    if len(parts) == 2:
+        parts.sort(key=lambda p: _AXIS_ORDER.index(p) if p in _AXIS_ORDER else 9)
+    return _choice("-".join(parts), POSITIONS, "position")
+
+
+def _format_name(value: Any) -> str:
+    return _choice(value, FORMATS, "format")
+
+
+def _choice(value: Any, allowed: Iterable[str], label: str) -> str:
+    allowed = tuple(allowed)
+    v = str(value).lower()
+    if v not in allowed:
+        raise InvalidArgumentError(f"Unsupported {label} {value!r}. Use one of: {', '.join(allowed)}")
+    return v
+
+
+def _color(value: Any) -> str:
+    """``#fff``, ``#ffffff`` and ``#ffffff80`` become ``hex(...)``. ``hex(...)`` is kept."""
+    s = str(value)
+    if _HEX_CALL.fullmatch(s):
+        return s
+    bare = s[1:] if s.startswith("#") else s
+    if not _HEX_BARE.fullmatch(bare):
+        raise InvalidArgumentError(f"Colours must be hex, like #ff8800 (got {value!r})")
+    return f"hex({bare})"
+
+
+_BUILDERS = {
+    "resize": _build_resize,
+    "format": _build_format,
+    "quality": _build_quality,
+    "background": _build_background,
+    "invert": _build_invert,
+}
+
+__all__: List[str] = ["build", "FITS", "POSITIONS", "FORMATS", "TYPES"]

fileboy/webhooks.py

@@ -0,0 +1,106 @@
+"""Verify webhooks sent by Fileboy.
+
+Every delivery is a POST with a JSON body and two headers:
+
+* ``Fileboy-Timestamp``: unix time in seconds when it was sent
+* ``Fileboy-Signature``: ``v1=`` and the hex HMAC-SHA256, keyed with your endpoint's signing
+  secret, of the string ``"<timestamp>.<raw body>"``
+
+Use the exact bytes received. Parsing and re-serialising the JSON changes them and breaks the
+signature::
+
+    event = fileboy.verify_webhook(request.body, request.headers, settings.FILEBOY_WEBHOOK_SECRET)
+    event["type"]  # "video.ready"
+"""
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict, Mapping, Optional, Union
+
+from .errors import FileboyError
+
+SIGNATURE_HEADER = "Fileboy-Signature"
+TIMESTAMP_HEADER = "Fileboy-Timestamp"
+DEFAULT_TOLERANCE_SECONDS = 300
+
+
+class WebhookVerificationError(FileboyError):
+    """Raised by :func:`verify_webhook`. ``code`` is one of ``missing_header``,
+    ``invalid_timestamp``, ``timestamp_out_of_tolerance``, ``invalid_signature`` or
+    ``invalid_body``."""
+
+
+def _error(code: str, message: str) -> WebhookVerificationError:
+    return WebhookVerificationError(message, code=code)
+
+
+def sign_webhook(raw_body: Union[str, bytes], timestamp: int, secret: str) -> str:
+    """The signature Fileboy sends for this secret, timestamp and body. Mostly useful in tests."""
+    body = raw_body.encode("utf-8") if isinstance(raw_body, str) else bytes(raw_body)
+    mac = hmac.new(secret.encode("utf-8"), f"{int(timestamp)}.".encode("ascii") + body, hashlib.sha256)
+    return "v1=" + mac.hexdigest()
+
+
+def _read_header(headers: Mapping[str, Any], name: str) -> Optional[str]:
+    """Find a header however the framework spells it: ``Fileboy-Signature``, lower case, or the
+    WSGI/Django ``META`` key ``HTTP_FILEBOY_SIGNATURE``."""
+    for key in (name, name.lower(), "HTTP_" + name.upper().replace("-", "_")):
+        try:
+            value = headers[key]
+        except (KeyError, TypeError):
+            continue
+        if value is not None:
+            return str(value)
+    for key in list(headers.keys()):
+        if str(key).lower() == name.lower():
+            return str(headers[key])
+    return None
+
+
+def verify_webhook(
+    raw_body: Union[str, bytes],
+    headers: Mapping[str, Any],
+    secret: str,
+    tolerance_seconds: int = DEFAULT_TOLERANCE_SECONDS,
+    now: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Check a webhook really came from Fileboy and is recent, then return the parsed event.
+
+    Args:
+        raw_body: the request body exactly as received (``bytes`` or ``str``).
+        headers: the request headers, in any case. Django, Flask and plain dicts all work.
+        secret: the endpoint's signing secret from the dashboard.
+        tolerance_seconds: how far from now the timestamp may be.
+        now: replaces the current time in unix seconds, for tests.
+
+    Raises:
+        WebhookVerificationError: with a ``code`` saying what was wrong.
+    """
+    if not isinstance(raw_body, (str, bytes, bytearray)):
+        raise _error("invalid_body", "The body must be the raw bytes or string received, not parsed JSON")
+
+    timestamp_header = _read_header(headers, TIMESTAMP_HEADER)
+    signature_header = _read_header(headers, SIGNATURE_HEADER)
+    if not timestamp_header or not signature_header:
+        raise _error("missing_header", f"Missing {TIMESTAMP_HEADER} or {SIGNATURE_HEADER} header")
+    if not (timestamp_header.isascii() and timestamp_header.isdigit()):
+        raise _error("invalid_timestamp", "Timestamp is not a number")
+
+    timestamp = int(timestamp_header)
+    current = int(time.time() if now is None else now)
+    if abs(current - timestamp) > tolerance_seconds:
+        raise _error("timestamp_out_of_tolerance", "Timestamp is outside of the allowed time window")
+
+    expected = sign_webhook(raw_body, timestamp, secret)
+    # More than one signature may be sent in future, for example while rotating secrets
+    candidates = [c for c in signature_header.replace(",", " ").split() if c]
+    if not any(hmac.compare_digest(c.encode("utf-8"), expected.encode("utf-8")) for c in candidates):
+        raise _error("invalid_signature", "Signature does not match")
+
+    try:
+        text = raw_body.decode("utf-8") if isinstance(raw_body, (bytes, bytearray)) else raw_body
+        return json.loads(text)
+    except ValueError:
+        raise _error("invalid_body", "Body is not valid JSON")

fileboy-0.1.0.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: fileboy
+Version: 0.1.0
+Summary: Official Python client for Fileboy: upload files and videos, build image transform URLs, read video data.
+Author: Fileboy
+License: MIT
+Project-URL: Homepage, https://fileboy.io/docs/libraries/python
+Project-URL: Documentation, https://fileboy.io/docs/libraries/python
+Project-URL: Changelog, https://github.com/CD2/Fileboy/blob/master/packages/python/CHANGELOG.md
+Keywords: fileboy,file upload,image resize,video hosting,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: requests>=2.25; extra == "dev"
+Dynamic: license-file
+
+# Fileboy for Python
+
+The official Python client for [Fileboy](https://fileboy.io): upload files and videos, build image
+URLs that resize on the fly, and read video data. Its only dependency is `requests`.
+
+## Install
+
+```bash
+pip install fileboy
+```
+
+Python 3.8 or newer.
+
+## Quick start
+
+```python
+import os
+import fileboy
+
+client = fileboy.Client(public_key=os.environ["FILEBOY_PUBLIC_KEY"])
+
+file = client.upload_file("report.pdf")   # a path, a binary file object or bytes
+print(file.id)                            # store this
+
+client.build_file_url(file.id, download=True)
+client.build_image_url(file.id, transforms=[{"type": "resize", "width": 300}, {"type": "format", "format": "webp"}])
+# https://api.fileboy.io/images/get/<id>?transform=resize:300x_;format:webp
+```
+
+## Django and other frameworks
+
+Configure once, then call `fileboy.client()` anywhere:
+
+```python
+# settings.py (or an AppConfig.ready())
+import os
+import fileboy
+
+fileboy.configure(
+    public_key=os.environ["FILEBOY_PUBLIC_KEY"],
+    # private_key=...,   only if your app uses signed requests
+    # api_url="https://api.fileboy.io",
+)
+```
+
+```python
+# views.py
+import fileboy
+
+def upload(request):
+    file = fileboy.client().upload_file(request.FILES["file"], name=request.FILES["file"].name)
+    ...
+```
+
+`FILEBOY_PUBLIC_KEY`, `FILEBOY_PRIVATE_KEY` and `FILEBOY_API_URL` are read from the environment when you do not set them.
+
+## What you can do
+
+| Task | Method |
+| --- | --- |
+| Upload a path, file object or bytes | `upload_file(file, name=, mime=, metadata=)` |
+| Upload from a path | `upload_file_from_path(path, ...)` |
+| Upload from a URL | `upload_file_from_url(url, name=, metadata=, expect=)` |
+| File details | `fetch_file_data(id_or_label)` |
+| File URL | `build_file_url(id_or_label, filename=, download=)` |
+| Image URL with transforms | `build_image_url(id_or_label, transforms=, filename=, download=)` |
+| Download bytes | `download_file(id_or_label, range=)`, `download_image(id_or_label, transforms=, range=)` |
+| Upload a video | `upload_video(file, name=, mime=)` |
+| Video details | `fetch_video_data(id)`, `fetch_video_info(id)` |
+| Manifest and poster URLs | `build_video_manifest_url(id, type="hls")`, `build_video_poster_url(id)` |
+| Custom poster | `upload_video_poster(video_id, image)`, `download_video_poster(video_id)` |
+| Transcripts | `upload_video_transcript(id, file, language="English")`, `fetch_video_transcript(id, transcript_id)` |
+| Signed access token | `create_access_token(read=, write=, upload=, expires_in=)` |
+
+An id that is a UUID is used as is. Anything else is treated as a label in your app, and a value
+that already contains a `+` is passed through. Labels are created in the dashboard.
+
+Uploads return a `FileData` dataclass (`id`, `name`, `original_filename`, `mime`, `metadata`,
+`file_size`, `content_hash`, `signed`, `dies_at`, `created_at`). `upload_video` returns a `Video`
+(`id`, `name`, `raw_file_id`). `range` is a `(first_byte, last_byte)` tuple.
+
+### Image transforms
+
+`transforms=` takes a list of dicts applied in order. The image service supports `resize`,
+`format`, `quality`, `background` and `invert`:
+
+```python
+[
+    {"type": "resize", "width": 200, "height": 200, "fit": "cover"},   # fit: contain cover fill inside outside
+    {"type": "resize", "width": 400, "fit": "contain", "position": "top-left", "background": "#ffffff"},
+    {"type": "format", "format": "webp"},                              # jpeg png webp tiff bmp
+    {"type": "quality", "value": 75},
+    {"type": "background", "color": "#fff"},
+    {"type": "invert"},
+]
+```
+
+You can also pass a dict of `name: value`, such as `{"resize": "300x_", "format": "webp", "quality": 75}`, or a ready-made string.
+
+## Errors
+
+Every error is a `FileboyError` with `status`, `code` (the API's error code) and `body`.
+
+| Class | When |
+| --- | --- |
+| `AuthenticationError` | 401 |
+| `FileboyPermissionError` | 403, including plan limits |
+| `NotFoundError` | 404 |
+| `RateLimitError` | 429 |
+| `BadRequestError` | other 4xx, such as a file that is too large |
+| `ServerError` | 5xx |
+| `FileboyConnectionError` | timeouts and network failures |
+| `InvalidArgumentError`, `ConfigurationError` | bad arguments, before any request |
+
+`FileboyPermissionError` and `FileboyConnectionError` are prefixed so they do not shadow the
+Python built-ins `PermissionError` and `ConnectionError`.
+
+## Notes
+
+* File, image and video reads need no authorization, so URL builders never sign anything.
+* The shared `demo` key only accepts small images and cannot upload video.
+* There is no endpoint yet to update, delete or list files, so the client has no such methods.
+* The client uses a `requests.Session`, so connections are reused between calls.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+The tests run against a local fake server. The transform builder is also checked against
+`packages/sdk-fixtures/transforms.json`, the same cases the Go image parser is tested with.
+
+MIT licensed.
+
+## Webhooks
+
+Verify the requests Fileboy sends to your endpoints. Use the raw body, exactly as received:
+
+```python
+# Django
+import fileboy
+from django.http import HttpResponse, HttpResponseBadRequest
+from django.views.decorators.csrf import csrf_exempt
+
+@csrf_exempt
+def fileboy_webhook(request):
+    try:
+        event = fileboy.verify_webhook(request.body, request.headers, settings.FILEBOY_WEBHOOK_SECRET)
+    except fileboy.WebhookVerificationError as error:
+        return HttpResponseBadRequest(error.code)  # "invalid_signature", "timestamp_out_of_tolerance", ...
+    if event["type"] == "video.ready":
+        ...  # event["resource"]["urls"]["hls"], event["resource"]["duration"]
+    return HttpResponse(status=200)
+```
+
+`verify_webhook` returns the parsed event (a dict) or raises `WebhookVerificationError`. The timestamp
+must be within 5 minutes (`tolerance_seconds=` changes that). Events carry a unique `id` that is the same
+on every retry, so use it to ignore duplicates. `fileboy.sign_webhook(body, timestamp, secret)` builds a
+signature for your own tests.
+
+## Publishing (maintainers)
+
+You need a [PyPI](https://pypi.org) account that owns `fileboy` (the first upload claims the name) and an API token (account settings, scope: that project once it exists). Try [TestPyPI](https://test.pypi.org) first.
+
+1. Bump the version in `src/fileboy/_version.py` and `pyproject.toml` (keep them equal) and add a section to `CHANGELOG.md`.
+2. `pip install -e '.[dev]' && pytest` must pass.
+3. `python -m pip install build twine && rm -rf dist && python -m build && twine check dist/*`
+4. Rehearse: `twine upload --repository testpypi dist/*`.
+5. Publish: `twine upload dist/*` with username `__token__` and the API token as the password.
+6. Tag the commit: `git tag python-vX.Y.Z && git push origin python-vX.Y.Z`.
+
+PyPI never lets you reuse a version number, so bump it for every fix.

fileboy-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+fileboy/__init__.py,sha256=LW94VsrGInvARSJei-yPStf06RkPVlm-QiAMNmb98FA,3033
+fileboy/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+fileboy/client.py,sha256=l8gC55TCLWlORPUsTCqiK5uVpAJmAXg2hGAiBkJKLB0,16220
+fileboy/errors.py,sha256=UtG5MmnywnqU6ScQ4JIuONmM2AC3jN0R2cxsIXraf3U,1502
+fileboy/file_data.py,sha256=ffRd_bdDODGByZC-TrAY8ajJl0TvAnIRwk4AsAW5iBc,2098
+fileboy/mime.py,sha256=XFeQDzm-QXJ9042yR_xGLTB-QMwb5f1pD0EvKNAGFnE,1441
+fileboy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fileboy/token.py,sha256=1E7PSAhQWigNttRLZ8o6FGvxCXd_hcsxpI7Ax6yRjVg,1741
+fileboy/transforms.py,sha256=2G5mhd4Tj_JgkNWLMfdqae-WBXd7jl18IiIJP6JlB68,5248
+fileboy/webhooks.py,sha256=5N-9k7G8mvUu_U2odgGtErn4u6EgKCBufy8RV2RI4L8,4423
+fileboy-0.1.0.dist-info/licenses/LICENSE,sha256=tUG1zhm-40RO51aTvOxwTFbVPQpMn1gkoSO0IxwGuOU,1069
+fileboy-0.1.0.dist-info/METADATA,sha256=litAgGaPj5wE1njUJnXmAKw48RAK9cNEsE4NpUqdLjE,8286
+fileboy-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fileboy-0.1.0.dist-info/top_level.txt,sha256=vHXKzU-YZZJUuulcaBeV477m-ZM1KheoNI3Kgn1QQrk,8
+fileboy-0.1.0.dist-info/RECORD,,

fileboy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fileboy-0.1.0.dist-info/licenses/LICENSE

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

fileboy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fileboy