cycls 0.0.2.74__py3-none-any.whl → 0.0.2.75__py3-none-any.whl

cycls/grpc/__init__.py

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

cycls/grpc/client.py

@@ -0,0 +1,71 @@
+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(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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,40 @@
+# -*- 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

@@ -0,0 +1,100 @@
+# 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

@@ -0,0 +1,60 @@
+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/runtime.py

@@ -1,3 +1,4 @@
+import contextlib
 import docker
 import cloudpickle
 import tempfile
@@ -6,44 +7,27 @@ import os
 import sys
 import shutil
 from pathlib import Path
-from contextlib import contextmanager
 import tarfile
 
-# Enable BuildKit for faster builds with better caching
-os.environ["DOCKER_BUILDKIT"] = "1"
-
-# --- Top-Level Helper Functions ---
+from .grpc import RuntimeClient
 
-def _bootstrap_script(payload_file: str, result_file: str) -> str:
-    """Generates the Python script that runs inside the Docker container."""
-    return f"""
-import cloudpickle
-import sys
-import os
-import traceback
-from pathlib import Path
-
-if __name__ == "__main__":
-    io_dir = Path(sys.argv[1])
-    payload_path = io_dir / '{payload_file}'
-    result_path = io_dir / '{result_file}'
-
-    try:
-        with open(payload_path, 'rb') as f:
-            func, args, kwargs = cloudpickle.load(f)
+os.environ["DOCKER_BUILDKIT"] = "1"
 
-        result = func(*args, **kwargs)
+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"}
 
-        with open(result_path, 'wb') as f:
-            cloudpickle.dump(result, f)
+# 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)
+'''
 
-    except Exception as e:
-        traceback.print_exc(file=sys.stderr)
-        sys.exit(1)
-"""
 
 def _hash_path(path_str: str) -> str:
-    """Hashes a file or a directory's contents to create a deterministic signature."""
     h = hashlib.sha256()
     p = Path(path_str)
     if p.is_file():
@@ -56,478 +40,416 @@ def _hash_path(path_str: str) -> str:
             files.sort()
             for name in files:
                 filepath = Path(root) / name
-                relpath = filepath.relative_to(p)
-                h.update(str(relpath).encode())
+                h.update(str(filepath.relative_to(p)).encode())
                 with filepath.open('rb') as f:
                     while chunk := f.read(65536):
                         h.update(chunk)
     return h.hexdigest()
 
+
 def _copy_path(src_path: Path, dest_path: Path):
-    """Recursively copies a file or directory to a destination path."""
     if src_path.is_dir():
         shutil.copytree(src_path, dest_path, dirs_exist_ok=True)
     else:
         dest_path.parent.mkdir(parents=True, exist_ok=True)
         shutil.copy(src_path, dest_path)
 
-# Pre-built base image with common dependencies
-BASE_IMAGE = "ghcr.io/cycls/base:python3.12"
-BASE_PACKAGES = {
-    "cloudpickle", "cryptography", "fastapi", "fastapi[standard]",
-    "pydantic", "pyjwt", "uvicorn", "uvicorn[standard]", "httpx"
-}
-
-# --- Main Runtime Class ---
 
 class Runtime:
-    """
-    Handles building a Docker image and executing a function within a container.
-    """
-    def __init__(self, func, name, python_version=None, pip_packages=None, apt_packages=None, run_commands=None, copy=None, base_url=None, api_key=None, base_image=None):
+    """Executes functions in Docker containers. Uses gRPC for local dev, pickle for deploy."""
+
+    def __init__(self, func, name, python_version=None, pip_packages=None, apt_packages=None,
+                 run_commands=None, copy=None, base_url=None, api_key=None, base_image=None):
         self.func = func
+        self.name = name
         self.python_version = python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
         self.apt_packages = sorted(apt_packages or [])
         self.run_commands = sorted(run_commands or [])
         self.copy = copy or {}
-        self.name = name
-        self.base_url = base_url or "https://service-core-280879789566.me-central1.run.app"
-        self.image_prefix = f"cycls/{name}"
-
-        # Use pre-built base image by default, filter out already-installed packages
         self.base_image = base_image or BASE_IMAGE
-        all_pip = set(pip_packages or [])
-        self.pip_packages = sorted(all_pip - BASE_PACKAGES) if self.base_image == BASE_IMAGE else sorted(all_pip)
-
-        # Standard paths and filenames used inside the container
-        self.io_dir = "/app/io"
-        self.runner_filename = "runner.py"
-        self.runner_path = f"/app/{self.runner_filename}"
-        self.payload_file = "payload.pkl"
-        self.result_file = "result.pkl"
+        self.base_url = base_url or "https://service-core-280879789566.me-central1.run.app"
+        self.api_key = api_key
 
-        self.runner_script = _bootstrap_script(self.payload_file, self.result_file)
-        self.tag = self._generate_base_tag()
+        # Compute pip packages (gRPC only needed for local dev, added dynamically)
+        user_packages = set(pip_packages or [])
+        if self.base_image == BASE_IMAGE:
+            self.pip_packages = sorted(user_packages - BASE_PACKAGES)
+        else:
+            self.pip_packages = sorted(user_packages | {"cloudpickle"})
 
-        self.api_key = api_key
+        self.image_prefix = f"cycls/{name}"
+        self.managed_label = "cycls.runtime"
         self._docker_client = None
-        self.managed_label = f"cycls.runtime"
+
+        # 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.
-        This ensures Docker is only required for methods that actually use it.
-        """
+        """Lazily initializes and returns a Docker client."""
         if self._docker_client is None:
             try:
-                print("🐳 Initializing Docker client...")
+                print("Initializing Docker client...")
                 client = docker.from_env()
                 client.ping()
                 self._docker_client = client
             except docker.errors.DockerException:
-                print("\n❌ Error: Docker is not running or is not installed.")
-                print("   This is required for local 'run' and 'build' operations.")
-                print("   Please start the Docker daemon and try again.")
+                print("\nError: Docker is not running or is not installed.")
+                print("Please start the Docker daemon and try again.")
                 sys.exit(1)
         return self._docker_client
-    
-    # docker system prune -af
-    def _perform_auto_cleanup(self):
-        """Performs a simple, automatic cleanup of old Docker resources."""
+
+    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}):
-                container.remove(force=True)
-
-            cleaned_images = 0
-            for image in self.docker_client.images.list(all=True, filters={"label": self.managed_label}):
-                is_current = self.tag in image.tags
-                is_deployable = any(t.startswith(f"{self.image_prefix}:deploy-") for t in image.tags)
-
-                if not is_current and not is_deployable:
+                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)
+                is_current = keep_tag and keep_tag in image.tags
+                if not is_deploy and not is_current:
                     self.docker_client.images.remove(image.id, force=True)
-                    cleaned_images += 1
-            
-            if cleaned_images > 0:
-                print(f"🧹 Cleaned up {cleaned_images} old image version(s).")
-
-            self.docker_client.images.prune(filters={'label': self.managed_label})
-
+                    cleaned += 1
+            if cleaned:
+                print(f"Cleaned up {cleaned} old dev image(s).")
         except Exception as e:
-            print(f"⚠️  An error occurred during cleanup: {e}")
-
-    def _generate_base_tag(self) -> str:
-        """Creates a unique tag for the base Docker image based on its dependencies."""
-        signature_parts = [
-            self.base_image,
-            "".join(self.python_version),
-            "".join(self.pip_packages),
-            "".join(self.apt_packages),
-            "".join(self.run_commands),
-            self.runner_script
-        ]
+            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)]
         for src, dst in sorted(self.copy.items()):
             if not Path(src).exists():
                 raise FileNotFoundError(f"Path in 'copy' not found: {src}")
-            content_hash = _hash_path(src)
-            signature_parts.append(f"copy:{src}>{dst}:{content_hash}")
+            parts.append(f"{src}>{dst}:{_hash_path(src)}")
+        if extra_parts:
+            parts.extend(extra_parts)
+        return f"{self.image_prefix}:{hashlib.sha256(''.join(parts).encode()).hexdigest()[:16]}"
 
-        signature = "".join(signature_parts)
-        image_hash = hashlib.sha256(signature.encode()).hexdigest()
-        return f"{self.image_prefix}:{image_hash[:16]}"
+    def _dockerfile_preamble(self, pip_extras=None) -> str:
+        """Common Dockerfile setup: base image, apt, pip, run commands, copy."""
+        lines = [f"FROM {self.base_image}"]
 
-    def _generate_dockerfile(self, port=None) -> str:
-        """Generates a multi-stage Dockerfile string."""
-        using_base = self.base_image == BASE_IMAGE
+        if self.base_image != BASE_IMAGE:
+            lines.append("ENV PIP_ROOT_USER_ACTION=ignore PYTHONUNBUFFERED=1")
+            lines.append("WORKDIR /app")
 
-        # Only install extra packages not in base image (use uv if available in base)
-        run_pip_install = (
-            f"RUN uv pip install --system --no-cache {' '.join(self.pip_packages)}"
-            if self.pip_packages else ""
-        )
-        run_apt_install = (
-            f"RUN apt-get update && apt-get install -y --no-install-recommends {' '.join(self.apt_packages)}"
-            if self.apt_packages else ""
-        )
-        run_shell_commands = "\n".join([f"RUN {cmd}" for cmd in self.run_commands]) if self.run_commands else ""
-        copy_lines = "\n".join([f"COPY context_files/{dst} {dst}" for dst in self.copy.values()])
-        expose_line = f"EXPOSE {port}" if port else ""
-
-        # Skip env/mkdir/workdir if using pre-built base (already configured)
-        env_lines = "" if using_base else f"""ENV PIP_ROOT_USER_ACTION=ignore \\
-    PYTHONUNBUFFERED=1
-RUN mkdir -p {self.io_dir}
-WORKDIR /app"""
-
-        return f"""
-# STAGE 1: Base image with all dependencies
-FROM {self.base_image} as base
-{env_lines}
-{run_apt_install}
-{run_pip_install}
-{run_shell_commands}
-{copy_lines}
-COPY {self.runner_filename} {self.runner_path}
-ENTRYPOINT ["python", "{self.runner_path}", "{self.io_dir}"]
-
-# STAGE 2: Final deployable image with the payload "baked in"
-FROM base
-{expose_line}
-COPY {self.payload_file} {self.io_dir}/
-"""
+        if self.apt_packages:
+            lines.append(f"RUN apt-get update && apt-get install -y --no-install-recommends {' '.join(self.apt_packages)}")
 
-    def _prepare_build_context(self, workdir: Path, include_payload=False, args=None, kwargs=None):
-        """Prepares a complete build context in the given directory."""
-        port = kwargs.get('port') if kwargs else None
-        
-        # Create a dedicated subdirectory for all user-copied files
-        context_files_dir = workdir / "context_files"
-        context_files_dir.mkdir()
+        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)}")
+
+        for cmd in self.run_commands:
+            lines.append(f"RUN {cmd}")
 
-        if self.copy:
-            for src, dst in self.copy.items():
-                src_path = Path(src).resolve() # Resolve to an absolute path
-                dest_in_context = context_files_dir / dst
-                _copy_path(src_path, dest_in_context)
+        for dst in self.copy.values():
+            lines.append(f"COPY context_files/{dst} /app/{dst}")
 
-        (workdir / "Dockerfile").write_text(self._generate_dockerfile(port=port))
-        (workdir / self.runner_filename).write_text(self.runner_script)
+        return "\n".join(lines)
 
-        if include_payload:
-            payload_bytes = cloudpickle.dumps((self.func, args or [], kwargs or {}))
-            (workdir / self.payload_file).write_bytes(payload_bytes)
+    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_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
+EXPOSE {port}
+CMD ["python", "entrypoint.py"]
+"""
 
-    def _build_image_if_needed(self):
-        """Checks if the base Docker image exists locally and builds it if not."""
+    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:
-            self.docker_client.images.get(self.tag)
-            print(f"✅ Found cached base image: {self.tag}")
-            return
+            for chunk in self.docker_client.api.build(
+                path=str(workdir), tag=tag, forcerm=True, decode=True,
+                labels={self.managed_label: "true"}
+            ):
+                if 'stream' in chunk:
+                    print(chunk['stream'].strip())
+            print("-------------------------")
+            print(f"Image built: {tag}")
+            return tag
+        except docker.errors.BuildError as e:
+            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"])
+        try:
+            self.docker_client.images.get(tag)
+            print(f"Found cached image: {tag}")
+            return tag
         except docker.errors.ImageNotFound:
-            print(f"🛠️  Building new base image: {self.tag}")
-
-        with tempfile.TemporaryDirectory() as tmpdir_str:
-            tmpdir = Path(tmpdir_str)
-            # Prepare context without payload for the base image
-            self._prepare_build_context(tmpdir)
-            
-            print("--- 🐳 Docker Build Logs (Base Image) ---")
-            response_generator = self.docker_client.api.build(
-                path=str(tmpdir),
-                tag=self.tag,
-                forcerm=True,
-                decode=True,
-                target='base', # Only build the 'base' stage
-                labels={self.managed_label: "true"}, # image label
-            )
-            try:
-                for chunk in response_generator:
-                    if 'stream' in chunk:
-                        print(chunk['stream'].strip())
-                print("----------------------------------------")
-                print(f"✅ Base image built successfully: {self.tag}")
-            except docker.errors.BuildError as e:
-                print(f"\n❌ Docker build failed. Reason: {e}")
-                raise
-
-    @contextmanager
-    def runner(self, *args, **kwargs):
-        """Context manager to set up, run, and tear down the container for local execution."""
-        port = kwargs.get('port', None)
-        self._perform_auto_cleanup()
-        self._build_image_if_needed()
-        container = None
-        ports_mapping = {f'{port}/tcp': port} if port else None
+            print(f"Building new image: {tag}")
 
-        with tempfile.TemporaryDirectory() as tmpdir_str:
-            tmpdir = Path(tmpdir_str)
-            payload_path = tmpdir / self.payload_file
-            result_path = tmpdir / self.result_file
+        with tempfile.TemporaryDirectory() as tmpdir:
+            workdir = Path(tmpdir)
+            self._copy_user_files(workdir)
+            (workdir / "Dockerfile").write_text(self._dockerfile_grpc())
 
-            with payload_path.open('wb') as f:
-                cloudpickle.dump((self.func, args, kwargs), f)
+            # Copy gRPC runtime
+            grpc_src = Path(__file__).parent / "grpc"
+            shutil.copytree(grpc_src, workdir / "grpc_runtime",
+                          ignore=shutil.ignore_patterns('*.proto', '__pycache__'))
 
+            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:
+            try:
+                self._container.reload()
+                if self._container.status == 'running':
+                    return self._client
+            except:
+                pass
+            self._cleanup_container()
+
+        tag = self._ensure_grpc_image()
+        self._perform_auto_cleanup(keep_tag=tag)
+
+        # Port mappings
+        ports = {f'{GRPC_PORT}/tcp': None}
+        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._container.reload()
+        self._host_port = int(self._container.ports[f'{GRPC_PORT}/tcp'][0]['HostPort'])
+
+        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
+
+    def _cleanup_container(self):
+        """Stop and remove the warm container."""
+        if self._client:
+            self._client.close()
+            self._client = None
+        if self._container:
             try:
-                container = self.docker_client.containers.create(
-                    image=self.tag,
-                    volumes={str(tmpdir): {'bind': self.io_dir, 'mode': 'rw'}},
-                    ports=ports_mapping,
-                    labels={self.managed_label: "true"} # container label
-                )
-                container.start()
-                yield container, result_path
-            finally:
-                if container:
-                    print("\n🧹 Cleaning up container...")
-                    try:
-                        container.stop(timeout=5)
-                        container.remove()
-                        print("✅ Container stopped and removed.")
-                    except docker.errors.APIError as e:
-                        print(f"⚠️  Could not clean up container: {e}")
+                self._container.stop(timeout=3)
+                self._container.remove()
+            except:
+                pass
+            self._container = None
+        self._host_port = None
 
     def run(self, *args, **kwargs):
-        """Executes the function in a new Docker container and waits for the result."""
-        print(f"🚀 Running function '{self.name}' in container...")
+        """Execute the function in a container and return the result."""
+        service_port = kwargs.get('port')
+        print(f"Running '{self.name}'...")
         try:
-            with self.runner(*args, **kwargs) as (container, result_path):
-                print("--- 🪵 Container Logs (streaming) ---")
-                for chunk in container.logs(stream=True, follow=True):
-                    print(chunk.decode('utf-8').strip())
-                print("------------------------------------")
-
-                result_status = container.wait()
-                if result_status['StatusCode'] != 0:
-                    print(f"\n❌ Error: Container exited with code: {result_status['StatusCode']}")
-                    return None
-                
-                if result_path.exists():
-                    with result_path.open('rb') as f:
-                        result = cloudpickle.load(f)
-                    print("✅ Function executed successfully.")
-                    return result
-                else:
-                    print("\n❌ Error: Result file not found.")
-                    return None
-        except (KeyboardInterrupt, docker.errors.DockerException) as e:
-            print(f"\n🛑 Operation stopped: {e}")
+            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):
+                    print(chunk.decode(), end='')
+                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
+
+        except KeyboardInterrupt:
+            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):
-        """Runs the container with file watching - restarts script on changes."""
+        """Run with file watching - restarts script on changes."""
         try:
             from watchfiles import watch as watchfiles_watch
         except ImportError:
-            print("❌ watchfiles not installed. Run: pip install watchfiles")
+            print("watchfiles not installed. Run: pip install watchfiles")
             return
 
         import inspect
         import subprocess
 
-        # Get the main script (the outermost .py file in the stack)
+        # Find the user's script (outside cycls package)
+        cycls_pkg = Path(__file__).parent.resolve()
         main_script = None
         for frame_info in inspect.stack():
-            filename = frame_info.filename
-            if filename.endswith('.py') and not filename.startswith('<'):
-                main_script = Path(filename).resolve()
-        # main_script is now the outermost/first script in the call chain
-
-        # Build watch paths: main script + copy sources
-        watch_paths = []
-        if main_script and main_script.exists():
-            watch_paths.append(main_script)
-        watch_paths.extend([Path(src).resolve() for src in self.copy.keys() if Path(src).exists()])
+            filepath = Path(frame_info.filename).resolve()
+            if filepath.suffix == '.py' and not str(filepath).startswith(str(cycls_pkg)):
+                main_script = filepath
+                break
 
-        if not watch_paths:
-            print("⚠️  No files to watch. Running without watch mode.")
+        if not main_script:
+            print("Could not find script to watch.")
             return self.run(*args, **kwargs)
 
-        print(f"👀 Watching for changes:")
+        # Build watch paths
+        watch_paths = [main_script]
+        watch_paths.extend([Path(src).resolve() for src in self.copy.keys() if Path(src).exists()])
+
+        print(f"👀 Watching:")
         for p in watch_paths:
             print(f"   {p}")
         print()
 
         while True:
-            # Run the script in a subprocess so we survive errors
-            print(f"🚀 Running {main_script.name}...")
+            print(f"🚀 Starting {main_script.name}...")
             proc = subprocess.Popen(
                 [sys.executable, str(main_script)],
-                env={**os.environ, '_CYCLS_WATCH_CHILD': '1'}
+                env={**os.environ, '_CYCLS_WATCH': '1'}
             )
 
             try:
-                # Watch for changes
                 for changes in watchfiles_watch(*watch_paths):
-                    changed_files = [str(c[1]) for c in changes]
-                    print(f"\n🔄 Changes detected:")
-                    for f in changed_files:
-                        print(f"   {f}")
+                    print(f"\n🔄 Changed: {[Path(c[1]).name for c in changes]}")
                     break
 
-                print("\n🔄 Restarting...\n")
                 proc.terminate()
-                try:
-                    proc.wait(timeout=3)
-                except subprocess.TimeoutExpired:
-                    proc.kill()
-
+                proc.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                proc.kill()
             except KeyboardInterrupt:
-                print("\n🛑 Stopping...")
+                print("\nStopping...")
                 proc.terminate()
-                try:
-                    proc.wait(timeout=3)
-                except subprocess.TimeoutExpired:
-                    proc.kill()
+                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
+        self._copy_user_files(workdir)
+        (workdir / "Dockerfile").write_text(self._dockerfile_deploy(port))
+        (workdir / "entrypoint.py").write_text(ENTRYPOINT_PY)
+        with open(workdir / "function.pkl", "wb") as f:
+            cloudpickle.dump((self.func, args, kwargs), f)
+
     def build(self, *args, **kwargs):
-        """Builds a self-contained, deployable Docker image locally."""
-        print("📦 Building self-contained image for deployment...")
-        payload_hash = hashlib.sha256(cloudpickle.dumps((self.func, args, kwargs))).hexdigest()[:16]
-        final_tag = f"{self.image_prefix}:deploy-{payload_hash}"
+        """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]}"
 
         try:
-            self.docker_client.images.get(final_tag)
-            print(f"✅ Found cached deployable image: {final_tag}")
-            return final_tag
+            self.docker_client.images.get(tag)
+            print(f"Found cached image: {tag}")
+            return tag
         except docker.errors.ImageNotFound:
-            print(f"🛠️  Building new deployable image: {final_tag}")
+            print(f"Building: {tag}")
 
-        with tempfile.TemporaryDirectory() as tmpdir_str:
-            tmpdir = Path(tmpdir_str)
-            self._prepare_build_context(tmpdir, include_payload=True, args=args, kwargs=kwargs)
-
-            print("--- 🐳 Docker Build Logs (Final Image) ---")
-            response_generator = self.docker_client.api.build(
-                path=str(tmpdir), tag=final_tag, forcerm=True, decode=True
-            )
-            try:
-                for chunk in response_generator:
-                    if 'stream' in chunk:
-                        print(chunk['stream'].strip())
-                print("-----------------------------------------")
-                print(f"✅ Image built successfully: {final_tag}")
-                port = kwargs.get('port') if kwargs else None
-                print(f"🤖 Run: docker run --rm -d -p {port}:{port} {final_tag}")
-                return final_tag
-            except docker.errors.BuildError as e:
-                print(f"\n❌ Docker build failed. Reason: {e}")
-                return None
+        with tempfile.TemporaryDirectory() as tmpdir:
+            workdir = Path(tmpdir)
+            self._prepare_deploy_context(workdir, port, args, kwargs)
+            self._build_image(tag, workdir)
+            print(f"Run: docker run --rm -p {port}:{port} {tag}")
+            return tag
 
     def deploy(self, *args, **kwargs):
-        """Deploys the function by sending it to a remote build server."""
+        """Deploy the function to a remote build server."""
         import requests
 
-        print(f"🚀 Preparing to deploy function '{self.name}'")
+        port = kwargs.pop('port', 8080)
+        print(f"Deploying '{self.name}'...")
+
+        payload = cloudpickle.dumps((self.func, args, {**kwargs, 'port': port}))
+        archive_name = f"{self.name}-{hashlib.sha256(payload).hexdigest()[:16]}.tar.gz"
 
-        # 1. Prepare the build context and compress it into a tarball
-        payload_hash = hashlib.sha256(cloudpickle.dumps((self.func, args, kwargs))).hexdigest()[:16]
-        archive_name = f"source-{self.tag.split(':')[1]}-{payload_hash}.tar.gz"
+        with tempfile.TemporaryDirectory() as tmpdir:
+            workdir = Path(tmpdir)
+            self._prepare_deploy_context(workdir, port, args, kwargs)
 
-        with tempfile.TemporaryDirectory() as tmpdir_str:
-            tmpdir = Path(tmpdir_str)
-            self._prepare_build_context(tmpdir, include_payload=True, args=args, kwargs=kwargs)
-            
-            archive_path = Path(tmpdir_str) / archive_name
+            archive_path = workdir / archive_name
             with tarfile.open(archive_path, "w:gz") as tar:
-                # Add all files from the context to the tar archive
-                for f in tmpdir.glob("**/*"):
-                    if f.is_file():
-                        tar.add(f, arcname=f.relative_to(tmpdir))
-            
-            # 2. Prepare the request payload
-            port = kwargs.get('port', 8080)
-            data_payload = {
-                "function_name": self.name,
-                "port": port,
-                # "memory": "1Gi" # You could make this a parameter
-            }
-            headers = {
-                "X-API-Key": self.api_key
-            }
-
-            # 3. Upload to the deploy server
-            print("📦 Uploading build context to the deploy server...")
+                for f in workdir.glob("**/*"):
+                    if f.is_file() and f != archive_path:
+                        tar.add(f, arcname=f.relative_to(workdir))
+
+            print("Uploading build context...")
             try:
                 with open(archive_path, 'rb') as f:
-                    files = {'source_archive': (archive_name, f, 'application/gzip')}
-                    
                     response = requests.post(
                         f"{self.base_url}/v1/deploy",
-                        data=data_payload,
-                        files=files,
-                        headers=headers,
-                        timeout=5*1800 # Set a long timeout for the entire process
+                        data={"function_name": self.name, "port": port},
+                        files={'source_archive': (archive_name, f, 'application/gzip')},
+                        headers={"X-API-Key": self.api_key},
+                        timeout=9000
                     )
-
-                # 4. Handle the server's response
-                response.raise_for_status() # Raise an exception for 4xx/5xx errors
+                response.raise_for_status()
                 result = response.json()
-                
-                print(f"✅ Deployment successful!")
-                print(f"🔗 Service is available at: {result['url']}")
+                print(f"Deployed: {result['url']}")
                 return result['url']
 
             except requests.exceptions.HTTPError as e:
-                print(f"❌ Deployment failed. Server returned error: {e.response.status_code}")
+                print(f"Deploy failed: {e.response.status_code}")
                 try:
-                    # Try to print the detailed error message from the server
-                    print(f"   Reason: {e.response.json()['detail']}")
+                    print(f"  {e.response.json()['detail']}")
                 except:
-                    print(f"   Reason: {e.response.text}")
+                    print(f"  {e.response.text}")
                 return None
             except requests.exceptions.RequestException as e:
-                print(f"❌ Could not connect to the deploy server: {e}")
+                print(f"Connection error: {e}")
                 return None
 
-    def Deploy(self, *args, **kwargs):
-        try:
-            from .shared import upload_file_to_cloud, build_and_deploy_to_cloud
-        except ImportError:
-            print("❌ Shared not found. This is an internal method.")
-            return None
-
-        port = kwargs.get('port', 8080)
-        
-        with tempfile.TemporaryDirectory() as tmpdir_str:
-            tmpdir = Path(tmpdir_str)
-            self._prepare_build_context(tmpdir, include_payload=True, args=args, kwargs=kwargs)
-            
-            archive_path = Path(tmpdir_str) / "source.tar.gz"
-            with tarfile.open(archive_path, "w:gz") as tar:
-                for f in tmpdir.glob("**/*"):
-                    if f.is_file():
-                        tar.add(f, arcname=f.relative_to(tmpdir))
-
-            archive_name = upload_file_to_cloud(self.name, archive_path)
-
-        try:
-            service = build_and_deploy_to_cloud(
-            function_name=self.name,
-            gcs_object_name=archive_name,
-            port=port,
-            memory="1Gi"
-            )
-        except Exception as e:
-            print(f"❌ Cloud Deployment Failed: {e}")
-            return None
+    def __del__(self):
+        """Cleanup on garbage collection."""
+        self._cleanup_container()

cycls/sdk.py

@@ -88,7 +88,7 @@ class AgentRuntime:
 
     def local(self, port=8080, watch=True):
         """Run locally in Docker with file watching by default."""
-        if os.environ.get('_CYCLS_WATCH_CHILD'):
+        if os.environ.get('_CYCLS_WATCH'):
             watch = False
         runtime = self._runtime(prod=False)
         runtime.watch(port=port) if watch else runtime.run(port=port)

{cycls-0.0.2.74.dist-info → cycls-0.0.2.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cycls
-Version: 0.0.2.74
+Version: 0.0.2.75
 Summary: Distribute Intelligence
 Author: Mohammed J. AlRujayi
 Author-email: mj@cycls.com
@@ -16,6 +16,7 @@ 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: pyjwt (>=2.8.0,<3.0.0)

cycls-0.0.2.75.dist-info/RECORD

@@ -0,0 +1,20 @@
+cycls/__init__.py,sha256=vyI1d_8VP4XW7MliFuUs_P3O9KQxyCwQu-JkxrCyhPQ,597
+cycls/auth.py,sha256=xkndHZyCfnlertMMEKerCJjf23N3fVcTRVTTSXTTuzg,247
+cycls/cli.py,sha256=AKf0z7ZLau3GvBVR_IhB7agmq4nVaHkcuUafNyvv2_A,7978
+cycls/default-theme/assets/index-B0ZKcm_V.css,sha256=wK9-NhEB8xPcN9Zv69zpOcfGTlFbMwyC9WqTmSKUaKw,6546
+cycls/default-theme/assets/index-D5EDcI4J.js,sha256=sN4qRcAXa7DBd9JzmVcCoCwH4l8cNCM-U9QGUjBvWSo,1346506
+cycls/default-theme/index.html,sha256=bM-yW_g0cGrV40Q5yY3ccY0fM4zI1Wuu5I8EtGFJIxs,828
+cycls/dev-theme/index.html,sha256=QJBHkdNuMMiwQU7o8dN8__8YQeQB45D37D-NCXIWB2Q,11585
+cycls/grpc/__init__.py,sha256=sr8UQMgJEHyBreBKV8xz8UCd0zDP5lhjXTnfkOB_yOY,63
+cycls/grpc/client.py,sha256=zDFIBABXzuv_RUVn5LllppZ38C7k01RyAS8ZURBjudQ,2270
+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=1jkF1_8LeZewmwn-TztyMSTjcRhsoQK2RxSNq4cjCHk,17637
+cycls/sdk.py,sha256=_1tJ-lRQ1CmZ2y_9taXJhSDbHq0F674GvdiSRpgbTOk,6614
+cycls/web.py,sha256=_QNH8K55vTm90Z7tvcRKal5IybjkB1GY7Pf9p3qu3r8,4659
+cycls-0.0.2.75.dist-info/METADATA,sha256=X_9G2W3jfjl8SNQwzAb030SLmPKf9nru-ygE6sI7MCg,8459
+cycls-0.0.2.75.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cycls-0.0.2.75.dist-info/entry_points.txt,sha256=vEhqUxFhhuzCKWtq02LbMnT3wpUqdfgcM3Yh-jjXom8,40
+cycls-0.0.2.75.dist-info/RECORD,,

cycls-0.0.2.74.dist-info/RECORD

@@ -1,14 +0,0 @@
-cycls/__init__.py,sha256=vyI1d_8VP4XW7MliFuUs_P3O9KQxyCwQu-JkxrCyhPQ,597
-cycls/auth.py,sha256=xkndHZyCfnlertMMEKerCJjf23N3fVcTRVTTSXTTuzg,247
-cycls/cli.py,sha256=AKf0z7ZLau3GvBVR_IhB7agmq4nVaHkcuUafNyvv2_A,7978
-cycls/default-theme/assets/index-B0ZKcm_V.css,sha256=wK9-NhEB8xPcN9Zv69zpOcfGTlFbMwyC9WqTmSKUaKw,6546
-cycls/default-theme/assets/index-D5EDcI4J.js,sha256=sN4qRcAXa7DBd9JzmVcCoCwH4l8cNCM-U9QGUjBvWSo,1346506
-cycls/default-theme/index.html,sha256=bM-yW_g0cGrV40Q5yY3ccY0fM4zI1Wuu5I8EtGFJIxs,828
-cycls/dev-theme/index.html,sha256=QJBHkdNuMMiwQU7o8dN8__8YQeQB45D37D-NCXIWB2Q,11585
-cycls/runtime.py,sha256=lg7XKHd9fLV_bYksHv2LHf3Lq7HPAC3K5Tr8pNgQ7sM,21641
-cycls/sdk.py,sha256=X8-VAVqtksO0VGJIxlg02HLmeFpwtwMHWu9PNksS5kw,6620
-cycls/web.py,sha256=_QNH8K55vTm90Z7tvcRKal5IybjkB1GY7Pf9p3qu3r8,4659
-cycls-0.0.2.74.dist-info/METADATA,sha256=IXA6mD4bkkGRnGZjK_rQYDda-fEE8nI2ucgVVVIsJgQ,8419
-cycls-0.0.2.74.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cycls-0.0.2.74.dist-info/entry_points.txt,sha256=vEhqUxFhhuzCKWtq02LbMnT3wpUqdfgcM3Yh-jjXom8,40
-cycls-0.0.2.74.dist-info/RECORD,,