tachyon-api 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

tachyon_api/cache.py

@@ -0,0 +1,261 @@
+"""
+Cache utilities: decorator with TTL and pluggable backends.
+
+This module provides:
+- BaseCacheBackend protocol and an in-memory implementation
+- CacheConfig dataclass and helpers to set global/app config
+- cache decorator usable on any sync/async function (including routes)
+
+Design notes:
+- Key builder defaults to a stable representation of function + args/kwargs
+- Unless predicate allows opt-out per-call
+- TTL can be provided per-decorator or falls back to global default
+"""
+from __future__ import annotations
+
+import time
+import asyncio
+import hashlib
+import inspect
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any, Callable, Optional, Tuple
+
+
+class BaseCacheBackend:
+    """Minimal cache backend interface."""
+
+    def get(self, key: str) -> Any:  # pragma: no cover - interface
+        raise NotImplementedError
+
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:  # pragma: no cover - interface
+        raise NotImplementedError
+
+    def delete(self, key: str) -> None:  # pragma: no cover - interface
+        raise NotImplementedError
+
+    def clear(self) -> None:  # pragma: no cover - interface
+        raise NotImplementedError
+
+
+class InMemoryCacheBackend(BaseCacheBackend):
+    """Simple in-memory cache with TTL using wall-clock time."""
+
+    def __init__(self) -> None:
+        self._store: dict[str, Tuple[float | None, Any]] = {}
+
+    def _is_expired(self, expires_at: float | None) -> bool:
+        return expires_at is not None and time.time() >= expires_at
+
+    def get(self, key: str) -> Any:
+        item = self._store.get(key)
+        if not item:
+            return None
+        expires_at, value = item
+        if self._is_expired(expires_at):
+            # Lazy expiration
+            try:
+                del self._store[key]
+            except KeyError:
+                pass
+            return None
+        return value
+
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        expires_at = time.time() + ttl if ttl and ttl > 0 else None
+        self._store[key] = (expires_at, value)
+
+    def delete(self, key: str) -> None:
+        self._store.pop(key, None)
+
+    def clear(self) -> None:
+        self._store.clear()
+
+
+@dataclass
+class CacheConfig:
+    backend: BaseCacheBackend
+    default_ttl: float = 60.0
+    key_builder: Optional[Callable[[Callable, tuple, dict], str]] = None
+    enabled: bool = True
+
+
+_cache_config: Optional[CacheConfig] = None
+
+
+def _default_key_builder(func: Callable, args: tuple, kwargs: dict) -> str:
+    parts = [getattr(func, "__module__", ""), getattr(func, "__qualname__", ""), "|"]
+    # Stable kwargs order
+    items = [repr(a) for a in args] + [f"{k}={repr(v)}" for k, v in sorted(kwargs.items())]
+    raw_key = ":".join(parts + items)
+    return hashlib.sha256(raw_key.encode("utf-8")).hexdigest()
+
+
+def create_cache_config(
+    backend: Optional[BaseCacheBackend] = None,
+    default_ttl: float = 60.0,
+    key_builder: Optional[Callable[[Callable, tuple, dict], str]] = None,
+    enabled: bool = True,
+) -> CacheConfig:
+    """Create and set the global cache configuration.
+
+    Returns the created CacheConfig and sets it as the active global config.
+    """
+    global _cache_config
+    cfg = CacheConfig(
+        backend=backend or InMemoryCacheBackend(),
+        default_ttl=default_ttl,
+        key_builder=key_builder,
+        enabled=enabled,
+    )
+    _cache_config = cfg
+    return cfg
+
+
+def set_cache_config(config: CacheConfig) -> None:
+    """Set the global cache configuration object."""
+    global _cache_config
+    _cache_config = config
+
+
+def get_cache_config() -> CacheConfig:
+    """Get the current cache configuration, creating a default one if missing."""
+    global _cache_config
+    if _cache_config is None:
+        _cache_config = create_cache_config()
+    return _cache_config
+
+
+def cache(
+    TTL: Optional[float] = None,
+    *,
+    key_builder: Optional[Callable[[Callable, tuple, dict], str]] = None,
+    unless: Optional[Callable[[tuple, dict], bool]] = None,
+    backend: Optional[BaseCacheBackend] = None,
+):
+    """Cache decorator with TTL and pluggable backend.
+
+    Args:
+        TTL: Time-to-live in seconds for this decorator instance. Falls back to config.default_ttl.
+        key_builder: Optional custom function to build cache keys.
+        unless: Predicate receiving (args, kwargs). If returns True, skip cache for that call.
+        backend: Optional backend override for this decorator.
+    """
+
+    def decorator(func: Callable):
+        cfg = get_cache_config()
+        be = backend or cfg.backend
+        ttl_value = cfg.default_ttl if TTL is None else TTL
+        kb = key_builder or cfg.key_builder or (lambda f, a, kw: _default_key_builder(f, a, kw))
+
+        if asyncio.iscoroutinefunction(func):
+            @wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                if not cfg.enabled or (unless and unless(args, kwargs)):
+                    return await func(*args, **kwargs)
+                key = kb(func, args, kwargs)
+                cached = be.get(key)
+                if cached is not None:
+                    return cached
+                result = await func(*args, **kwargs)
+                try:
+                    be.set(key, result, ttl_value)
+                except Exception:
+                    # Backend errors should not break the app
+                    pass
+                return result
+
+            return async_wrapper
+        else:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                if not cfg.enabled or (unless and unless(args, kwargs)):
+                    return func(*args, **kwargs)
+                key = kb(func, args, kwargs)
+                cached = be.get(key)
+                if cached is not None:
+                    return cached
+                result = func(*args, **kwargs)
+                try:
+                    be.set(key, result, ttl_value)
+                except Exception:
+                    pass
+                return result
+
+            return wrapper
+
+    return decorator
+
+
+class RedisCacheBackend(BaseCacheBackend):
+    """Adapter backend for Redis-like clients.
+
+    Expects a client with .get(key) -> bytes|str|None and .set(key, value, ex=ttl_seconds).
+    The stored values should be JSON-serializable or pickled externally by the user.
+    """
+
+    def __init__(self, client) -> None:
+        self.client = client
+
+    def get(self, key: str) -> Any:
+        value = self.client.get(key)
+        # Many clients return bytes; decode if possible
+        if isinstance(value, bytes):
+            try:
+                return value.decode("utf-8")
+            except Exception:
+                return value
+        return value
+
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        # Use ex (expire seconds) if available
+        kwargs = {}
+        if ttl and ttl > 0:
+            kwargs["ex"] = int(ttl)
+        # Best effort set
+        self.client.set(key, value, **kwargs)
+
+    def delete(self, key: str) -> None:
+        try:
+            self.client.delete(key)
+        except Exception:
+            pass
+
+    def clear(self) -> None:
+        # Not standardized; no-op by default
+        pass
+
+
+class MemcachedCacheBackend(BaseCacheBackend):
+    """Adapter backend for Memcached-like clients.
+
+    Expects a client with .get(key) and .set(key, value, expire=ttl_seconds).
+    """
+
+    def __init__(self, client) -> None:
+        self.client = client
+
+    def get(self, key: str) -> Any:
+        return self.client.get(key)
+
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        expire = int(ttl) if ttl and ttl > 0 else 0
+        try:
+            # pymemcache: set(key, value, expire=...)
+            self.client.set(key, value, expire=expire)
+        except TypeError:
+            # python-binary-memcached: set(key, value, time=...)
+            self.client.set(key, value, time=expire)
+
+    def delete(self, key: str) -> None:
+        try:
+            self.client.delete(key)
+        except Exception:
+            pass
+
+    def clear(self) -> None:
+        try:
+            self.client.flush_all()
+        except Exception:
+            pass
+

tachyon_api/openapi.py

@@ -1,5 +1,8 @@
-from typing import Dict, Any, Optional, List, Type
+from typing import Dict, Any, Optional, List, Type, get_origin, get_args
 from dataclasses import dataclass, field
+import datetime
+import uuid
+import typing
 
 from .models import Struct
 
@@ -7,30 +10,112 @@ from .models import Struct
 TYPE_MAP = {int: "integer", str: "string", bool: "boolean", float: "number"}
 
 
-def _generate_schema_for_struct(struct_class: Type[Struct]) -> Dict[str, Any]:
+def _schema_for_python_type(
+    py_type: Type,
+    components: Dict[str, Dict[str, Any]],
+    visited: set[Type],
+) -> Dict[str, Any]:
+    """Return OpenAPI schema for a Python type, adding components for Structs if needed."""
+    origin = get_origin(py_type)
+    args = get_args(py_type)
+
+    # Optional[T] (Union[T, None])
+    if origin is typing.Union and args:
+        non_none = [a for a in args if a is not type(None)]  # noqa: E721
+        if len(non_none) == 1:
+            inner = non_none[0]
+            schema = _schema_for_python_type(inner, components, visited)
+            schema["nullable"] = True
+            return schema
+
+    # List[T]
+    if origin in (list, List):
+        item = args[0] if args else str
+        item_schema = _schema_for_python_type(item, components, visited)
+        return {"type": "array", "items": item_schema}
+
+    # Struct subclass
+    if isinstance(py_type, type) and issubclass(py_type, Struct):
+        name = py_type.__name__
+        if py_type not in visited:
+            visited.add(py_type)
+            components[name] = _generate_struct_schema(py_type, components, visited)
+        return {"$ref": f"#/components/schemas/{name}"}
+
+    # Special formats
+    if py_type is uuid.UUID:
+        return {"type": "string", "format": "uuid"}
+    if py_type is datetime.datetime:
+        return {"type": "string", "format": "date-time"}
+    if py_type is datetime.date:
+        return {"type": "string", "format": "date"}
+
+    # Scalars
+    return {"type": TYPE_MAP.get(py_type, "string")}
+
+
+def _unwrap_optional(py_type: Type) -> tuple[Type, bool]:
+    origin = get_origin(py_type)
+    args = get_args(py_type)
+    if origin is typing.Union and args:
+        non_none = [a for a in args if a is not type(None)]  # noqa: E721
+        if len(non_none) == 1:
+            return non_none[0], True
+    return py_type, False
+
+
+def _generate_struct_schema(
+    struct_class: Type[Struct],
+    components: Dict[str, Dict[str, Any]],
+    visited: set[Type],
+) -> Dict[str, Any]:
+    """
+    Generate a JSON Schema dictionary for a msgspec Struct, populating components for nested Structs.
     """
-    Generate a JSON Schema dictionary from a tachyon_api.models.Struct.
+    properties: Dict[str, Any] = {}
+    required: List[str] = []
 
-    Args:
-        struct_class: The Struct class to generate schema for
+    annotations = getattr(struct_class, "__annotations__", {})
+    for field_name in getattr(struct_class, "__struct_fields__", annotations.keys()):
+        field_type = annotations.get(field_name, str)
+        base_type, is_opt = _unwrap_optional(field_type)
 
-    Returns:
-        Dictionary containing the OpenAPI schema for the struct
+        # Build property schema
+        prop_schema = _schema_for_python_type(base_type, components, visited)
+        if is_opt:
+            prop_schema["nullable"] = True
+
+        properties[field_name] = prop_schema
+
+        # Determine required: mark non-Optional fields as required
+        if not is_opt:
+            required.append(field_name)
+
+    schema: Dict[str, Any] = {"type": "object", "properties": properties}
+    if required:
+        schema["required"] = required
+    return schema
+
+
+def build_components_for_struct(struct_class: Type[Struct]) -> Dict[str, Dict[str, Any]]:
     """
-    properties = {}
-    required = []
-
-    # Use msgspec's introspection tools
-    for field_name in struct_class.__struct_fields__:
-        field_type = struct_class.__annotations__.get(field_name)
-        properties[field_name] = {
-            "type": TYPE_MAP.get(field_type, "string"),
-            "title": field_name.replace("_", " ").title(),
-        }
-        # For now, assume all fields are required (can be enhanced later)
-        required.append(field_name)
+    Build components schemas for the given Struct and all nested Structs.
+
+    Returns a dict mapping component name to schema, including the top-level struct.
+    """
+    components: Dict[str, Dict[str, Any]] = {}
+    visited: set[Type] = set()
+    name = struct_class.__name__
+    components[name] = _generate_struct_schema(struct_class, components, visited)
+    return components
+
 
-    return {"type": "object", "properties": properties, "required": required}
+def _generate_schema_for_struct(struct_class: Type[Struct]) -> Dict[str, Any]:
+    """
+    Backward-compatible API: generate only the schema for the provided Struct (no nested components registration).
+    """
+    comps = build_components_for_struct(struct_class)
+    return comps[struct_class.__name__]
 
 
 @dataclass
@@ -202,7 +287,7 @@ class OpenAPIGenerator:
             SwaggerUIBundle.presets.standalone
         ],
         layout: "BaseLayout",
-        ...{params_json}
+        ...{{}}
     }})
     </script>
 </body>
@@ -268,7 +353,6 @@ class OpenAPIGenerator:
         """
         if self._openapi_schema is None:
             self._openapi_schema = self.config.to_openapi_dict()
-
         if path not in self._openapi_schema["paths"]:
             self._openapi_schema["paths"][path] = {}
 

tachyon_api/responses.py

@@ -6,12 +6,24 @@ with Starlette responses.
 """
 
 from starlette.responses import JSONResponse, HTMLResponse  # noqa
+import orjson
+from .models import encode_json
+
+
+class TachyonJSONResponse(JSONResponse):
+    """High-performance JSON response using orjson for serialization."""
+
+    media_type = "application/json"
+
+    def render(self, content) -> bytes:  # type: ignore[override]
+        # Use centralized encoder to support Struct, UUID, date, datetime, etc.
+        return encode_json(content)
 
 
 # Simple helper functions for common response patterns
 def success_response(data=None, message="Success", status_code=200):
     """Create a success response with consistent structure"""
-    return JSONResponse(
+    return TachyonJSONResponse(
         {"success": True, "message": message, "data": data}, status_code=status_code
     )
 
@@ -22,7 +34,7 @@ def error_response(error, status_code=400, code=None):
     if code:
         response_data["code"] = code
 
-    return JSONResponse(response_data, status_code=status_code)
+    return TachyonJSONResponse(response_data, status_code=status_code)
 
 
 def not_found_response(error="Resource not found"):
@@ -41,7 +53,19 @@ def validation_error_response(error="Validation failed", errors=None):
     if errors:
         response_data["errors"] = errors
 
-    return JSONResponse(response_data, status_code=422)
+    return TachyonJSONResponse(response_data, status_code=422)
+
+
+def response_validation_error_response(error="Response validation error"):
+    """Create a 500 response validation error response"""
+    # Normalize message with prefix and include 'detail' for backward compatibility
+    msg = str(error)
+    if not msg.lower().startswith("response validation error"):
+        msg = f"Response validation error: {msg}"
+    return TachyonJSONResponse(
+        {"success": False, "error": msg, "detail": msg, "code": "RESPONSE_VALIDATION_ERROR"},
+        status_code=500,
+    )
 
 
 # Re-export Starlette responses for convenience

tachyon_api-0.5.7.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.3
+Name: tachyon-api
+Version: 0.5.7
+Summary: A lightweight, FastAPI-inspired web framework
+License: GPL-3.0-or-later
+Author: Juan Manuel Panozzo Zénere
+Author-email: jm.panozzozenere@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: msgspec (>=0.19.0,<0.20.0)
+Requires-Dist: orjson (>=3.11.1,<4.0.0)
+Requires-Dist: ruff (>=0.12.7,<0.13.0)
+Requires-Dist: starlette (>=0.47.2,<0.48.0)
+Requires-Dist: typer (>=0.16.0,<0.17.0)
+Requires-Dist: uvicorn (>=0.35.0,<0.36.0)
+Description-Content-Type: text/markdown
+
+# 🚀 Tachyon API
+
+![Version](https://img.shields.io/badge/version-0.5.7-blue.svg)
+![Python](https://img.shields.io/badge/python-3.10+-brightgreen.svg)
+![License](https://img.shields.io/badge/license-GPL--3.0-orange.svg)
+![Status](https://img.shields.io/badge/status-stable-brightgreen.svg)
+
+**A lightweight, high-performance API framework for Python with the elegance of FastAPI and the speed of light.**
+
+Tachyon API combines the intuitive decorator-based syntax you love with minimal dependencies and maximal performance. Built with Test-Driven Development from the ground up, it offers a cleaner, faster alternative with full ASGI compatibility.
+
+```python
+from tachyon_api import Tachyon
+from tachyon_api.models import Struct
+
+app = Tachyon()
+
+class User(Struct):
+    name: str
+    age: int
+
+@app.get("/")
+def hello_world():
+    return {"message": "Tachyon is running at lightspeed!"}
+
+@app.post("/users")
+def create_user(user: User):
+    return {"created": user.name}
+```
+
+## ✨ Features
+
+- 🔍 Intuitive API (decorators) and minimal core
+- 🧩 Implicit & explicit DI
+- 📚 OpenAPI with Scalar, Swagger, ReDoc
+- 🛠️ Router system
+- 🔄 Middlewares (class + decorator)
+- 🧠 Cache decorator with TTL (in-memory, Redis, Memcached)
+- 🚀 High-performance JSON (msgspec + orjson)
+- 🧾 Unified error format (422/500)
+- 🧰 Default JSON response (TachyonJSONResponse)
+- 🔒 End-to-end safety: request Body validation + typed response_model
+- 📘 Deep OpenAPI schemas: nested Structs, Optional/List (nullable/array), formats (uuid, date-time)
+
+## 🧪 Test-Driven Development
+
+Tachyon API is built with TDD principles at its core. The test suite covers routing, DI, params, body validation, responses, OpenAPI generation, caching, and example flows.
+
+## 🔌 Core Dependencies
+
+- Starlette (ASGI)
+- msgspec (validation/serialization)
+- orjson (fast JSON)
+- uvicorn (server)
+
+## 💉 Dependency Injection System
+
+- Implicit injection: annotate with registered types
+- Explicit injection: Depends() for clarity and control
+
+## 🔄 Middleware Support
+
+- Built-in: CORSMiddleware, LoggerMiddleware
+- Use app.add_middleware(...) or @app.middleware()
+
+## ⚡ Cache with TTL
+
+- @cache(TTL=...) on routes and functions
+- Per-app config and pluggable backends (InMemory, Redis, Memcached)
+
+## 📚 Example Application
+
+The example demonstrates clean architecture, routers, middlewares, caching, and now end-to-end safety with OpenAPI:
+
+- /orjson-demo: default JSON powered by orjson
+- /api/v1/users/e2e: Body + response_model, unified errors and deep OpenAPI schemas
+
+Run the example:
+
+```
+cd example
+python app.py
+```
+
+Docs at /docs (Scalar), /swagger, /redoc.
+
+## ✅ Response models, OpenAPI params, and deep schemas
+
+- Response models: set response_model=YourStruct to validate/convert outputs via msgspec before serializing.
+- Parameter schemas: Optional[T] → nullable: true; List[T] → type: array with items.
+- Deep schemas: nested Struct components, Optional/List items, and formats (uuid, date-time) are generated and referenced in components.
+
+## 🧾 Default JSON response and unified error format
+
+- Default response: TachyonJSONResponse serializes complex types (UUID/date/datetime, Struct) via orjson and centralized encoders.
+- 422 Validation: { success: false, error, code: VALIDATION_ERROR, [errors] }.
+- 500 Response model: { success: false, error: "Response validation error: ...", detail, code: RESPONSE_VALIDATION_ERROR }.
+
+## 📝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📜 License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
+
+## 🔮 Roadmap
+
+- Exception system and global handlers
+- CLI, scaffolding, and code quality tooling
+- Authentication middleware and benchmarks
+- More examples and deployment guides
+
+---
+
+*Built with 💜 by developers, for developers*
+

{tachyon_api-0.5.5.dist-info → tachyon_api-0.5.7.dist-info}/RECORD

@@ -1,16 +1,17 @@
-tachyon_api/__init__.py,sha256=MrwA2s-dfpygkU3iY6SghCeuWuF_tNwdWPQ9Onp-pmM,776
-tachyon_api/app.py,sha256=Gt_ufNXdHAOR9lYJ8inLO_n-BuO_8VYmjTsuiab-r-k,24271
+tachyon_api/__init__.py,sha256=CEg69nSVW9iCLYgqVNvSr_7EICb9nrLuaDVxKlpm430,1207
+tachyon_api/app.py,sha256=R4EHr85hc_1k76YasseqZrus7b9by5rGij3IAh_UACg,36160
+tachyon_api/cache.py,sha256=FAlWcVbXf47_OWVtP92D2_J7ytwLD2pUV3ROy95u0Uc,8249
 tachyon_api/di.py,sha256=FyFghfUjU0OaE_lW2BqItgsZWXFbLvwFsvVywqFjl6c,1505
 tachyon_api/middlewares/__init__.py,sha256=BR1kqTj2IKdwhvVZCVn9p_rOFS0aOYoaC0bNX0C_0q4,121
 tachyon_api/middlewares/core.py,sha256=-dJTrI6KJbQzatopCUC5lau_JIZpl063697qdE4W0SY,1440
 tachyon_api/middlewares/cors.py,sha256=jZMqfFSz-14dwNIOOMqKaQm8Dypnf0V_WVW_4Uuc4AE,5716
 tachyon_api/middlewares/logger.py,sha256=8W543kmfu7f5LpDQOox8Z4t3QT1knko7bUx7kWLCzWw,4832
 tachyon_api/models.py,sha256=9pA5_ddMAcWW2dErAgeyG926NFezfCU68uuhW0qGMs4,2224
-tachyon_api/openapi.py,sha256=MHrA7DnVW88gyh1fiiLx1-uE1mc-eU4yseD6dCf_wxs,11688
+tachyon_api/openapi.py,sha256=7gob0J9uQ6-fjEFHbS-KT0oH7pOko18TEW_dcT5FEkI,14623
 tachyon_api/params.py,sha256=gLGIsFEGr33_G0kakpqOFHRrf86w3egFJAjquZp3Lo0,2810
-tachyon_api/responses.py,sha256=FaPv4xTXTw4jvyErsA7Gkp0l0POln-0_0bE6rbtsmcE,1574
+tachyon_api/responses.py,sha256=f-oe4EFQb-JkYEhWwE63qf9V8GLZ0PxouwsHQQnTj7M,2488
 tachyon_api/router.py,sha256=TlzgJ-UAfxBAQKy4YNVQIBObIDNzlebQ4G9qxsswJQ0,4204
-tachyon_api-0.5.5.dist-info/LICENSE,sha256=UZXUTSuWBt8V377-2_YE4ug9t6rcBAKrfOVhIBQ8zhk,712
-tachyon_api-0.5.5.dist-info/METADATA,sha256=F2WE9mBCeW6YJaYTaygrRphBpjCWkRLeQ1DjQNGjl2k,8413
-tachyon_api-0.5.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-tachyon_api-0.5.5.dist-info/RECORD,,
+tachyon_api-0.5.7.dist-info/LICENSE,sha256=UZXUTSuWBt8V377-2_YE4ug9t6rcBAKrfOVhIBQ8zhk,712
+tachyon_api-0.5.7.dist-info/METADATA,sha256=aIG9RflcTQ1deMOaBWfFt3s4cyUqVQ2MQfB9mUuXNoU,5042
+tachyon_api-0.5.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+tachyon_api-0.5.7.dist-info/RECORD,,