cycls 0.0.2.82__py3-none-any.whl → 0.0.2.84__py3-none-any.whl

cycls/__init__.py

@@ -1,20 +1,14 @@
-import sys
-from types import ModuleType
-from .sdk import function, agent
-from .runtime import Runtime
+from . import function as _function_module
+from .function import function, Function
+from .app import app, App
 
-class _Module(ModuleType):
-    def __getattr__(self, name):
-        from . import sdk
-        if name in ("api_key", "base_url"):
-            return getattr(sdk, name)
-        raise AttributeError(f"module 'cycls' has no attribute '{name}'")
-
-    def __setattr__(self, name, value):
-        from . import sdk
-        if name in ("api_key", "base_url"):
-            setattr(sdk, name, value)
-            return
-        super().__setattr__(name, value)
+def __getattr__(name):
+    if name in ("api_key", "base_url"):
+        return getattr(_function_module, name)
+    raise AttributeError(f"module 'cycls' has no attribute '{name}'")
 
-sys.modules[__name__].__class__ = _Module
+def __setattr__(name, value):
+    if name in ("api_key", "base_url"):
+        setattr(_function_module, name, value)
+    else:
+        raise AttributeError(f"module 'cycls' has no attribute '{name}'")

cycls/app.py

@@ -0,0 +1,88 @@
+import os
+import uvicorn
+import importlib.resources
+
+from .function import Function, _get_api_key, _get_base_url
+from .web import web, Config
+
+CYCLS_PATH = importlib.resources.files('cycls')
+
+THEMES = ["default", "dev"]
+
+
+class App(Function):
+    """App extends Function with web UI serving capabilities."""
+
+    def __init__(self, func, name, theme="default", pip=None, apt=None, copy=None, copy_public=None,
+                 auth=False, org=None, header=None, intro=None, title=None, plan="free", analytics=False):
+        if theme not in THEMES:
+            raise ValueError(f"Unknown theme: {theme}. Available: {THEMES}")
+        self.user_func = func
+        self.theme = theme
+        self.copy_public = copy_public or []
+
+        self.config = Config(
+            header=header,
+            intro=intro,
+            title=title,
+            auth=auth,
+            plan=plan,
+            analytics=analytics,
+            org=org,
+        )
+
+        # Build files dict for Function (theme is inside cycls/)
+        files = {str(CYCLS_PATH): "cycls"}
+        files.update({f: f for f in copy or []})
+        files.update({f: f"public/{f}" for f in self.copy_public})
+
+        super().__init__(
+            func=func,
+            name=name,
+            pip=["fastapi[standard]", "pyjwt", "cryptography", "uvicorn", "docker", *(pip or [])],
+            apt=apt,
+            copy=files,
+            base_url=_get_base_url(),
+            api_key=_get_api_key()
+        )
+
+    def __call__(self, *args, **kwargs):
+        return self.user_func(*args, **kwargs)
+
+    def _prepare_func(self, prod):
+        self.config.set_prod(prod)
+        self.config.public_path = f"cycls/themes/{self.theme}"
+        user_func, config, name = self.user_func, self.config, self.name
+        self.func = lambda port: __import__("cycls").web.serve(user_func, config, name, port)
+
+    def _local(self, port=8080):
+        """Run directly with uvicorn (no Docker)."""
+        print(f"Starting local server at localhost:{port}")
+        self.config.public_path = str(CYCLS_PATH.joinpath(f"themes/{self.theme}"))
+        self.config.set_prod(False)
+        uvicorn.run(web(self.user_func, self.config), host="0.0.0.0", port=port)
+
+    def local(self, port=8080, watch=True):
+        """Run locally in Docker with file watching by default."""
+        if os.environ.get('_CYCLS_WATCH'):
+            watch = False
+        self._prepare_func(prod=False)
+        self.watch(port=port) if watch else self.run(port=port)
+
+    def deploy(self, port=8080):
+        """Deploy to production."""
+        if self.api_key is None:
+            raise RuntimeError("Missing API key. Set cycls.api_key or CYCLS_API_KEY environment variable.")
+        self._prepare_func(prod=True)
+        return super().deploy(port=port)
+
+
+def app(name=None, **kwargs):
+    """Decorator that transforms a function into a deployable App."""
+    if kwargs.get("plan") == "cycls_pass":
+        kwargs["auth"] = True
+        kwargs["analytics"] = True
+
+    def decorator(func):
+        return App(func=func, name=name or func.__name__, **kwargs)
+    return decorator

cycls/{runtime.py → function.py}

@@ -10,23 +10,47 @@ import shutil
 from pathlib import Path
 import tarfile
 
-from .grpc import RuntimeClient
-
 os.environ["DOCKER_BUILDKIT"] = "1"
 
-GRPC_PORT = 50051
 BASE_IMAGE = "ghcr.io/cycls/base:python3.12"
 BASE_PACKAGES = {"cloudpickle", "cryptography", "fastapi", "fastapi[standard]",
                  "pydantic", "pyjwt", "uvicorn", "uvicorn[standard]", "httpx"}
-GRPC_PACKAGES = {"grpcio", "protobuf"}
 
-# Simple entrypoint for deployed services - loads pickled function+args and runs it
 ENTRYPOINT_PY = '''import cloudpickle
 with open("/app/function.pkl", "rb") as f:
     func, args, kwargs = cloudpickle.load(f)
 func(*args, **kwargs)
 '''
 
+RUNNER_PY = '''import cloudpickle
+import sys
+import traceback
+from pathlib import Path
+
+io_dir = Path(sys.argv[1])
+payload_path = io_dir / "payload.pkl"
+result_path = io_dir / "result.pkl"
+
+try:
+    with open(payload_path, "rb") as f:
+        func, args, kwargs = cloudpickle.load(f)
+    result = func(*args, **kwargs)
+    with open(result_path, "wb") as f:
+        cloudpickle.dump(result, f)
+except Exception:
+    traceback.print_exc()
+    sys.exit(1)
+'''
+
+# Module-level configuration
+api_key = None
+base_url = None
+
+def _get_api_key():
+    return api_key or os.getenv("CYCLS_API_KEY")
+
+def _get_base_url():
+    return base_url or os.getenv("CYCLS_BASE_URL")
 
 def _hash_path(path_str: str) -> str:
     h = hashlib.sha256()
@@ -56,40 +80,34 @@ def _copy_path(src_path: Path, dest_path: Path):
         shutil.copy(src_path, dest_path)
 
 
-class Runtime:
-    """Executes functions in Docker containers. Uses gRPC for local dev, pickle for deploy."""
+class Function:
+    """Executes functions in Docker containers."""
 
-    def __init__(self, func, name, python_version=None, pip_packages=None, apt_packages=None,
+    def __init__(self, func, name, python_version=None, pip=None, apt=None,
                  run_commands=None, copy=None, base_url=None, api_key=None, base_image=None):
         self.func = func
-        self.name = name
+        self.name = name.replace('_', '-')
         self.python_version = python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
-        self.apt_packages = sorted(apt_packages or [])
+        self.apt = sorted(apt or [])
         self.run_commands = sorted(run_commands or [])
-        self.copy = copy or {}
+        self.copy = {f: f for f in copy} if isinstance(copy, list) else (copy or {})
         self.base_image = base_image or BASE_IMAGE
         self.base_url = base_url or "https://service-core-280879789566.me-central1.run.app"
         self.api_key = api_key
 
-        # Compute pip packages (gRPC only needed for local dev, added dynamically)
-        user_packages = set(pip_packages or [])
+        user_packages = set(pip or [])
         if self.base_image == BASE_IMAGE:
-            self.pip_packages = sorted(user_packages - BASE_PACKAGES)
+            self.pip = sorted(user_packages - BASE_PACKAGES)
         else:
-            self.pip_packages = sorted(user_packages | {"cloudpickle"})
+            self.pip = sorted(user_packages | {"cloudpickle"})
 
-        self.image_prefix = f"cycls/{name}"
-        self.managed_label = "cycls.runtime"
+        self.image_prefix = f"cycls/{self.name}"
+        self.managed_label = "cycls.function"
         self._docker_client = None
-
-        # Local dev state (gRPC container)
         self._container = None
-        self._client = None
-        self._host_port = None
 
     @property
     def docker_client(self):
-        """Lazily initializes and returns a Docker client."""
         if self._docker_client is None:
             try:
                 print("Initializing Docker client...")
@@ -103,15 +121,12 @@ class Runtime:
         return self._docker_client
 
     def _perform_auto_cleanup(self, keep_tag=None):
-        """Clean up old containers and dev images (preserve deploy-* images)."""
         try:
-            # Remove old containers
             current_id = self._container.id if self._container else None
             for container in self.docker_client.containers.list(all=True, filters={"label": self.managed_label}):
                 if container.id != current_id:
                     container.remove(force=True)
 
-            # Remove old dev images globally (keep deploy-* and current)
             cleaned = 0
             for image in self.docker_client.images.list(filters={"label": self.managed_label}):
                 is_deploy = any(":deploy-" in t for t in image.tags)
@@ -125,9 +140,8 @@ class Runtime:
             print(f"Warning: cleanup error: {e}")
 
     def _image_tag(self, extra_parts=None) -> str:
-        """Creates a unique tag based on image configuration."""
-        parts = [self.base_image, self.python_version, "".join(self.pip_packages),
-                 "".join(self.apt_packages), "".join(self.run_commands)]
+        parts = [self.base_image, self.python_version, "".join(self.pip),
+                 "".join(self.apt), "".join(self.run_commands)]
         for src, dst in sorted(self.copy.items()):
             if not Path(src).exists():
                 raise FileNotFoundError(f"Path in 'copy' not found: {src}")
@@ -136,20 +150,18 @@ class Runtime:
             parts.extend(extra_parts)
         return f"{self.image_prefix}:{hashlib.sha256(''.join(parts).encode()).hexdigest()[:16]}"
 
-    def _dockerfile_preamble(self, pip_extras=None) -> str:
-        """Common Dockerfile setup: base image, apt, pip, run commands, copy."""
+    def _dockerfile_preamble(self) -> str:
         lines = [f"FROM {self.base_image}"]
 
         if self.base_image != BASE_IMAGE:
             lines.append("ENV PIP_ROOT_USER_ACTION=ignore PYTHONUNBUFFERED=1")
             lines.append("WORKDIR /app")
 
-        if self.apt_packages:
-            lines.append(f"RUN apt-get update && apt-get install -y --no-install-recommends {' '.join(self.apt_packages)}")
+        if self.apt:
+            lines.append(f"RUN apt-get update && apt-get install -y --no-install-recommends {' '.join(self.apt)}")
 
-        all_pip = list(self.pip_packages) + list(pip_extras or [])
-        if all_pip:
-            lines.append(f"RUN uv pip install --system --no-cache {' '.join(all_pip)}")
+        if self.pip:
+            lines.append(f"RUN uv pip install --system --no-cache {' '.join(self.pip)}")
 
         for cmd in self.run_commands:
             lines.append(f"RUN {cmd}")
@@ -159,16 +171,13 @@ class Runtime:
 
         return "\n".join(lines)
 
-    def _dockerfile_grpc(self) -> str:
-        """Dockerfile for local dev: gRPC server."""
-        return f"""{self._dockerfile_preamble(pip_extras=GRPC_PACKAGES)}
-COPY grpc_runtime/ /app/grpc_runtime/
-EXPOSE {GRPC_PORT}
-CMD ["python", "-m", "grpc_runtime.server", "--port", "{GRPC_PORT}"]
+    def _dockerfile_local(self) -> str:
+        return f"""{self._dockerfile_preamble()}
+COPY runner.py /app/runner.py
+ENTRYPOINT ["python", "/app/runner.py", "/io"]
 """
 
     def _dockerfile_deploy(self, port: int) -> str:
-        """Dockerfile for deploy: baked-in function via pickle."""
         return f"""{self._dockerfile_preamble()}
 COPY function.pkl /app/function.pkl
 COPY entrypoint.py /app/entrypoint.py
@@ -177,14 +186,12 @@ CMD ["python", "entrypoint.py"]
 """
 
     def _copy_user_files(self, workdir: Path):
-        """Copy user-specified files to build context."""
         context_files_dir = workdir / "context_files"
         context_files_dir.mkdir()
         for src, dst in self.copy.items():
             _copy_path(Path(src).resolve(), context_files_dir / dst)
 
     def _build_image(self, tag: str, workdir: Path) -> str:
-        """Build a Docker image from a prepared context."""
         print("--- Docker Build Logs ---")
         try:
             for chunk in self.docker_client.api.build(
@@ -200,9 +207,8 @@ CMD ["python", "entrypoint.py"]
             print(f"\nDocker build failed: {e}")
             raise
 
-    def _ensure_grpc_image(self) -> str:
-        """Build local dev image with gRPC server if needed."""
-        tag = self._image_tag(extra_parts=["grpc-v2"])
+    def _ensure_local_image(self) -> str:
+        tag = self._image_tag(extra_parts=["local-v1"])
         try:
             self.docker_client.images.get(tag)
             print(f"Found cached image: {tag}")
@@ -213,176 +219,118 @@ CMD ["python", "entrypoint.py"]
         with tempfile.TemporaryDirectory() as tmpdir:
             workdir = Path(tmpdir)
             self._copy_user_files(workdir)
-            (workdir / "Dockerfile").write_text(self._dockerfile_grpc())
-
-            # Copy gRPC runtime
-            grpc_src = Path(__file__).parent / "grpc"
-            shutil.copytree(grpc_src, workdir / "grpc_runtime",
-                          ignore=shutil.ignore_patterns('*.proto', '__pycache__'))
-
+            (workdir / "Dockerfile").write_text(self._dockerfile_local())
+            (workdir / "runner.py").write_text(RUNNER_PY)
             return self._build_image(tag, workdir)
 
-    def _ensure_container(self, service_port=None):
-        """Start container if not running, return gRPC client."""
-        if self._client and self._container:
+    def _cleanup_container(self):
+        if getattr(self, '_container', None):
             try:
-                self._container.reload()
-                if self._container.status == 'running':
-                    return self._client
+                self._container.stop(timeout=3)
+                self._container.remove()
             except docker.errors.NotFound:
-                pass  # Container was removed externally
+                pass
             except docker.errors.APIError:
-                pass  # Docker API issue, will recreate
-            self._cleanup_container()
+                pass
+            self._container = None
 
-        tag = self._ensure_grpc_image()
+    @contextlib.contextmanager
+    def runner(self, *args, **kwargs):
+        service_port = kwargs.get('port')
+        tag = self._ensure_local_image()
         self._perform_auto_cleanup(keep_tag=tag)
 
-        # Port mappings (fixed ports avoid race conditions)
-        ports = {f'{GRPC_PORT}/tcp': GRPC_PORT}
-        if service_port:
-            ports[f'{service_port}/tcp'] = service_port
-
-        self._container = self.docker_client.containers.run(
-            tag, detach=True, ports=ports, labels={self.managed_label: "true"}
-        )
-        self._host_port = GRPC_PORT
-        self._client = RuntimeClient(port=self._host_port)
-        if not self._client.wait_ready(timeout=10):
-            raise RuntimeError("Container failed to start")
-        print(f"Container ready on port {self._host_port}")
-        return self._client
+        ports = {f'{service_port}/tcp': service_port} if service_port else None
+
+        with tempfile.TemporaryDirectory() as io_dir:
+            io_path = Path(io_dir)
+            payload_path = io_path / "payload.pkl"
+            result_path = io_path / "result.pkl"
+
+            with open(payload_path, 'wb') as f:
+                cloudpickle.dump((self.func, args, kwargs), f)
 
-    def _cleanup_container(self):
-        """Stop and remove the warm container."""
-        if self._client:
-            self._client.close()
-            self._client = None
-        if self._container:
             try:
-                self._container.stop(timeout=3)
-                self._container.remove()
-            except docker.errors.NotFound:
-                pass  # Already removed
-            except docker.errors.APIError:
-                pass  # Best effort cleanup
-            self._container = None
-        self._host_port = None
+                self._container = self.docker_client.containers.create(
+                    image=tag,
+                    volumes={str(io_path): {'bind': '/io', 'mode': 'rw'}},
+                    ports=ports,
+                    labels={self.managed_label: "true"}
+                )
+                self._container.start()
+                yield self._container, result_path
+            finally:
+                self._cleanup_container()
 
     def run(self, *args, **kwargs):
-        """Execute the function in a container and return the result."""
         service_port = kwargs.get('port')
         print(f"Running '{self.name}'...")
+
         try:
-            client = self._ensure_container(service_port=service_port)
-
-            # Blocking service: fire gRPC, stream Docker logs
-            if service_port:
-                client.fire(self.func, *args, **kwargs)
-                print(f"Service running on port {service_port}")
-                print("--- 🪵 Container Logs ---")
-                for chunk in self._container.logs(stream=True, follow=True):
+            with self.runner(*args, **kwargs) as (container, result_path):
+                print("--- Container Logs ---")
+                for chunk in container.logs(stream=True, follow=True):
                     print(chunk.decode(), end='')
-                return None
+                print("----------------------")
+
+                status = container.wait()
+                if status['StatusCode'] != 0:
+                    print(f"Error: Container exited with code {status['StatusCode']}")
+                    return None
 
-            # Regular function: execute, then print logs
-            result = client.call(self.func, *args, **kwargs)
-            logs = self._container.logs().decode()
-            if logs.strip():
-                print("--- 🪵 Container Logs ---")
-                print(logs, end='')
-                print("-------------------------")
-            return result
+                if service_port:
+                    return None
+
+                if result_path.exists():
+                    with open(result_path, 'rb') as f:
+                        return cloudpickle.load(f)
+                else:
+                    print("Error: Result file not found")
+                    return None
 
         except KeyboardInterrupt:
-            print("\n-------------------------")
+            print("\n----------------------")
             print("Stopping...")
-            self._cleanup_container()
             return None
         except Exception as e:
             print(f"Error: {e}")
             return None
 
-    def stream(self, *args, **kwargs):
-        """Execute the function and yield streamed results."""
-        service_port = kwargs.get('port')
-        client = self._ensure_container(service_port=service_port)
-        yield from client.execute(self.func, *args, **kwargs)
-
-    @contextlib.contextmanager
-    def runner(self, *args, **kwargs):
-        """Context manager for running a service. Yields (container, client)."""
-        service_port = kwargs.get('port')
-        try:
-            client = self._ensure_container(service_port=service_port)
-            client.fire(self.func, *args, **kwargs)
-            yield self._container, client
-        finally:
-            self._cleanup_container()
-
     def watch(self, *args, **kwargs):
-        """Run with file watching - restarts script on changes."""
+        if os.environ.get('_CYCLS_WATCH'):
+            return self.run(*args, **kwargs)
+
         try:
             from watchfiles import watch as watchfiles_watch
         except ImportError:
-            print("watchfiles not installed (enables auto-reload on file changes).")
-            print("Install with: pip install watchfiles")
-            print("Running without file watching...")
+            print("watchfiles not installed. pip install watchfiles")
             return self.run(*args, **kwargs)
 
-        import inspect
         import subprocess
 
-        # Find the user's script (outside cycls package)
-        cycls_pkg = Path(__file__).parent.resolve()
-        main_script = None
-        for frame_info in inspect.stack():
-            filepath = Path(frame_info.filename).resolve()
-            if filepath.suffix == '.py' and not str(filepath).startswith(str(cycls_pkg)):
-                main_script = filepath
-                break
-
-        if not main_script:
-            print("Could not find script to watch.")
-            return self.run(*args, **kwargs)
-
-        # Build watch paths
-        watch_paths = [main_script]
-        watch_paths.extend([Path(src).resolve() for src in self.copy.keys() if Path(src).exists()])
+        script = Path(sys.argv[0]).resolve()
+        watch_paths = [script] + [Path(p).resolve() for p in self.copy if Path(p).exists()]
 
-        print(f"👀 Watching:")
-        for p in watch_paths:
-            print(f"   {p}")
-        print()
+        print(f"Watching: {[p.name for p in watch_paths]}\n")
 
         while True:
-            print(f"🚀 Starting {main_script.name}...")
-            proc = subprocess.Popen(
-                [sys.executable, str(main_script)],
-                env={**os.environ, '_CYCLS_WATCH': '1'}
-            )
-
+            proc = subprocess.Popen([sys.executable, str(script)], env={**os.environ, '_CYCLS_WATCH': '1'})
             try:
                 for changes in watchfiles_watch(*watch_paths):
-                    print(f"\n🔄 Changed: {[Path(c[1]).name for c in changes]}")
+                    print(f"\nChanged: {[Path(c[1]).name for c in changes]}")
                     break
-
                 proc.terminate()
                 proc.wait(timeout=3)
             except subprocess.TimeoutExpired:
                 proc.kill()
             except KeyboardInterrupt:
-                print("\nStopping...")
                 proc.terminate()
                 proc.wait(timeout=3)
                 return
 
-            print()
-
     def _prepare_deploy_context(self, workdir: Path, port: int, args=(), kwargs=None):
-        """Prepare build context for deploy: pickle function+args + entrypoint."""
         kwargs = kwargs or {}
-        kwargs['port'] = port  # Ensure port is in kwargs
+        kwargs['port'] = port
         self._copy_user_files(workdir)
         (workdir / "Dockerfile").write_text(self._dockerfile_deploy(port))
         (workdir / "entrypoint.py").write_text(ENTRYPOINT_PY)
@@ -390,7 +338,6 @@ CMD ["python", "entrypoint.py"]
             cloudpickle.dump((self.func, args, kwargs), f)
 
     def build(self, *args, **kwargs):
-        """Build a deployable Docker image locally."""
         port = kwargs.pop('port', 8080)
         payload = cloudpickle.dumps((self.func, args, {**kwargs, 'port': port}))
         tag = f"{self.image_prefix}:deploy-{hashlib.sha256(payload).hexdigest()[:16]}"
@@ -410,7 +357,6 @@ CMD ["python", "entrypoint.py"]
             return tag
 
     def deploy(self, *args, **kwargs):
-        """Deploy the function to a remote build server."""
         import requests
 
         port = kwargs.pop('port', 8080)
@@ -456,5 +402,11 @@ CMD ["python", "entrypoint.py"]
                 return None
 
     def __del__(self):
-        """Cleanup on garbage collection."""
         self._cleanup_container()
+
+
+def function(name=None, **kwargs):
+    """Decorator that transforms a Python function into a containerized Function."""
+    def decorator(func):
+        return Function(func, name or func.__name__, **kwargs, base_url=_get_base_url(), api_key=_get_api_key())
+    return decorator

cycls/web.py

@@ -2,19 +2,25 @@ import json, inspect
 from pathlib import Path
 from pydantic import BaseModel
 from typing import Optional
+from .auth import PK_LIVE, PK_TEST, JWKS_PROD, JWKS_TEST
 
 class Config(BaseModel):
     public_path: str = "theme"
-    header: str = ""
-    intro: str = ""
-    title: str = ""
+    header: Optional[str] = None
+    intro: Optional[str] = None
+    title: Optional[str] = None
     prod: bool = False
     auth: bool = False
     plan: str = "free"
     analytics: bool = False
     org: Optional[str] = None
-    pk: str = ""
-    jwks: str = ""
+    pk: Optional[str] = None
+    jwks: Optional[str] = None
+
+    def set_prod(self, prod: bool):
+        self.prod = prod
+        self.pk = PK_LIVE if prod else PK_TEST
+        self.jwks = JWKS_PROD if prod else JWKS_TEST
 
 async def openai_encoder(stream):
     if inspect.isasyncgen(stream):

{cycls-0.0.2.82.dist-info → cycls-0.0.2.84.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cycls
-Version: 0.0.2.82
+Version: 0.0.2.84
 Summary: Distribute Intelligence
 Author: Mohammed J. AlRujayi
 Author-email: mj@cycls.com
@@ -12,14 +12,10 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Provides-Extra: modal
 Requires-Dist: cloudpickle (>=3.1.1,<4.0.0)
 Requires-Dist: docker (>=7.1.0,<8.0.0)
 Requires-Dist: fastapi (>=0.111.0,<0.112.0)
-Requires-Dist: grpcio (>=1.76.0,<2.0.0)
 Requires-Dist: httpx (>=0.27.0,<0.28.0)
-Requires-Dist: modal (>=1.1.0,<2.0.0) ; extra == "modal"
-Requires-Dist: protobuf (>=6.0,<7.0)
 Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Description-Content-Type: text/markdown
 
@@ -49,6 +45,8 @@ The open-source SDK for distributing AI agents.
 
 The function is the unit of abstraction in cycls. Your agent logic lives in a plain Python function — the decorator layers on everything else: containerization, authentication, deployment, analytics. You write the function, the `@` handles the infrastructure.
 
+Cycls is beautifully lean (~862 lines!) and focused on deployment infrastructure for any Python function, not agent logic itself.
+
 ## Distribute Intelligence
 
 Write a function. Deploy it as an API, a web interface, or both. Add authentication, analytics, and monetization with flags.
@@ -58,8 +56,8 @@ import cycls
 
 cycls.api_key = "YOUR_CYCLS_API_KEY"
 
-@cycls.agent(pip=["openai"])
-async def agent(context):
+@cycls.app(pip=["openai"])
+async def app(context):
     from openai import AsyncOpenAI
     client = AsyncOpenAI()
 
@@ -76,7 +74,7 @@ async def agent(context):
         elif event.type == "response.output_text.delta":
             yield event.delta
 
-agent.deploy()  # Live at https://agent.cycls.ai
+app.deploy()  # Live at https://agent.cycls.ai
 ```
 
 ## Installation
@@ -99,9 +97,9 @@ Requires Docker.
 ## Running
 
 ```python
-agent.local()             # Development with hot-reload (localhost:8080)
-agent.local(watch=False)  # Development without hot-reload
-agent.deploy()            # Production: https://agent.cycls.ai
+app.local()             # Development with hot-reload (localhost:8080)
+app.local(watch=False)  # Development without hot-reload
+app.deploy()            # Production: https://agent.cycls.ai
 ```
 
 Get an API key at [cycls.com](https://cycls.com).
@@ -109,8 +107,8 @@ Get an API key at [cycls.com](https://cycls.com).
 ## Authentication & Analytics
 
 ```python
-@cycls.agent(pip=["openai"], auth=True, analytics=True)
-async def agent(context):
+@cycls.app(pip=["openai"], auth=True, analytics=True)
+async def app(context):
     # context.user available when auth=True
     user = context.user  # User(id, email, name, plans)
     yield f"Hello {user.name}!"
@@ -127,7 +125,7 @@ async def agent(context):
 Yield structured objects for rich streaming responses:
 
 ```python
-@cycls.agent()
+@cycls.app()
 async def demo(context):
     yield {"type": "thinking", "thinking": "Analyzing the request..."}
     yield "Here's what I found:\n\n"
@@ -169,7 +167,7 @@ This works seamlessly with OpenAI's reasoning models - just map reasoning summar
 ## Context Object
 
 ```python
-@cycls.agent()
+@cycls.app()
 async def chat(context):
     context.messages      # [{"role": "user", "content": "..."}]
     context.messages.raw  # Full data including UI component parts
@@ -202,13 +200,13 @@ See [docs/streaming-protocol.md](docs/streaming-protocol.md) for frontend integr
 Define your entire runtime in the decorator:
 
 ```python
-@cycls.agent(
+@cycls.app(
     pip=["openai", "pandas", "numpy"],
     apt=["ffmpeg", "libmagic1"],
     copy=["./utils.py", "./models/", "/absolute/path/to/config.json"],
     copy_public=["./assets/logo.png", "./static/"],
 )
-async def my_agent(context):
+async def my_app(context):
     ...
 ```
 
@@ -243,7 +241,7 @@ copy=[
 Then import them in your function:
 
 ```python
-@cycls.agent(copy=["./utils.py"])
+@cycls.app(copy=["./utils.py"])
 async def chat(context):
     from utils import helper_function  # Your bundled module
     ...
@@ -257,7 +255,7 @@ Files and directories served at the `/public` endpoint. Perfect for images, down
 copy_public=["./assets/logo.png", "./downloads/"]
 ```
 
-Access them at `https://your-agent.cycls.ai/public/logo.png`.
+Access them at `https://your-app.cycls.ai/public/logo.png`.
 
 ---
 

cycls-0.0.2.84.dist-info/RECORD

@@ -0,0 +1,14 @@
+cycls/__init__.py,sha256=efbq0vRijGOByKtz9bRF8WQFYmnPSgZV1DH-54s6iwQ,493
+cycls/app.py,sha256=xoPCEBJm8lqVwqa2qnvmhfFW1pWn9CbWIp--CBo2Tqw,3107
+cycls/auth.py,sha256=xkndHZyCfnlertMMEKerCJjf23N3fVcTRVTTSXTTuzg,247
+cycls/cli.py,sha256=cVbIkTDnVofohvByyYUrXF_RYDQZVQECJqo7cPBPJfs,4781
+cycls/function.py,sha256=3N8PqpVSVaU6RSrIwCvTCUwTm0kOchQN6jSz89v_hXE,15120
+cycls/themes/default/assets/index-C2r4Daz3.js,sha256=OGzjspxo0uUTdtQIzWZNgFMhGUtW4wSVuW33iA7oLFM,1351283
+cycls/themes/default/assets/index-DWGS8zpa.css,sha256=SxylXQV1qgQ0sw9QlMxcu9jwWTu8XPOnWZju8upUpCM,6504
+cycls/themes/default/index.html,sha256=WPUqVzJyh-aO2ulWTbXwOVAfWHaj0yWTGd9e8HOEro4,828
+cycls/themes/dev/index.html,sha256=QJBHkdNuMMiwQU7o8dN8__8YQeQB45D37D-NCXIWB2Q,11585
+cycls/web.py,sha256=KU7UsqIWFR32BOoKgDRPfcMooyrfytl3anp0XVSl5O4,5317
+cycls-0.0.2.84.dist-info/METADATA,sha256=otcLx-nidkZMpdpeuHt9akSLyTKN31Aj9AJekCzTNEM,8706
+cycls-0.0.2.84.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cycls-0.0.2.84.dist-info/entry_points.txt,sha256=vEhqUxFhhuzCKWtq02LbMnT3wpUqdfgcM3Yh-jjXom8,40
+cycls-0.0.2.84.dist-info/RECORD,,

cycls-0.0.2.84.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cycls=cycls.cli:main
+

cycls/grpc/__init__.py

@@ -1,3 +0,0 @@
-from .client import RuntimeClient
-
-__all__ = ["RuntimeClient"]

cycls/grpc/client.py

@@ -1,71 +0,0 @@
-import cloudpickle
-import grpc
-
-try:
-    from . import runtime_pb2
-    from . import runtime_pb2_grpc
-except ImportError:
-    import runtime_pb2
-    import runtime_pb2_grpc
-
-
-class RuntimeClient:
-    def __init__(self, host='localhost', port=50051, timeout=None):
-        self.host = host
-        self.port = port
-        self.timeout = timeout
-        self._channel = None
-        self._stub = None
-
-    def _connect(self):
-        if self._channel is None:
-            self._channel = grpc.insecure_channel(f'{self.host}:{self.port}')
-            self._stub = runtime_pb2_grpc.RuntimeStub(self._channel)
-        return self._stub
-
-    def execute(self, func, *args, **kwargs):
-        """Execute function and yield streamed results."""
-        stub = self._connect()
-        payload = cloudpickle.dumps((func, args, kwargs))
-        request = runtime_pb2.Request(payload=payload)
-
-        for response in stub.Execute(request, timeout=self.timeout):
-            result = cloudpickle.loads(response.data)
-            if response.error:
-                raise RuntimeError(f"Function execution failed: {result}")
-            yield result
-
-    def call(self, func, *args, **kwargs):
-        """Execute and return single result (or list if multiple)."""
-        results = list(self.execute(func, *args, **kwargs))
-        return results[0] if len(results) == 1 else results
-
-    def fire(self, func, *args, **kwargs):
-        """Fire off execution without waiting for response."""
-        stub = self._connect()
-        payload = cloudpickle.dumps((func, args, kwargs))
-        request = runtime_pb2.Request(payload=payload)
-        # Start the stream - gRPC sends request immediately
-        self._active_stream = stub.Execute(request)
-
-    def wait_ready(self, timeout=10):
-        """Wait for channel to be ready."""
-        if self._channel is None:
-            self._connect()
-        try:
-            grpc.channel_ready_future(self._channel).result(timeout=timeout)
-            return True
-        except grpc.FutureTimeoutError:
-            return False
-
-    def close(self):
-        if self._channel:
-            self._channel.close()
-            self._channel = None
-            self._stub = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()

cycls/grpc/runtime.proto

@@ -1,18 +0,0 @@
-syntax = "proto3";
-
-package runtime;
-
-service Runtime {
-  rpc Execute(Request) returns (stream Response);
-}
-
-message Request {
-  bytes payload = 1;
-}
-
-message Response {
-  bytes data = 1;
-  bool error = 2;
-  bytes log = 3;
-  bool is_log = 4;
-}

cycls/grpc/runtime_pb2.py

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# NO CHECKED-IN PROTOBUF GENCODE
-# source: runtime.proto
-# Protobuf Python Version: 6.31.1
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import runtime_version as _runtime_version
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(
-    _runtime_version.Domain.PUBLIC,
-    6,
-    31,
-    1,
-    '',
-    'runtime.proto'
-)
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\rruntime.proto\x12\x07runtime\"\x1a\n\x07Request\x12\x0f\n\x07payload\x18\x01 \x01(\x0c\"D\n\x08Response\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\x0c\x12\r\n\x05\x65rror\x18\x02 \x01(\x08\x12\x0b\n\x03log\x18\x03 \x01(\x0c\x12\x0e\n\x06is_log\x18\x04 \x01(\x08\x32;\n\x07Runtime\x12\x30\n\x07\x45xecute\x12\x10.runtime.Request\x1a\x11.runtime.Response0\x01\x62\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'runtime_pb2', _globals)
-if not _descriptor._USE_C_DESCRIPTORS:
-  DESCRIPTOR._loaded_options = None
-  _globals['_REQUEST']._serialized_start=26
-  _globals['_REQUEST']._serialized_end=52
-  _globals['_RESPONSE']._serialized_start=54
-  _globals['_RESPONSE']._serialized_end=122
-  _globals['_RUNTIME']._serialized_start=124
-  _globals['_RUNTIME']._serialized_end=183
-# @@protoc_insertion_point(module_scope)

cycls/grpc/runtime_pb2_grpc.py

@@ -1,100 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-"""Client and server classes corresponding to protobuf-defined services."""
-import grpc
-import warnings
-
-try:
-    from . import runtime_pb2 as runtime__pb2
-except ImportError:
-    import runtime_pb2 as runtime__pb2
-
-GRPC_GENERATED_VERSION = '1.76.0'
-GRPC_VERSION = grpc.__version__
-_version_not_supported = False
-
-try:
-    from grpc._utilities import first_version_is_lower
-    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
-except ImportError:
-    _version_not_supported = True
-
-if _version_not_supported:
-    raise RuntimeError(
-        f'The grpc package installed is at version {GRPC_VERSION},'
-        + ' but the generated code in runtime_pb2_grpc.py depends on'
-        + f' grpcio>={GRPC_GENERATED_VERSION}.'
-        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
-        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
-    )
-
-
-class RuntimeStub(object):
-    """Missing associated documentation comment in .proto file."""
-
-    def __init__(self, channel):
-        """Constructor.
-
-        Args:
-            channel: A grpc.Channel.
-        """
-        self.Execute = channel.unary_stream(
-                '/runtime.Runtime/Execute',
-                request_serializer=runtime__pb2.Request.SerializeToString,
-                response_deserializer=runtime__pb2.Response.FromString,
-                _registered_method=True)
-
-
-class RuntimeServicer(object):
-    """Missing associated documentation comment in .proto file."""
-
-    def Execute(self, request, context):
-        """Missing associated documentation comment in .proto file."""
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-
-def add_RuntimeServicer_to_server(servicer, server):
-    rpc_method_handlers = {
-            'Execute': grpc.unary_stream_rpc_method_handler(
-                    servicer.Execute,
-                    request_deserializer=runtime__pb2.Request.FromString,
-                    response_serializer=runtime__pb2.Response.SerializeToString,
-            ),
-    }
-    generic_handler = grpc.method_handlers_generic_handler(
-            'runtime.Runtime', rpc_method_handlers)
-    server.add_generic_rpc_handlers((generic_handler,))
-    server.add_registered_method_handlers('runtime.Runtime', rpc_method_handlers)
-
-
- # This class is part of an EXPERIMENTAL API.
-class Runtime(object):
-    """Missing associated documentation comment in .proto file."""
-
-    @staticmethod
-    def Execute(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_stream(
-            request,
-            target,
-            '/runtime.Runtime/Execute',
-            runtime__pb2.Request.SerializeToString,
-            runtime__pb2.Response.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)

cycls/grpc/server.py

@@ -1,60 +0,0 @@
-import asyncio
-import inspect
-import traceback
-import cloudpickle
-import grpc
-from concurrent import futures
-
-try:
-    from . import runtime_pb2
-    from . import runtime_pb2_grpc
-except ImportError:
-    import runtime_pb2
-    import runtime_pb2_grpc
-
-
-class RuntimeServicer(runtime_pb2_grpc.RuntimeServicer):
-    def Execute(self, request, context):
-        try:
-            func, args, kwargs = cloudpickle.loads(request.payload)
-            result = func(*args, **kwargs)
-
-            # Handle coroutines
-            if inspect.iscoroutine(result):
-                result = asyncio.run(result)
-
-            # Handle async generators
-            if inspect.isasyncgen(result):
-                async def collect():
-                    items = []
-                    async for item in result:
-                        items.append(item)
-                    return items
-                result = iter(asyncio.run(collect()))
-
-            # Stream results for generators, single response otherwise
-            if inspect.isgenerator(result):
-                for chunk in result:
-                    yield runtime_pb2.Response(data=cloudpickle.dumps(chunk))
-            else:
-                yield runtime_pb2.Response(data=cloudpickle.dumps(result))
-
-        except Exception as e:
-            error_msg = f"{type(e).__name__}: {e}\n{traceback.format_exc()}"
-            yield runtime_pb2.Response(data=cloudpickle.dumps(error_msg), error=True)
-
-
-def serve(port=50051):
-    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-    runtime_pb2_grpc.add_RuntimeServicer_to_server(RuntimeServicer(), server)
-    server.add_insecure_port(f'[::]:{port}')
-    server.start()
-    server.wait_for_termination()
-
-
-if __name__ == '__main__':
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--port', type=int, default=50051)
-    args = parser.parse_args()
-    serve(args.port)

cycls/sdk.py

@@ -1,186 +0,0 @@
-import os, time, uvicorn
-from .runtime import Runtime
-from .web import web, Config
-from .auth import PK_LIVE, PK_TEST, JWKS_PROD, JWKS_TEST
-import importlib.resources
-
-CYCLS_PATH = importlib.resources.files('cycls')
-
-# Module-level configuration
-api_key = None
-base_url = None
-
-themes = {
-    "default": CYCLS_PATH.joinpath('default-theme'),
-    "dev": CYCLS_PATH.joinpath('dev-theme'),
-}
-
-def _resolve_theme(theme):
-    """Resolve theme - accepts string name or path"""
-    if isinstance(theme, str):
-        if theme in themes:
-            return themes[theme]
-        raise ValueError(f"Unknown theme: {theme}. Available: {list(themes.keys())}")
-    return theme
-
-def _set_prod(config: Config, prod: bool):
-    config.prod = prod
-    config.pk = PK_LIVE if prod else PK_TEST
-    config.jwks = JWKS_PROD if prod else JWKS_TEST
-
-class AgentRuntime:
-    """Wraps an agent function with local/deploy/modal capabilities."""
-
-    def __init__(self, func, name, theme, pip, apt, copy, copy_public, modal_keys, auth, org, domain, header, intro, title, plan, analytics):
-        self.func = func
-        self.name = name
-        self.theme = _resolve_theme(theme)
-        self.pip = pip
-        self.apt = apt
-        self.copy = copy
-        self.copy_public = copy_public
-        self.modal_keys = modal_keys
-        self.domain = domain or f"{name}.cycls.ai"
-
-        self.config = Config(
-            header=header,
-            intro=intro,
-            title=title,
-            auth=auth,
-            plan=plan,
-            analytics=analytics,
-            org=org,
-        )
-
-    def __call__(self, *args, **kwargs):
-        """Make the runtime callable - delegates to the wrapped function."""
-        return self.func(*args, **kwargs)
-
-    def _local(self, port=8080):
-        """Run directly with uvicorn (no Docker)."""
-        print(f"Starting local server at localhost:{port}")
-        self.config.public_path = self.theme
-        _set_prod(self.config, False)
-        uvicorn.run(web(self.func, self.config), host="0.0.0.0", port=port)
-
-    def _runtime(self, prod=False):
-        """Create a Runtime instance for deployment."""
-        _set_prod(self.config, prod)
-        config_dict = self.config.model_dump()
-
-        # Extract to local variables to avoid capturing self in lambda (cloudpickle issue)
-        func = self.func
-        name = self.name
-
-        files = {str(self.theme): "theme", str(CYCLS_PATH)+"/web.py": "web.py"}
-        files.update({f: f for f in self.copy})
-        files.update({f: f"public/{f}" for f in self.copy_public})
-
-        return Runtime(
-            func=lambda port: __import__("web").serve(func, config_dict, name, port),
-            name=name,
-            apt_packages=self.apt,
-            pip_packages=["fastapi[standard]", "pyjwt", "cryptography", "uvicorn", *self.pip],
-            copy=files,
-            base_url=base_url,
-            api_key=api_key
-        )
-
-    def local(self, port=8080, watch=True):
-        """Run locally in Docker with file watching by default."""
-        if os.environ.get('_CYCLS_WATCH'):
-            watch = False
-        runtime = self._runtime(prod=False)
-        runtime.watch(port=port) if watch else runtime.run(port=port)
-
-    def deploy(self, port=8080):
-        """Deploy to production."""
-        if api_key is None:
-            raise RuntimeError("Missing API key. Set cycls.api_key before calling deploy().")
-        runtime = self._runtime(prod=True)
-        return runtime.deploy(port=port)
-
-    def modal(self, prod=False):
-        import modal
-        from modal.runner import run_app
-
-        # Extract to local variables to avoid capturing self in lambda
-        func = self.func
-        name = self.name
-        domain = self.domain
-
-        client = modal.Client.from_credentials(*self.modal_keys)
-        image = (modal.Image.debian_slim()
-                            .pip_install("fastapi[standard]", "pyjwt", "cryptography", *self.pip)
-                            .apt_install(*self.apt)
-                            .add_local_dir(self.theme, "/root/theme")
-                            .add_local_file(str(CYCLS_PATH)+"/web.py", "/root/web.py"))
-
-        for item in self.copy:
-            image = image.add_local_file(item, f"/root/{item}") if "." in item else image.add_local_dir(item, f'/root/{item}')
-
-        for item in self.copy_public:
-            image = image.add_local_file(item, f"/root/public/{item}") if "." in item else image.add_local_dir(item, f'/root/public/{item}')
-
-        app = modal.App("development", image=image)
-
-        _set_prod(self.config, prod)
-        config_dict = self.config.model_dump()
-
-        app.function(serialized=True, name=name)(
-            modal.asgi_app(label=name, custom_domains=[domain])
-            (lambda: __import__("web").web(func, config_dict))
-        )
-
-        if prod:
-            print(f"Deployed to => https://{domain}")
-            app.deploy(client=client, name=name)
-        else:
-            with modal.enable_output():
-                run_app(app=app, client=client)
-                print("Modal development server is running. Press Ctrl+C to stop.")
-                with modal.enable_output(), run_app(app=app, client=client):
-                    while True: time.sleep(10)
-
-
-def agent(name=None, pip=None, apt=None, copy=None, copy_public=None, theme="default", modal_keys=None, auth=False, org=None, domain=None, header="", intro="", title="", plan="free", analytics=False):
-    """Decorator that transforms a function into a deployable agent."""
-    pip = pip or []
-    apt = apt or []
-    copy = copy or []
-    copy_public = copy_public or []
-    modal_keys = modal_keys or ["", ""]
-
-    if plan == "cycls_pass":
-        auth = True
-        analytics = True
-
-    def decorator(func):
-        agent_name = name or func.__name__.replace('_', '-')
-        return AgentRuntime(
-            func=func,
-            name=agent_name,
-            theme=theme,
-            pip=pip,
-            apt=apt,
-            copy=copy,
-            copy_public=copy_public,
-            modal_keys=modal_keys,
-            auth=auth,
-            org=org,
-            domain=domain,
-            header=header,
-            intro=intro,
-            title=title,
-            plan=plan,
-            analytics=analytics,
-        )
-    return decorator
-
-def function(python_version=None, pip=None, apt=None, run_commands=None, copy=None, name=None):
-    """Decorator that transforms a Python function into a containerized, remotely executable object."""
-    def decorator(func):
-        func_name = name or func.__name__
-        copy_dict = {i: i for i in copy or []}
-        return Runtime(func, func_name.replace('_', '-'), python_version, pip, apt, run_commands, copy_dict, base_url, api_key)
-    return decorator

cycls-0.0.2.82.dist-info/RECORD

@@ -1,20 +0,0 @@
-cycls/__init__.py,sha256=vyI1d_8VP4XW7MliFuUs_P3O9KQxyCwQu-JkxrCyhPQ,597
-cycls/auth.py,sha256=xkndHZyCfnlertMMEKerCJjf23N3fVcTRVTTSXTTuzg,247
-cycls/chat.py,sha256=cVbIkTDnVofohvByyYUrXF_RYDQZVQECJqo7cPBPJfs,4781
-cycls/default-theme/assets/index-C2r4Daz3.js,sha256=OGzjspxo0uUTdtQIzWZNgFMhGUtW4wSVuW33iA7oLFM,1351283
-cycls/default-theme/assets/index-DWGS8zpa.css,sha256=SxylXQV1qgQ0sw9QlMxcu9jwWTu8XPOnWZju8upUpCM,6504
-cycls/default-theme/index.html,sha256=WPUqVzJyh-aO2ulWTbXwOVAfWHaj0yWTGd9e8HOEro4,828
-cycls/dev-theme/index.html,sha256=QJBHkdNuMMiwQU7o8dN8__8YQeQB45D37D-NCXIWB2Q,11585
-cycls/grpc/__init__.py,sha256=sr8UQMgJEHyBreBKV8xz8UCd0zDP5lhjXTnfkOB_yOY,63
-cycls/grpc/client.py,sha256=GJoWlh2gP3YWEQ75-dX-IInyOdr2YSM8Cuw0lI-vD1I,2302
-cycls/grpc/runtime.proto,sha256=B1AqrNIXOtr3Xsyzfc2Z1OCBepa6hsi4DJ4a3Pf33IQ,244
-cycls/grpc/runtime_pb2.py,sha256=vEJo8FGP5aWPSDqzjZldfctduA2ojiyvoody7vpf-1w,1703
-cycls/grpc/runtime_pb2_grpc.py,sha256=KFd8KqGbiNsKm8X39Q9_BPwXjeZUiDl8O_4aTlEys3k,3394
-cycls/grpc/server.py,sha256=pfb4bo06NKDv0OpknqMSMjB9f8HUR41EZau1c6_XU5A,1911
-cycls/runtime.py,sha256=CORCjI-AW-cE6zg_blQsbLHchcM6coJo6b3N4PriuWo,18072
-cycls/sdk.py,sha256=yOLAOx26qaAgddLu7QcAroeaQ2eWqIjCvM7QmCe-OJs,6760
-cycls/web.py,sha256=mRzuOVZPEMW6bLkzEDHI25AWYBREqbtoHsBzgGbUH4g,5038
-cycls-0.0.2.82.dist-info/METADATA,sha256=NUxfEBA8eEphR60zB5MfkvBWUrNk0OlYo1afVBgMlLU,8759
-cycls-0.0.2.82.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cycls-0.0.2.82.dist-info/entry_points.txt,sha256=0NBXjzFFxdtO57z3vdaQEy68KmYTEgwK9Gvo34AOTb4,41
-cycls-0.0.2.82.dist-info/RECORD,,

cycls-0.0.2.82.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-cycls=cycls.chat:main
-