jvcli 2.0.9__py3-none-any.whl → 2.0.11__py3-none-any.whl

jvcli/__init__.py

@@ -4,5 +4,5 @@ jvcli package initialization.
 This package provides the CLI tool for Jivas Package Repository.
 """
 
-__version__ = "2.0.9"
+__version__ = "2.0.11"
 __supported__jivas__versions__ = ["2.0.0"]

jvcli/api.py

@@ -62,7 +62,7 @@ class RegistryAPI:
         token: Optional[str] = None,
         api_key: Optional[str] = None,
     ) -> dict:
-        """Get action info.yaml content as json"""
+        """Get package info.yaml content as json"""
         endpoint = "info"
 
         try:
@@ -83,12 +83,12 @@ class RegistryAPI:
                 return response.json()
             else:
                 click.secho(
-                    f"Error retrieving action: {response.json()['error']}",
+                    f"Error retrieving package: {response.json()['error']}",
                     fg="red",
                 )
                 return {}
         except Exception as e:
-            click.secho(f"Error retrieving action: {e}", fg="red")
+            click.secho(f"Error retrieving package: {e}", fg="red")
             return {}
 
     @staticmethod
@@ -133,42 +133,6 @@ class RegistryAPI:
             click.secho(f"Error downloading package: {e}", fg="red")
             return {}
 
-    @staticmethod
-    def get_action_info(
-        name: str,
-        version: str = "",
-        token: Optional[str] = None,
-        api_key: Optional[str] = None,
-    ) -> dict:
-        """Get action info.yaml content as json"""
-        endpoint = "info"
-
-        try:
-            headers = {"Authorization": f"Bearer {token}"} if token else {}
-
-            if api_key:
-                headers["x-api-key"] = api_key
-
-            data = {
-                "name": name,
-                "version": "" if version == "latest" else version,
-            }
-            response = requests.get(
-                RegistryAPI.url + endpoint, params=data, headers=headers
-            )
-            # Check if the response is successful
-            if response.status_code == 200:
-                return response.json()
-            else:
-                click.secho(
-                    f"Error retrieving action: {response.json()['error']}",
-                    fg="red",
-                )
-                return {}
-        except Exception as e:
-            click.secho(f"Error retrieving action: {e}", fg="red")
-            return {}
-
     @staticmethod
     def create_namespace(name: str, token: str) -> dict:
         """Create a namespace."""

jvcli/client/lib/widgets.py

@@ -181,7 +181,7 @@ def dynamic_form(
                 {"id": 0, "fields": {field["name"]: "" for field in field_definitions}}
             ]
 
-    def add_row() -> None:
+    def add_row() -> None:  # pragma: no cover, don't know how to test this yet 😅
         """Add a new row to the dynamic form."""
         new_id = (
             max((item["id"] for item in st.session_state[session_key]), default=-1) + 1
@@ -192,7 +192,9 @@ def dynamic_form(
         }
         st.session_state[session_key].append(new_row)
 
-    def remove_row(id_to_remove: int) -> None:
+    def remove_row(
+        id_to_remove: int,
+    ) -> None:  # pragma: no cover, don't know how to test this yet 😅
         """Remove a row from the dynamic form."""
         st.session_state[session_key] = [
             item for item in st.session_state[session_key] if item["id"] != id_to_remove

jvcli/commands/auth.py

@@ -26,14 +26,14 @@ def signup(username: str, email: str, password: str) -> None:
 
 @click.command()
 @click.option(
-    "--login",
+    "--username",
     help="Your email address or username.",
     prompt="Login (username or email)",
 )
 @click.option("--password", prompt=True, hide_input=True, help="Your password.")
-def login(login: str, password: str) -> None:
+def login(username: str, password: str) -> None:
     """Log in to your Jivas Package Repository account."""
-    data = RegistryAPI.login(login, password)
+    data = RegistryAPI.login(username, password)
     if data and "token" in data and "namespaces" in data and "email" in data:
         save_token(data["token"], data["namespaces"], data["email"])
         click.secho("Login successful! Token saved.", fg="green", bold=True)

jvcli/commands/studio.py

@@ -2,39 +2,44 @@
 
 import json
 from pathlib import Path
+from typing import Annotated
 
 import click
 import jaclang  # noqa: F401
 from bson import ObjectId
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.staticfiles import StaticFiles
 from jac_cloud.core.architype import NodeAnchor
+from jac_cloud.jaseci.security import decrypt
 from uvicorn import run
 
 
-@click.group()
-def studio() -> None:
-    """Group for managing Jivas Studio resources."""
-    pass  # pragma: no cover
+def get_nodes_and_edges(
+    nid: str,
+    current_depth: int,
+    depth: int,
+    nodes: list,
+    edges: list,
+    node_collection: NodeAnchor.Collection,
+    edge_collection: NodeAnchor.Collection,
+) -> None:
+    """Get nodes and edges recursively."""
+    if current_depth >= depth:
+        return
 
+    outgoing_edges = edge_collection.find(
+        {
+            "$or": [
+                {"source": nid},
+                {"source": {"$regex": f"{nid}$"}},
+            ]
+        }
+    )
 
-def get_graph(root: str) -> dict:
-    """Fetches a graph structure from the database."""
-    nodes = []
-    edges = []
-
-    edge_collection = NodeAnchor.Collection.get_collection("edge")
-    node_collection = NodeAnchor.Collection.get_collection("node")
-    node_docs = node_collection.find({"root": ObjectId(root)})
-    edge_docs = edge_collection.find({"root": ObjectId(root)})
-
-    for node in node_docs:
-        nodes.append(
-            {
-                "id": node["_id"],
-                "data": node["architype"],
-                "name": node["name"],
-            }
-        )
-    for edge in edge_docs:
+    for edge in outgoing_edges:
         edges.append(
             {
                 "id": edge["_id"],
@@ -45,40 +50,181 @@ def get_graph(root: str) -> dict:
             }
         )
 
-    return {
-        "nodes": json.loads(json.dumps(nodes, default=str)),
-        "edges": json.loads(json.dumps(edges, default=str)),
-    }
+        node_id = edge["target"].split(":")[-1]
+        connected_nodes = node_collection.find({"_id": ObjectId(node_id)})
 
+        for node in connected_nodes:
+            nodes.append(
+                {
+                    "id": node["_id"],
+                    "data": node["architype"],
+                    "name": node["name"],
+                }
+            )
 
-def get_users() -> list:
-    """Fetches users from the database."""
-    users = []
-    user_collection = NodeAnchor.Collection.get_collection("user")
-    user_docs = user_collection.find()
+            get_nodes_and_edges(
+                node["_id"],
+                current_depth + 1,
+                depth,
+                nodes,
+                edges,
+                node_collection,
+                edge_collection,
+            )
 
-    for user in user_docs:
-        users.append(
-            {
-                "id": user["_id"],
-                "root_id": user["root_id"],
-                "email": user["email"],
-            }
-        )
 
-    return json.loads(json.dumps(users, default=str))
+# need this because endpoint annotation differs depending on require auth flag
+class EndpointFactory:
+    """Factory for creating endpoints based on require_auth flag."""
+
+    @staticmethod
+    def create_endpoints(require_auth: bool, security: HTTPBearer | None) -> tuple:
+        """Create endpoints based on require_auth flag."""
+
+        def validate_auth(credentials: HTTPAuthorizationCredentials) -> None:
+            """Validate authentication token."""
+            token = credentials.credentials
+            if not token or not decrypt(token):
+                raise HTTPException(status_code=401, detail="Invalid token")
+
+        def get_graph_data(root: str) -> dict:
+            """Get graph nodes and edges data."""
+            edge_collection = NodeAnchor.Collection.get_collection("edge")
+            node_collection = NodeAnchor.Collection.get_collection("node")
+
+            nodes = [
+                {
+                    "id": node["_id"],
+                    "data": node["architype"],
+                    "name": node["name"],
+                }
+                for node in node_collection.find({"root": ObjectId(root)})
+            ]
+
+            edges = [
+                {
+                    "id": edge["_id"],
+                    "name": edge["name"],
+                    "source": edge["source"],
+                    "target": edge["target"],
+                    "data": edge["architype"],
+                }
+                for edge in edge_collection.find({"root": ObjectId(root)})
+            ]
+
+            return {"nodes": nodes, "edges": edges}
+
+        def get_users_data() -> list:
+            """Get users data."""
+            user_collection = NodeAnchor.Collection.get_collection("user")
+            return [
+                {
+                    "id": user["_id"],
+                    "root_id": user["root_id"],
+                    "email": user["email"],
+                }
+                for user in user_collection.find()
+            ]
+
+        def get_node_connections(node_id: str, depth: int) -> dict:
+            nid = node_id.split(":")[-1]
+            current_depth = 0
+            nodes: list = []
+            edges: list = []
+
+            edge_collection = NodeAnchor.Collection.get_collection("edge")
+            node_collection = NodeAnchor.Collection.get_collection("node")
+
+            get_nodes_and_edges(
+                nid,
+                current_depth,
+                depth,
+                nodes,
+                edges,
+                node_collection,
+                edge_collection,
+            )
+
+            return {"nodes": nodes, "edges": edges}
+
+        if not require_auth:
+
+            async def graph_endpoint(root: str) -> JSONResponse:
+                return JSONResponse(
+                    content=json.loads(json.dumps(get_graph_data(root), default=str))
+                )
+
+            async def users_endpoint() -> JSONResponse:
+                return JSONResponse(
+                    content=json.loads(json.dumps(get_users_data(), default=str))
+                )
+
+            async def node_endpoint(node_id: str, depth: int) -> JSONResponse:
+                return JSONResponse(
+                    content=json.loads(
+                        json.dumps(get_node_connections(node_id, depth), default=str)
+                    )
+                )
+
+            return graph_endpoint, users_endpoint, node_endpoint
+
+        else:
+
+            async def guarded_graph_endpoint(
+                root: str,
+                credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
+            ) -> JSONResponse:
+                validate_auth(credentials)
+                return JSONResponse(
+                    content=json.loads(json.dumps(get_graph_data(root), default=str))
+                )
+
+            async def guarded_users_endpoint(
+                credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
+            ) -> JSONResponse:
+                validate_auth(credentials)
+                return JSONResponse(
+                    content=json.loads(json.dumps(get_users_data(), default=str))
+                )
+
+            async def guarded_node_endpoint(
+                node_id: str,
+                depth: int,
+                credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
+            ) -> JSONResponse:
+                validate_auth(credentials)
+                return JSONResponse(
+                    content=json.loads(
+                        json.dumps(get_node_connections(node_id, depth), default=str)
+                    )
+                )
+
+            return guarded_graph_endpoint, guarded_users_endpoint, guarded_node_endpoint
+
+
+@click.group()
+def studio() -> None:
+    """Group for managing Jivas Studio resources."""
+    pass  # pragma: no cover
 
 
 @studio.command()
 @click.option("--port", default=8989, help="Port for the studio to launch on.")
-def launch(port: int) -> None:
+@click.option(
+    "--require-auth", default=False, help="Require authentication for studio api."
+)
+def launch(port: int, require_auth: bool) -> None:
     """Launch the Jivas Studio on the specified port."""
     click.echo(f"Launching Jivas Studio on port {port}...")
-    from fastapi import FastAPI
-    from fastapi.middleware.cors import CORSMiddleware
-    from fastapi.staticfiles import StaticFiles
 
-    app = FastAPI()
+    security = HTTPBearer() if require_auth else None
+
+    get_graph, get_users, get_node = EndpointFactory.create_endpoints(
+        require_auth, security
+    )
+
+    app = FastAPI(title="Jivas Studio API")
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],
@@ -89,8 +235,24 @@ def launch(port: int) -> None:
 
     app.add_api_route("/graph", endpoint=get_graph, methods=["GET"])
     app.add_api_route("/users", endpoint=get_users, methods=["GET"])
+    app.add_api_route("/graph/node", endpoint=get_node, methods=["GET"])
+
+    client_dir = (
+        Path(__file__)
+        .resolve()
+        .parent.parent.joinpath("studio-auth" if require_auth else "studio")
+    )
 
-    client_dir = Path(__file__).resolve().parent.parent.joinpath("studio")
-    app.mount("/", StaticFiles(directory=client_dir, html=True), name="studio")
+    app.mount(
+        "/",
+        StaticFiles(directory=client_dir, html=True),
+        name="studio",
+    )
+
+    app.mount(
+        "/graph",
+        StaticFiles(directory=client_dir, html=True),
+        name="studio_graph",
+    )
 
     run(app, host="0.0.0.0", port=port)