cycls 0.0.2.34__tar.gz → 0.0.2.36__tar.gz

{cycls-0.0.2.34 → cycls-0.0.2.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cycls
-Version: 0.0.2.34
+Version: 0.0.2.36
 Summary: Cycls SDK
 Author: Mohammed J. AlRujayi
 Author-email: mj@cycls.com

{cycls-0.0.2.34 → cycls-0.0.2.36}/cycls/runtime.py

@@ -9,14 +9,6 @@ from pathlib import Path
 from contextlib import contextmanager
 import tarfile
 
-# --- Docker Client Initialization ---
-try:
-    docker_client = docker.from_env()
-except docker.errors.DockerException:
-    print("❌ Error: Docker is not running or not installed.")
-    print("Please start the Docker daemon and try again.")
-    sys.exit(1)
-
 # --- Top-Level Helper Functions ---
 
 def _bootstrap_script(payload_file: str, result_file: str) -> str:
@@ -84,7 +76,7 @@ class Runtime:
     """
     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):
         self.func = func
-        self.python_version = python_version or "3.12"
+        self.python_version = python_version or f"{sys.version_info.major}.{sys.version_info.minor}"
         self.pip_packages = sorted(pip_packages or [])
         self.apt_packages = sorted(apt_packages or [])
         self.run_commands = sorted(run_commands or [])
@@ -104,6 +96,51 @@ class Runtime:
         self.tag = self._generate_base_tag()
 
         self.api_key = api_key
+        self._docker_client = None
+        self.managed_label = f"cycls.runtime"
+
+    @property
+    def docker_client(self):
+        """
+        Lazily initializes and returns a Docker client.
+        This ensures Docker is only required for methods that actually use it.
+        """
+        if self._docker_client is None:
+            try:
+                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.")
+                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."""
+        try:
+            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:
+                    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})
+
+        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."""
@@ -132,11 +169,7 @@ class Runtime:
             if self.apt_packages else ""
         )
         run_shell_commands = "\n".join([f"RUN {cmd}" for cmd in self.run_commands]) if self.run_commands else ""
-
-        # fixes absolute path copy, but causes collision
-        copy_lines = "\n".join([f"COPY {Path(src).name} {dst}" for src, dst in self.copy.items()])
-        # copy_lines = "\n".join([f"COPY {src} {dst}" for src, dst in self.copy.items()])
-
+        copy_lines = "\n".join([f"COPY context_files/{dst} {dst}" for dst in self.copy.values()])
         expose_line = f"EXPOSE {port}" if port else ""
 
         return f"""
@@ -162,6 +195,16 @@ COPY {self.payload_file} {self.io_dir}/
         """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()
+
+        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)
+
         (workdir / "Dockerfile").write_text(self._generate_dockerfile(port=port))
         (workdir / self.runner_filename).write_text(self.runner_script)
 
@@ -169,20 +212,10 @@ COPY {self.payload_file} {self.io_dir}/
             payload_bytes = cloudpickle.dumps((self.func, args or [], kwargs or {}))
             (workdir / self.payload_file).write_bytes(payload_bytes)
 
-        if self.copy:
-            # for src in self.copy.keys():
-            #     _copy_path(Path(src), workdir / src)
-
-            # fixes absolute path copy
-            for src in self.copy.keys():
-                src_path = Path(src)
-                dest_path = workdir / src_path.name if src_path.is_absolute() else workdir / src
-                _copy_path(src_path, dest_path)
-
     def _build_image_if_needed(self):
         """Checks if the base Docker image exists locally and builds it if not."""
         try:
-            docker_client.images.get(self.tag)
+            self.docker_client.images.get(self.tag)
             print(f"✅ Found cached base image: {self.tag}")
             return
         except docker.errors.ImageNotFound:
@@ -194,12 +227,13 @@ COPY {self.payload_file} {self.io_dir}/
             self._prepare_build_context(tmpdir)
             
             print("--- 🐳 Docker Build Logs (Base Image) ---")
-            response_generator = docker_client.api.build(
+            response_generator = self.docker_client.api.build(
                 path=str(tmpdir),
                 tag=self.tag,
                 forcerm=True,
                 decode=True,
-                target='base' # Only build the 'base' stage
+                target='base', # Only build the 'base' stage
+                labels={self.managed_label: "true"}, # image label
             )
             try:
                 for chunk in response_generator:
@@ -215,6 +249,7 @@ COPY {self.payload_file} {self.io_dir}/
     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
@@ -228,10 +263,11 @@ COPY {self.payload_file} {self.io_dir}/
                 cloudpickle.dump((self.func, args, kwargs), f)
 
             try:
-                container = docker_client.containers.create(
+                container = self.docker_client.containers.create(
                     image=self.tag,
                     volumes={str(tmpdir): {'bind': self.io_dir, 'mode': 'rw'}},
-                    ports=ports_mapping
+                    ports=ports_mapping,
+                    labels={self.managed_label: "true"} # container label
                 )
                 container.start()
                 yield container, result_path
@@ -279,7 +315,7 @@ COPY {self.payload_file} {self.io_dir}/
         final_tag = f"{self.image_prefix}:deploy-{payload_hash}"
 
         try:
-            docker_client.images.get(final_tag)
+            self.docker_client.images.get(final_tag)
             print(f"✅ Found cached deployable image: {final_tag}")
             return final_tag
         except docker.errors.ImageNotFound:
@@ -290,7 +326,7 @@ COPY {self.payload_file} {self.io_dir}/
             self._prepare_build_context(tmpdir, include_payload=True, args=args, kwargs=kwargs)
 
             print("--- 🐳 Docker Build Logs (Final Image) ---")
-            response_generator = docker_client.api.build(
+            response_generator = self.docker_client.api.build(
                 path=str(tmpdir), tag=final_tag, forcerm=True, decode=True
             )
             try:

{cycls-0.0.2.34 → cycls-0.0.2.36}/cycls/sdk.py

@@ -16,12 +16,13 @@ class Agent:
 
         self.registered_functions = []
 
-    def __call__(self, name="", header="", intro="", domain=None, auth=False):
+    def __call__(self, name=None, header="", intro="", domain=None, auth=False):
         def decorator(f):
             self.registered_functions.append({
                 "func": f,
                 "config": ["public", False, self.org, self.api_token, header, intro, auth],
-                "name": name,
+                # "name": name,
+                "name": name or (f.__name__).replace('_', '-'),
                 "domain": domain or f"{name}.cycls.ai",
             })
             return f
@@ -40,7 +41,7 @@ class Agent:
         uvicorn.run(web(i["func"], *i["config"]), host="0.0.0.0", port=port)
         return
 
-    def deploy(self, prod=False, port=8080):
+    def cycls(self, prod=False, port=8080):
         if not self.registered_functions:
             print("Error: No @agent decorated function found.")
             return
@@ -54,11 +55,15 @@ class Agent:
 
         i["config"][6] = False
 
+        copy={str(cycls_path.joinpath('theme')):"public", str(cycls_path)+"/web.py":"app/web.py"}
+        copy.update({i:i for i in self.copy})
+
         new = Runtime(
             func=lambda port: __import__("uvicorn").run(__import__("web").web(i["func"], *i["config"]), host="0.0.0.0", port=port),
-            name="web-agent",
+            name=i["name"],
+            apt_packages=self.apt,
             pip_packages=["fastapi[standard]", "pyjwt", "cryptography", "uvicorn", *self.pip],
-            copy={str(cycls_path.joinpath('theme')):"public", str(cycls_path)+"/web.py":"app/web.py"},
+            copy=copy,
             api_key=self.api_key
         )
         new.deploy(port=port) if prod else new.run(port=port) 
@@ -97,6 +102,7 @@ class Agent:
                 with modal.enable_output(), run_app(app=self.app, client=self.client): 
                     while True: time.sleep(10)
 
+# docker system prune -af
 # poetry config pypi-token.pypi <your-token>
-# poetry run python agent.py
+# poetry run python agent-cycls.py
 # poetry publish --build

{cycls-0.0.2.34 → cycls-0.0.2.36}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cycls"
-version = "0.0.2.34"
+version = "0.0.2.36"
 
 packages = [{ include = "cycls" }]
 include = ["cycls/theme/**/*"]