jvserve 2.0.16__py3-none-any.whl → 2.1.1__py3-none-any.whl

jvserve/lib/file_interface.py

@@ -78,7 +78,7 @@ class LocalFileInterface(FileInterface):
         """Get URL for accessing local file via HTTP."""
         file_path = os.path.join(self.__root_dir, filename)
         if os.path.exists(file_path):
-            return f"{os.environ.get('JIVAS_FILES_URL', 'http://localhost:9000/files')}/{filename}"
+            return f"{os.environ.get('JIVAS_FILES_URL', 'http://localhost:8000/files')}/{filename}"
         return None
 
 

jvserve/lib/jac_interface.py

@@ -0,0 +1,222 @@
+"""JacInterface: A connection and context state provider for Jac Runtime."""
+
+import asyncio
+import logging
+import os
+import threading
+import time
+import traceback
+from typing import Optional, Tuple
+
+import requests
+from fastapi import Request
+from jac_cloud.core.archetype import (  # type: ignore
+    NodeAnchor,
+    WalkerArchetype,
+)
+from jac_cloud.core.context import (
+    JASECI_CONTEXT,
+    JaseciContext,
+)
+from jac_cloud.plugin.jaseci import JacPlugin
+from jaclang.runtimelib.machine import JacMachine
+
+
+class JacInterface:
+    """Thread-safe connection and context state provider for Jac Runtime with auto-authentication."""
+
+    def __init__(self, host: str = "localhost", port: int = 8000) -> None:
+        """Initialize JacInterface with host and port."""
+        self.host = host
+        self.port = port
+        self.root_id = ""
+        self.token = ""
+        self.expiration = 0.0
+        self._lock = threading.RLock()  # Thread-safe lock
+        self.logger = logging.getLogger(__name__)
+
+    def update(self, root_id: str, token: str, expiration: float) -> None:
+        """Thread-safe state update"""
+        with self._lock:
+            self.root_id = root_id
+            self.token = token
+            self.expiration = expiration
+
+    def reset(self) -> None:
+        """Thread-safe state reset"""
+        with self._lock:
+            self.root_id = ""
+            self.token = ""
+            self.expiration = 0.0
+
+    def is_valid(self) -> bool:
+        """Thread-safe validity check"""
+        with self._lock:
+            return bool(
+                self.token and self.expiration and self.expiration > time.time()
+            )
+
+    def get_state(self) -> Tuple[str, str, Optional[float]]:
+        """Get current state with auto-authentication"""
+        if not self.is_valid():
+            self._authenticate()
+        with self._lock:
+            return (self.root_id, self.token, self.expiration)
+
+    def get_context(self, request: Request | None = None) -> Optional[JaseciContext]:
+        """Get Jaseci context with proper thread safety."""
+
+        state = self.get_state()
+        if not state or not self.is_valid():
+            self.logger.error("Failed to get valid state for Jaseci context")
+            return None
+
+        try:
+            root_id = state[0]
+            entry_node = NodeAnchor.ref(f"n:root:{root_id}")  # type: ignore
+            if not entry_node:
+                self.logger.error("Failed to resolve entry node from root_id")
+                return None
+
+            ctx = JaseciContext.create(request, entry_node)
+            if not ctx:
+                self.logger.error("Failed to create JaseciContext with entry node")
+                return None
+
+            ctx.system_root = entry_node
+            ctx.root_state = entry_node
+
+            # Clean up any existing context before setting new one
+            existing_ctx = JASECI_CONTEXT.get(None)
+            if existing_ctx:
+                try:
+                    existing_ctx.close()
+                except Exception as e:
+                    self.logger.warning(f"Error while closing existing context: {e}")
+
+            JASECI_CONTEXT.set(ctx)
+            return ctx
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to create JaseciContext: {e}\n{traceback.format_exc()}"
+            )
+            return None
+
+    def spawn_walker(
+        self,
+        walker_name: str | None,
+        module_name: str,
+        attributes: dict = {},  # noqa: B006
+        request: Request | None = None,  # noqa: B006
+    ) -> Optional[WalkerArchetype]:
+        """Spawn walker with proper context handling and thread safety"""
+
+        if not all([walker_name, module_name]):
+            self.logger.error("Missing required parameters for spawning walker")
+            return None
+
+        ctx = self.get_context(request)
+        if not ctx:
+            return None
+
+        try:
+            if module_name not in JacMachine.list_modules():
+                self.logger.error(f"Module {module_name} not loaded")
+                return None
+
+            entry_node = ctx.entry_node.archetype
+
+            return JacPlugin.spawn(
+                JacMachine.spawn_walker(walker_name, attributes, module_name),
+                entry_node,
+            )
+        except Exception as e:
+            self.logger.error(f"Error spawning walker: {e}\n{traceback.format_exc()}")
+            return None
+        finally:
+            if ctx:
+                ctx.close()
+                if JASECI_CONTEXT.get(None) == ctx:
+                    JASECI_CONTEXT.set(None)
+
+    def _authenticate(self) -> None:
+        """Thread-safe authentication with retry logic and improved error handling"""
+        user = os.environ.get("JIVAS_USER")
+        password = os.environ.get("JIVAS_PASSWORD")
+        if not user or not password:
+            self.logger.error("Missing JIVAS_USER or JIVAS_PASSWORD")
+            return
+
+        login_url = f"http://{self.host}:{self.port}/user/login"
+        register_url = f"http://{self.host}:{self.port}/user/register"
+
+        with self._lock:
+            try:
+                # Try login first
+                response = requests.post(
+                    login_url, json={"email": user, "password": password}, timeout=15
+                )
+                self.logger.info(f"Login response status: {response.status_code}")
+                if response.status_code == 200:
+                    self._process_auth_response(response.json())
+                    return
+
+                # Register if login fails
+                reg_response = requests.post(
+                    register_url, json={"email": user, "password": password}, timeout=15
+                )
+                self.logger.info(
+                    f"Register response status: {reg_response.status_code}"
+                )
+                if reg_response.status_code == 201:
+                    # Retry login after registration
+                    login_response = requests.post(
+                        login_url,
+                        json={"email": user, "password": password},
+                        timeout=15,
+                    )
+                    self.logger.info(
+                        f"Retry login response status: {login_response.status_code}"
+                    )
+                    if login_response.status_code == 200:
+                        self._process_auth_response(login_response.json())
+            except requests.exceptions.RequestException as e:
+                self.logger.error(f"Network error during authentication: {e}")
+            except Exception as e:
+                self.logger.error(
+                    f"Authentication failed: {e}\n{traceback.format_exc()}"
+                )
+                self.reset()
+
+    def _process_auth_response(self, response_data: dict) -> None:
+        """Process authentication response and update state"""
+        user_data = response_data.get("user", {})
+        root_id = user_data.get("root_id", "")
+        token = response_data.get("token", "")
+        expiration = user_data.get("expiration")
+
+        if not all([root_id, token, expiration]):
+            self.logger.error("Invalid authentication response")
+            return
+
+        self.update(root_id, token, expiration)
+
+    # Async versions of methods
+    async def _authenticate_async(self) -> None:
+        """Asynchronous wrapper for authentication"""
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._authenticate)
+
+    async def spawn_walker_async(
+        self,
+        walker_name: str,
+        module_name: str,
+        attributes: dict,
+        request: Request | None = None,
+    ) -> Optional[WalkerArchetype]:
+        """Asynchronous wrapper for walker spawning"""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None, self.spawn_walker, walker_name, module_name, attributes, request
+        )

{jvserve-2.0.16.dist-info → jvserve-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.16
+Version: 2.1.1
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.
@@ -9,7 +9,8 @@ Keywords: jivas
 Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: jac-cloud==0.1.20
+Requires-Dist: jac-cloud
+Requires-Dist: jaclang==0.8.4
 Requires-Dist: pyaml>=25.1.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.10
@@ -80,7 +81,7 @@ jac jvfileserve ./static
 ### Supported Arguments
 
 - **filename**: Path to your JAC file.
-- **host**: Host address to bind the server (default: `0.0.0.0`).
+- **host**: Host address to bind the server (default: `localhost`).
 - **port**: Port number to bind the server (default: `8000`).
 - **loglevel**: Logging level (default: `INFO`).
 - **workers**: Number of worker processes (optional).

jvserve-2.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+jvserve/__init__.py,sha256=Jd0pamSDn2wGTZkNk8I9qNYTFBHp7rasdYO0_Dvad_k,245
+jvserve/cli.py,sha256=WTB_euv8R_cQ9fK_tlFHV_I6Jn-CYJrHKzjHsWSyWPY,9304
+jvserve/lib/__init__.py,sha256=cnzfSHLoTWG9Ygut2nOpDys5aPlQz-m0BSkB-nd7OMs,31
+jvserve/lib/agent_interface.py,sha256=Igv5Jb7i9Aq_7IbLDZ6jnldGKssAWKeb6iXoolX8u4k,3478
+jvserve/lib/file_interface.py,sha256=VO9RBCtJwaBxu5eZjc57-uRbsVXXZt86wVRVq9R3KXY,6079
+jvserve/lib/jac_interface.py,sha256=ydhXfYTsrhdvMXBTAd_vnAXJSSVBydQ3qavPU1-oodU,7973
+jvserve/lib/jvlogger.py,sha256=RNiB9PHuBzTvNIQWhxoDgrDlNYA0PYm1SVpvzlqu8mE,4180
+jvserve-2.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+jvserve-2.1.1.dist-info/METADATA,sha256=NaMM0u6bH8WokLVjNGeuwj35kvs6yX-L20SYooPDvBA,4814
+jvserve-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jvserve-2.1.1.dist-info/entry_points.txt,sha256=HYyg1QXoLs0JRb004L300VeLOZyDLY27ynD1tnTnEN4,35
+jvserve-2.1.1.dist-info/top_level.txt,sha256=afoCXZv-zXNBuhVIvfJGjafXKEiJl_ooy4BtgQwAG4Q,8
+jvserve-2.1.1.dist-info/RECORD,,

jvserve/lib/agent_pulse.py

@@ -1,63 +0,0 @@
-"""Agent Pulse class for scheduling and running agent jobs."""
-
-import logging
-import threading
-import time
-
-import schedule
-
-
-class AgentPulse:
-    """Agent Pulse class for scheduling and running agent jobs."""
-
-    EVENT = None
-    THREAD = None
-    LOGGER = logging.getLogger(__name__)
-
-    @staticmethod
-    def start(interval: int = 1) -> threading.Event:
-        """Starts the agent pulse in a separate thread that executes
-        pending jobs at each elapsed time interval.
-
-        This method ensures that only one thread is running at a time
-        to prevent duplication. If a thread is already running, it logs
-        a message and returns without starting a new thread.
-
-        @param interval: Time in seconds between each execution cycle of
-        scheduled jobs.
-        @return: threading.Event which can be set to stop the running
-        thread.
-
-        Note: It is intended behavior that run_continuously() does not
-        run missed jobs. For instance, a job scheduled to run every
-        minute with a run interval of one hour will only run once per
-        hour, not 60 times at once.
-        """
-
-        if AgentPulse.THREAD and AgentPulse.THREAD.is_alive():
-            AgentPulse.LOGGER.info("agent pulse is already running.")
-            return AgentPulse.EVENT
-
-        AgentPulse.EVENT = threading.Event()
-
-        class ScheduleThread(threading.Thread):
-            def run(self) -> None:
-                while AgentPulse.EVENT and not AgentPulse.EVENT.is_set():
-                    schedule.run_pending()
-                    time.sleep(interval)
-
-        AgentPulse.THREAD = ScheduleThread()
-        AgentPulse.THREAD.start()
-
-        AgentPulse.LOGGER.info("agent pulse started.")
-
-        return AgentPulse.EVENT
-
-    @staticmethod
-    def stop() -> None:
-        """Stops the agent pulse."""
-        if AgentPulse.EVENT and not AgentPulse.EVENT.is_set():
-            AgentPulse.LOGGER.info("agent pulse stopped.")
-            AgentPulse.EVENT.set()
-            if AgentPulse.THREAD:
-                AgentPulse.THREAD.join()

jvserve-2.0.16.dist-info/RECORD

@@ -1,13 +0,0 @@
-jvserve/__init__.py,sha256=pq6aKUL15KaEDAIo2zlj2RtTFVdN-vXUx3UVdOZxOeM,191
-jvserve/cli.py,sha256=NJD4ehtKnhOvsz-vrFh9lz3P4bnxqz-uqTr8QItljZc,8897
-jvserve/lib/__init__.py,sha256=cnzfSHLoTWG9Ygut2nOpDys5aPlQz-m0BSkB-nd7OMs,31
-jvserve/lib/agent_interface.py,sha256=-uewEL_M4cZpZVl0rIOXnVpZI-3O9aGKLljoCgKSW0M,34955
-jvserve/lib/agent_pulse.py,sha256=6hBF6KQYr6Z9Mi_yoWKGfdnW7gg84kK20Slu-bLR_m8,2067
-jvserve/lib/file_interface.py,sha256=sqwTmBnZsVFQUGt7mE1EWA-jHnZlRtBAFeb4Rb_QgQ8,6079
-jvserve/lib/jvlogger.py,sha256=RNiB9PHuBzTvNIQWhxoDgrDlNYA0PYm1SVpvzlqu8mE,4180
-jvserve-2.0.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-jvserve-2.0.16.dist-info/METADATA,sha256=kRy2uTRK7zZBau0hAOt5BunMHO0m2OHHQPUzY9BGUOY,4791
-jvserve-2.0.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jvserve-2.0.16.dist-info/entry_points.txt,sha256=HYyg1QXoLs0JRb004L300VeLOZyDLY27ynD1tnTnEN4,35
-jvserve-2.0.16.dist-info/top_level.txt,sha256=afoCXZv-zXNBuhVIvfJGjafXKEiJl_ooy4BtgQwAG4Q,8
-jvserve-2.0.16.dist-info/RECORD,,