jvserve 2.0.10__tar.gz → 2.0.12__tar.gz

{jvserve-2.0.10 → jvserve-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.10
+Version: 2.0.12
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.

{jvserve-2.0.10 → jvserve-2.0.12}/jvserve/__init__.py

@@ -4,5 +4,5 @@ jvserve package initialization.
 This package provides the webserver for loading and interacting with JIVAS agents.
 """
 
-__version__ = "2.0.10"
+__version__ = "2.0.12"
 __supported__jivas__versions__ = ["2.0.0"]

{jvserve-2.0.10 → jvserve-2.0.12}/jvserve/cli.py

@@ -7,20 +7,80 @@ from contextlib import asynccontextmanager
 from typing import AsyncIterator, Optional
 
 from dotenv import load_dotenv
+from fastapi.responses import FileResponse, StreamingResponse
 from jac_cloud.jaseci.security import authenticator
+from jac_cloud.plugin.jaseci import NodeAnchor
 from jaclang.cli.cmdreg import cmd_registry
 from jaclang.plugin.default import hookimpl
 from jaclang.runtimelib.context import ExecutionContext
 from jaclang.runtimelib.machine import JacMachine
+from requests import Response
 from uvicorn import run as _run
 
 from jvserve.lib.agent_interface import AgentInterface
 from jvserve.lib.agent_pulse import AgentPulse
+from jvserve.lib.file_interface import (
+    DEFAULT_FILES_ROOT,
+    FILE_INTERFACE,
+    file_interface,
+)
 from jvserve.lib.jvlogger import JVLogger
 
 load_dotenv(".env")
 
 
+def serve_proxied_file(file_path: str) -> FileResponse | StreamingResponse:
+    """Serve a proxied file from a remote or local URL."""
+    import mimetypes
+
+    import requests
+    from fastapi import HTTPException
+
+    if FILE_INTERFACE == "local":
+        return FileResponse(path=os.path.join(DEFAULT_FILES_ROOT, file_path))
+
+    file_url = file_interface.get_file_url(file_path)
+
+    if file_url and ("localhost" in file_url or "127.0.0.1" in file_url):
+        # prevent recusive calls when env vars are not detected
+        raise HTTPException(status_code=500, detail="Environment not set up correctly")
+
+    if not file_url:
+        raise HTTPException(status_code=404, detail="File not found")
+
+    file_extension = os.path.splitext(file_path)[1].lower()
+
+    # List of extensions to serve directly
+    direct_serve_extensions = [
+        ".pdf",
+        ".html",
+        ".txt",
+        ".js",
+        ".css",
+        ".json",
+        ".xml",
+        ".svg",
+        ".csv",
+        ".ico",
+    ]
+
+    if file_extension in direct_serve_extensions:
+        file_response = requests.get(file_url)
+        file_response.raise_for_status()  # Raise HTTPError for bad responses (4XX or 5XX)
+
+        mime_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"
+
+        return StreamingResponse(iter([file_response.content]), media_type=mime_type)
+
+    file_response = requests.get(file_url, stream=True)
+    file_response.raise_for_status()
+
+    return StreamingResponse(
+        file_response.iter_content(chunk_size=1024),
+        media_type="application/octet-stream",
+    )
+
+
 class JacCmd:
     """Jac CLI."""
 
@@ -116,18 +176,12 @@ class JacCmd:
         def jvfileserve(
             directory: str, host: str = "0.0.0.0", port: int = 9000
         ) -> None:
-            """Launch the file server."""
+            """Launch the file server for local files."""
             # load FastAPI
             from fastapi import FastAPI
             from fastapi.middleware.cors import CORSMiddleware
             from fastapi.staticfiles import StaticFiles
 
-            if directory:
-                os.environ["JIVAS_FILES_ROOT_PATH"] = directory
-
-            if not os.path.exists(directory):
-                os.makedirs(directory)
-
             # Setup custom routes
             app = FastAPI()
 
@@ -140,21 +194,68 @@ class JacCmd:
                 allow_headers=["*"],
             )
 
+            if not os.path.exists(directory):
+                os.makedirs(directory)
+
+            # Set the environment variable for the file root path
+            os.environ["JIVAS_FILES_ROOT_PATH"] = directory
+
+            # Mount the static files directory
             app.mount(
                 "/files",
-                StaticFiles(
-                    directory=os.environ.get("JIVAS_FILES_ROOT_PATH", ".files")
-                ),
+                StaticFiles(directory=directory),
                 name="files",
             )
 
-            app.mount(
-                "/files",
-                StaticFiles(
-                    directory=os.environ.get("JIVAS_FILES_ROOT_PATH", ".files")
-                ),
-                name="files",
+            # run the app
+            _run(app, host=host, port=port)
+
+        @cmd_registry.register
+        def jvproxyserve(
+            directory: str, host: str = "0.0.0.0", port: int = 9000
+        ) -> None:
+            """Launch the file proxy server for remote files."""
+            # load FastAPI
+            from bson import ObjectId
+            from fastapi import FastAPI, HTTPException
+            from fastapi.middleware.cors import CORSMiddleware
+
+            # Setup custom routes
+            app = FastAPI()
+
+            # Add CORS middleware
+            app.add_middleware(
+                CORSMiddleware,
+                allow_origins=["*"],
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
             )
 
+            # Add proxy routes only if using S3
+            if FILE_INTERFACE == "s3":
+
+                @app.get("/files/{file_path:path}", response_model=None)
+                async def serve_file(
+                    file_path: str,
+                ) -> Response:
+                    return serve_proxied_file(file_path)
+
+            @app.get("/f/{file_id:path}", response_model=None)
+            async def get_proxied_file(
+                file_id: str,
+            ) -> Response:
+                params = file_id.split("/")
+                object_id = params[0]
+
+                # mongo db collection
+                collection = NodeAnchor.Collection.get_collection("url_proxies")
+                file_details = collection.find_one({"_id": ObjectId(object_id)})
+
+                if file_details:
+                    return serve_proxied_file(file_details["path"])
+
+                raise HTTPException(status_code=404, detail="File not found")
+
             # run the app
             _run(app, host=host, port=port)

{jvserve-2.0.10 → jvserve-2.0.12}/jvserve/lib/file_interface.py

@@ -7,6 +7,10 @@ import logging
 import os
 from abc import ABC, abstractmethod
 
+from dotenv import load_dotenv
+
+load_dotenv(".env")
+
 # Interface type determined by environment variable, defaults to local
 FILE_INTERFACE = os.environ.get("JIVAS_FILE_INTERFACE", "local")
 DEFAULT_FILES_ROOT = os.environ.get("JIVAS_FILES_ROOT_PATH", ".files")

{jvserve-2.0.10 → jvserve-2.0.12}/jvserve.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.10
+Version: 2.0.12
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.

{jvserve-2.0.10 → jvserve-2.0.12}/tests/test_jvserve.py

@@ -118,6 +118,26 @@ class JVServeCliTest(unittest.TestCase):
             os.remove(f"{directory}/test.txt")
             os.rmdir(directory)
 
+    def test_jvproxyserve_runs(self) -> None:
+        """Ensure `jac jvproxyserve` runs successfully."""
+        try:
+            directory = "test_files"
+            server_process = subprocess.Popen(
+                ["jac", "jvproxyserve", directory, "--port", "9100"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+
+            # Wait for the proxy server to be ready
+            self.wait_for_server("http://127.0.0.1:9100/docs")
+
+            res = httpx.get("http://127.0.0.1:9100/docs")
+            self.assertEqual(res.status_code, 200)
+
+        finally:
+            server_process.kill()
+
     def tearDown(self) -> None:
         """Cleanup after each test."""
         self.stop_server()