flyewin 0.1.0__py3-none-any.whl

flyewin/__init__.py

@@ -0,0 +1,5 @@
+"""Official client for the flye.win APIs. See https://flye.win/docs."""
+
+from ._client import DEFAULT_BASE_URL, FileInput, Flye, FlyeError, Response, __version__
+
+__all__ = ["Flye", "FlyeError", "FileInput", "Response", "DEFAULT_BASE_URL", "__version__"]

flyewin/_client.py

@@ -0,0 +1,490 @@
+"""Official client for the flye.win APIs.
+
+Generated from the API catalog by cmd/sdkgen. Do not edit by hand.
+"""
+
+from __future__ import annotations
+
+import json
+import mimetypes
+import os
+import random
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import IO, Any, Dict, List, Mapping, Optional, Tuple, Union
+
+__version__ = "0.1.0"
+DEFAULT_BASE_URL = "https://flye.win" + "/v1"
+
+#: A file to upload: raw bytes, an open binary file, a path, or (filename, bytes[, content_type]).
+FileInput = Union[bytes, bytearray, IO[bytes], "os.PathLike[str]", str, Tuple[str, bytes], Tuple[str, bytes, str]]
+
+
+class FlyeError(Exception):
+    """Raised for every failed call. ``code`` is stable: "rate_limited", "invalid_api_key"..."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: Optional[int] = None,
+        code: str = "error",
+        body: Any = None,
+        headers: Optional[Mapping[str, str]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.body = body
+        self.headers = dict(headers or {})
+
+    def __repr__(self) -> str:
+        return f"FlyeError(status={self.status!r}, code={self.code!r}, message={self.message!r})"
+
+
+class Response:
+    """Status and headers of the last response (X-RateLimit-*, X-Quota-*, X-Flye-Mode)."""
+
+    def __init__(self, status: int, headers: Mapping[str, str]) -> None:
+        self.status = status
+        self.headers = {k.lower(): v for k, v in headers.items()}
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
+def _file(value: Any, field: str) -> Tuple[str, bytes, str]:
+    if isinstance(value, tuple):
+        name, data = value[0], value[1]
+        ctype = value[2] if len(value) > 2 else None
+    elif isinstance(value, (bytes, bytearray)):
+        name, data, ctype = field, bytes(value), None
+    elif hasattr(value, "read"):
+        data = value.read()
+        name, ctype = os.path.basename(getattr(value, "name", field) or field), None
+    elif isinstance(value, (str, os.PathLike)):
+        path = os.fspath(value)
+        with open(path, "rb") as fh:
+            data = fh.read()
+        name, ctype = os.path.basename(path), None
+    else:
+        raise FlyeError("File parameters take bytes, an open binary file, a path or (filename, bytes).", code="invalid_file")
+    if isinstance(data, str):
+        data = data.encode()
+    ctype = ctype or mimetypes.guess_type(name)[0] or "application/octet-stream"
+    return name, bytes(data), ctype
+
+
+def _multipart(fields: List[Tuple[str, str]], files: List[Tuple[str, Tuple[str, bytes, str]]]) -> Tuple[bytes, str]:
+    boundary = "flyewin-" + uuid.uuid4().hex
+    out = bytearray()
+    for name, value in fields:
+        out += f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"\r\n\r\n'.encode()
+        out += value.encode() + b"\r\n"
+    for name, (filename, data, ctype) in files:
+        safe = filename.replace('"', "")
+        out += f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"; filename="{safe}"\r\n'.encode()
+        out += f"Content-Type: {ctype}\r\n\r\n".encode()
+        out += data + b"\r\n"
+    out += f"--{boundary}--\r\n".encode()
+    return bytes(out), f"multipart/form-data; boundary={boundary}"
+
+
+def _decode(raw: bytes, ctype: str) -> Any:
+    if not raw:
+        return None
+    if "json" in ctype:
+        try:
+            return json.loads(raw.decode("utf-8"))
+        except ValueError:
+            return raw.decode("utf-8", "replace")
+    if ctype.startswith("text/"):
+        return raw.decode("utf-8", "replace")
+    return raw
+
+
+def _backoff(attempt: int) -> float:
+    return min(8.0, 0.5 * 2**attempt) * (0.75 + random.random() * 0.5)
+
+
+class Flye:
+    """Client for the flye.win APIs.
+
+    >>> from flyewin import Flye
+    >>> flye = Flye()  # reads FLYE_API_KEY
+    >>> flye.utils.uuid(count=2)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("FLYE_API_KEY") or ""
+        if not self.api_key:
+            raise FlyeError("Missing API key: pass Flye(api_key) or set FLYE_API_KEY.", code="missing_api_key")
+        self.base_url = (base_url or os.environ.get("FLYE_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        #: Status and headers of the last response.
+        self.last_response: Optional[Response] = None
+        #: Stickers — Search stickers and animated GIFs, with ready-to-use links.
+        self.stickers = _Stickers(self)
+        #: CDN — Image hosting with public links, organized in projects and folders.
+        self.cdn = _Cdn(self)
+        #: Utils — UUIDs, hashes, base64 and IP inspection in one call.
+        self.utils = _Utils(self)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: List[Tuple[str, str, Any]],
+        extra: Optional[Dict[str, Any]] = None,
+        *,
+        default: str = "query",
+        timeout: Optional[float] = None,
+    ) -> Any:
+        """Low-level call used by every method. ``params`` is a list of (name, location, value)."""
+        query: List[Tuple[str, str]] = []
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "User-Agent": f"flyewin-python/{__version__}",
+        }
+        body_json: Dict[str, Any] = {}
+        fields: List[Tuple[str, str]] = []
+        files: List[Tuple[str, Tuple[str, bytes, str]]] = []
+        items = list(params) + [(k, default, v) for k, v in (extra or {}).items()]
+        for name, where, value in items:
+            if value is None:
+                continue
+            if where == "path":
+                path = path.replace("{" + name + "}", urllib.parse.quote(_text(value), safe=""))
+            elif where == "query":
+                for item in value if isinstance(value, (list, tuple)) else [value]:
+                    query.append((name, _text(item)))
+            elif where == "header":
+                headers[name] = _text(value)
+            elif where == "file":
+                files.append((name, _file(value, name)))
+            elif where == "form":
+                if isinstance(value, (bytes, bytearray, tuple)) or hasattr(value, "read"):
+                    files.append((name, _file(value, name)))
+                else:
+                    fields.append((name, _text(value)))
+            else:
+                body_json[name] = value
+        if "{" in path:
+            raise FlyeError(f"Missing path parameter in {method} {path}.", code="missing_param")
+
+        data: Optional[bytes] = None
+        if files or fields:
+            data, headers["Content-Type"] = _multipart(fields, files)
+        elif body_json or default == "body":
+            data = json.dumps(body_json).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        url = self.base_url + path + ("?" + urllib.parse.urlencode(query) if query else "")
+        idempotent = method == "GET"
+
+        attempt = 0
+        while True:
+            req = urllib.request.Request(url, data=data, headers=headers, method=method)
+            try:
+                with urllib.request.urlopen(req, timeout=timeout or self.timeout) as resp:
+                    self.last_response = Response(resp.status, resp.headers)
+                    return _decode(resp.read(), resp.headers.get("Content-Type", ""))
+            except urllib.error.HTTPError as err:
+                raw = err.read()
+                self.last_response = Response(err.code, err.headers)
+                payload = _decode(raw, err.headers.get("Content-Type", ""))
+                retry_after = 0.0
+                try:
+                    retry_after = float(err.headers.get("Retry-After") or 0)
+                except ValueError:
+                    pass
+                # 429 with a short Retry-After (per-minute limit) and 5xx on reads are worth another try.
+                can_retry = (err.code == 429 and 0 < retry_after <= 60) or (idempotent and err.code >= 500)
+                if can_retry and attempt < self.max_retries:
+                    time.sleep(retry_after if err.code == 429 else _backoff(attempt))
+                    attempt += 1
+                    continue
+                info = payload.get("error") if isinstance(payload, dict) else None
+                info = info if isinstance(info, dict) else {}
+                raise FlyeError(
+                    info.get("message") or f"HTTP {err.code}",
+                    status=err.code,
+                    code=info.get("code") or "http_error",
+                    body=payload,
+                    headers=err.headers,
+                ) from None
+            except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError) as err:
+                if idempotent and attempt < self.max_retries:
+                    time.sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                reason = getattr(err, "reason", err)
+                timed_out = isinstance(reason, (socket.timeout, TimeoutError))
+                raise FlyeError(
+                    "Request timed out." if timed_out else f"Network error: {reason}",
+                    code="timeout" if timed_out else "network_error",
+                ) from err
+
+
+class _Stickers:
+    """Stickers — Search stickers and animated GIFs, with ready-to-use links.
+
+    Docs: https://flye.win/apis/stickers
+    """
+
+    def __init__(self, client: Flye) -> None:
+        self._client = client
+
+    def search(self, *, q: Optional[str] = None, end_user_id: Optional[str] = None, max_wait_ms: Optional[int] = None, limit: Optional[int] = None, type: Optional[str] = None, page: Optional[int] = None, rotate: Optional[bool] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Search stickers
+
+        Returns the most relevant pack for the term, with a link for each sticker. With rotate=true, each call returns the next pack, so bots don't repeat the same result. A term never searched before may come right away with partial=true, with what we already have, while the full search finishes.
+
+        Args:
+            q: Search term, 2 to 80 characters. Without it, the response has 30 featured stickers, drawn on every call, with trending=true. Example: gato
+            end_user_id: Scale plan: identifies the user on your platform, so the limit applies per user and not to the account. Use a stable id, preferably a hash.
+            max_wait_ms: Longest wait for a term never searched before, 0 to 15000 ms. Past that, the response returns right away with pending=true and the search continues: repeat the call shortly. Without it, waits for the result. Example: 300
+            limit: Stickers per response, 1 to 30. Defaults to 30. Example: 10
+            type: all, animated or static. Defaults to all.
+            page: Pack position in the ranking, starting at 1. Defaults to 1.
+            rotate: true returns the next pack on each call from this account. Ignores page.
+
+        Docs: https://flye.win/apis/stickers
+        """
+        return self._client.request(
+            "GET", "/stickers/search", [("q", "query", q), ("X-End-User-Id", "header", end_user_id), ("max_wait_ms", "query", max_wait_ms), ("limit", "query", limit), ("type", "query", type), ("page", "query", page), ("rotate", "query", rotate)], extra, default="query", timeout=timeout
+        )
+
+    def list_packs(self, *, q: str, end_user_id: Optional[str] = None, max_wait_ms: Optional[int] = None, limit: Optional[int] = None, page: Optional[int] = None, type: Optional[str] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """List packs
+
+        Lists the packs found for the term, with a cover sticker, so you can build a picker.
+
+        Args:
+            q: Search term, 2 to 80 characters. Example: gato
+            end_user_id: Scale plan: identifies the user on your platform, so the limit applies per user and not to the account. Use a stable id, preferably a hash.
+            max_wait_ms: Longest wait for a term never searched before, 0 to 15000 ms. Past that, the response returns right away with pending=true and the search continues: repeat the call shortly. Without it, waits for the result. Example: 300
+            limit: Packs per page, 1 to 20. Defaults to 10. Example: 5
+            page: Page, starting at 1.
+            type: all, animated or static. Defaults to all.
+
+        Docs: https://flye.win/apis/stickers
+        """
+        return self._client.request(
+            "GET", "/stickers/packs", [("q", "query", q), ("X-End-User-Id", "header", end_user_id), ("max_wait_ms", "query", max_wait_ms), ("limit", "query", limit), ("page", "query", page), ("type", "query", type)], extra, default="query", timeout=timeout
+        )
+
+    def get_pack(self, id: str, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Stickers in a pack
+
+        Returns every sticker in a pack by its id.
+
+        Args:
+            id: Pack id, from /search or /packs.
+
+        Docs: https://flye.win/apis/stickers
+        """
+        return self._client.request(
+            "GET", "/stickers/packs/{id}", [("id", "path", id)], extra, default="query", timeout=timeout
+        )
+
+class _Cdn:
+    """CDN — Image hosting with public links, organized in projects and folders.
+
+    Docs: https://flye.win/apis/cdn
+    """
+
+    def __init__(self, client: Flye) -> None:
+        self._client = client
+
+    def upload(self, *, image: FileInput, project: str, folder: Optional[str] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Upload an image
+
+        Uploads one image as multipart/form-data. The project is created the first time you use it. Accepts jpg, jpeg, png, gif, webp, svg, up to your plan's per-file limit. The type is checked from the file's content, and SVG with scripts or external links is rejected.
+
+        Args:
+            image: The file. Also accepted under the name file.
+            project: Project name: letters, numbers, - and _, up to 48 characters. Uppercase becomes lowercase.
+            folder: Folder inside the project, optional, with the same rules as the name.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "POST", "/cdn/upload", [("image", "file", image), ("project", "form", project), ("folder", "form", folder)], extra, default="form", timeout=timeout
+        )
+
+    def list_projects(self, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """List projects
+
+        Lists your account's projects, with the image count and storage used by each.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "GET", "/cdn/projects", [], extra, default="query", timeout=timeout
+        )
+
+    def create_project(self, *, name: str, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Create a project
+
+        Creates an empty project. Optional: uploading already creates the project when it doesn't exist.
+
+        Args:
+            name: Project name.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "POST", "/cdn/projects", [("name", "body", name)], extra, default="body", timeout=timeout
+        )
+
+    def get_project(self, project: str, *, folder: Optional[str] = None, page: Optional[int] = None, per_page: Optional[int] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """List images
+
+        Lists the project's images, newest first, and the folders it has.
+
+        Args:
+            project: Project name.
+            folder: Only this folder's images. Without it, every image in the project. Use / for only those outside folders.
+            page: Page, starting at 1.
+            per_page: Items per page, 1 to 100. Defaults to 20.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "GET", "/cdn/projects/{project}", [("project", "path", project), ("folder", "query", folder), ("page", "query", page), ("per_page", "query", per_page)], extra, default="query", timeout=timeout
+        )
+
+    def get_image(self, id: str, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Image details
+
+        Returns one of your images by the id returned on upload.
+
+        Args:
+            id: Image id.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "GET", "/cdn/images/{id}", [("id", "path", id)], extra, default="query", timeout=timeout
+        )
+
+    def delete_image(self, id: str, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Delete an image
+
+        Deletes the image and frees the space right away. The link stops working within moments.
+
+        Args:
+            id: Image id.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "DELETE", "/cdn/images/{id}", [("id", "path", id)], extra, default="query", timeout=timeout
+        )
+
+    def delete_project(self, project: str, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Delete a project
+
+        Deletes the project with all its images and frees the space right away. This can't be undone.
+
+        Args:
+            project: Project name.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "DELETE", "/cdn/projects/{project}", [("project", "path", project)], extra, default="query", timeout=timeout
+        )
+
+    def get_usage(self, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Storage and limits
+
+        Shows the storage used, your plan's limits and the largest file accepted. A null limit means unlimited.
+
+        Docs: https://flye.win/apis/cdn
+        """
+        return self._client.request(
+            "GET", "/cdn/usage", [], extra, default="query", timeout=timeout
+        )
+
+class _Utils:
+    """Utils — UUIDs, hashes, base64 and IP inspection in one call.
+
+    Docs: https://flye.win/apis/utils
+    """
+
+    def __init__(self, client: Flye) -> None:
+        self._client = client
+
+    def uuid(self, *, count: Optional[int] = None, version: Optional[int] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Generate UUIDs
+
+        Generates 1 to 100 UUIDs. Version 7 sorts by time, which suits primary keys.
+
+        Args:
+            count: How many, from 1 to 100. Defaults to 1. Example: 2
+            version: 4 (random) or 7 (time-ordered). Defaults to 4. Example: 7
+
+        Docs: https://flye.win/apis/utils
+        """
+        return self._client.request(
+            "GET", "/utils/uuid", [("count", "query", count), ("version", "query", version)], extra, default="query", timeout=timeout
+        )
+
+    def hash(self, *, text: str, algo: Optional[str] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Compute a hash
+
+        Hashes the given text and returns it as hex.
+
+        Args:
+            text: Input text (up to 64 KB). Example: flye
+            algo: md5, sha1, sha256 or sha512. Defaults to sha256. Example: sha256
+
+        Docs: https://flye.win/apis/utils
+        """
+        return self._client.request(
+            "GET", "/utils/hash", [("text", "query", text), ("algo", "query", algo)], extra, default="query", timeout=timeout
+        )
+
+    def base64(self, *, text: str, mode: Optional[str] = None, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Encode / decode base64
+
+        Converts text to and from standard base64 (RFC 4648).
+
+        Args:
+            text: Content to convert.
+            mode: encode or decode. Defaults to encode.
+
+        Docs: https://flye.win/apis/utils
+        """
+        return self._client.request(
+            "POST", "/utils/base64", [("text", "body", text), ("mode", "body", mode)], extra, default="body", timeout=timeout
+        )
+
+    def ip(self, *, timeout: Optional[float] = None, **extra: Any) -> Any:
+        """Source IP
+
+        Returns the IP and user agent your request reached the platform with.
+
+        Docs: https://flye.win/apis/utils
+        """
+        return self._client.request(
+            "GET", "/utils/ip", [], extra, default="query", timeout=timeout
+        )

flyewin-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.1
+Name: flyewin
+Version: 0.1.0
+Summary: Official client for the flye.win APIs. No dependencies.
+License: MIT
+Project-URL: Homepage, https://flye.win
+Project-URL: Documentation, https://flye.win/docs
+Keywords: flye,flye.win,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# flyewin
+
+Official Python client for the [flye.win](https://flye.win) APIs. No dependencies, Python 3.8+.
+
+```sh
+pip install flyewin
+```
+
+```python
+from flyewin import Flye
+
+flye = Flye()  # reads FLYE_API_KEY, or Flye("flye_sk_...")
+
+print(flye.utils.uuid(count=2))
+```
+
+## Test keys
+
+Keys that start with `flye_test_` answer with the documented examples, need no plan and
+use no quota (30 requests/minute, 1,000/day). Use them while building and in CI, then
+switch to a `flye_sk_` key. Create both at https://flye.win/dashboard/keys.
+
+## Errors
+
+Every failure raises `FlyeError` with a stable `code`:
+
+```python
+from flyewin import Flye, FlyeError
+
+try:
+    flye.utils.hash(text="hi")
+except FlyeError as err:
+    if err.code == "rate_limited":
+        ...  # err.status == 429
+```
+
+Network errors and 5xx on GET requests are retried twice with backoff, and so is a `429`
+with a short `Retry-After`. Change it with `Flye(max_retries=0)`.
+
+Rate limit and quota headers of the last call are in `flye.last_response.headers`
+(`x-ratelimit-remaining`, `x-quota-remaining`).
+
+## Options
+
+`Flye(api_key=None, *, base_url="https://flye.win/v1", timeout=30.0, max_retries=2)`
+
+Every method also takes `timeout=` for that call.
+
+## Methods
+
+### Stickers — `flye.stickers`
+
+Search stickers and animated GIFs, with ready-to-use links. Docs: https://flye.win/apis/stickers
+
+| Method | HTTP | |
+| ------ | ---- | - |
+| `stickers.search()` | `GET /stickers/search` | Search stickers |
+| `stickers.list_packs(q="gato")` | `GET /stickers/packs` | List packs |
+| `stickers.get_pack("...")` | `GET /stickers/packs/{id}` | Stickers in a pack |
+
+### CDN — `flye.cdn`
+
+Image hosting with public links, organized in projects and folders. Docs: https://flye.win/apis/cdn
+
+| Method | HTTP | |
+| ------ | ---- | - |
+| `cdn.upload(image=open("photo.jpg", "rb"), project="...")` | `POST /cdn/upload` | Upload an image |
+| `cdn.list_projects()` | `GET /cdn/projects` | List projects |
+| `cdn.create_project(name="...")` | `POST /cdn/projects` | Create a project |
+| `cdn.get_project("...")` | `GET /cdn/projects/{project}` | List images |
+| `cdn.get_image("...")` | `GET /cdn/images/{id}` | Image details |
+| `cdn.delete_image("...")` | `DELETE /cdn/images/{id}` | Delete an image |
+| `cdn.delete_project("...")` | `DELETE /cdn/projects/{project}` | Delete a project |
+| `cdn.get_usage()` | `GET /cdn/usage` | Storage and limits |
+
+### Utils — `flye.utils`
+
+UUIDs, hashes, base64 and IP inspection in one call. Docs: https://flye.win/apis/utils
+
+| Method | HTTP | |
+| ------ | ---- | - |
+| `utils.uuid()` | `GET /utils/uuid` | Generate UUIDs |
+| `utils.hash(text="flye")` | `GET /utils/hash` | Compute a hash |
+| `utils.base64(text="...")` | `POST /utils/base64` | Encode / decode base64 |
+| `utils.ip()` | `GET /utils/ip` | Source IP |
+
+Uploads take bytes, an open binary file, a path, or `(filename, bytes)`.
+
+Full reference and the OpenAPI spec: https://flye.win/docs · https://flye.win/openapi.json

flyewin-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+flyewin/__init__.py,sha256=wUPO4ZBfJOa8-iBVx3Wt8_X8z42JvO3tVFZzb577o64,255
+flyewin/_client.py,sha256=6fqPd8X8bYi7VJHUjJAuIziKtCBu3b77C2QAjst9ZWc,20685
+flyewin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flyewin-0.1.0.dist-info/METADATA,sha256=B4ESIpIXwust9LzAUm4MZ1cz_PEw7jVbxfiusbE3ndM,3577
+flyewin-0.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+flyewin-0.1.0.dist-info/top_level.txt,sha256=mrJO_MYp7HsNnZu_aECHZdGTUi2XDCBkCI7yXr3O3rc,8
+flyewin-0.1.0.dist-info/RECORD,,

flyewin-0.1.0.dist-info/WHEEL

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

flyewin-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyewin