fastapi-voyager 0.4.5__tar.gz → 0.5.2__tar.gz

fastapi_voyager-0.5.2/.python-version

@@ -0,0 +1 @@
+3.12

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-voyager
-Version: 0.4.5
+Version: 0.5.2
 Summary: Visualize FastAPI application's routing tree and dependencies
 Project-URL: Homepage, https://github.com/allmonday/fastapi-voyager
 Project-URL: Source, https://github.com/allmonday/fastapi-voyager
@@ -162,11 +162,14 @@ features
 - [x] alt+click to show field details
 - [x] display source code of routes (including response_model)
 - [x] handle excluded field 
-- [ ] group routes by module hierarchy
+- [ ] add tooltips
+- [ ] route
+    - [ ] group routes by module hierarchy
+    - [ ] add response_model in route
 - [ ] support dataclass
+- [ ] click field to highlight links
 - [ ] user can generate nodes/edges manually and connect to generated ones
-- [ ] refactor
-    - [ ] abstract render module
+    - [ ] add owner
 - [ ] ui optimization
     - [ ] fixed left/right bar show field information
 - [ ] display standard ER diagram
@@ -176,6 +179,10 @@ features
     - [x] strikethrough for excluded fields
     - [ ] display loader as edges
 - [ ] add tests
+- [ ] refactor
+    - [ ] abstract render module
+- [ ] export voyager core data into json (for better debugging)
+    - [ ] add api to rebuild core data from json, and render it
 
 bugs:
 - [ ] fix duplicated link from class and parent class, it also break clicking highlight

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/README.md

@@ -135,11 +135,14 @@ features
 - [x] alt+click to show field details
 - [x] display source code of routes (including response_model)
 - [x] handle excluded field 
-- [ ] group routes by module hierarchy
+- [ ] add tooltips
+- [ ] route
+    - [ ] group routes by module hierarchy
+    - [ ] add response_model in route
 - [ ] support dataclass
+- [ ] click field to highlight links
 - [ ] user can generate nodes/edges manually and connect to generated ones
-- [ ] refactor
-    - [ ] abstract render module
+    - [ ] add owner
 - [ ] ui optimization
     - [ ] fixed left/right bar show field information
 - [ ] display standard ER diagram
@@ -149,6 +152,10 @@ features
     - [x] strikethrough for excluded fields
     - [ ] display loader as edges
 - [ ] add tests
+- [ ] refactor
+    - [ ] abstract render module
+- [ ] export voyager core data into json (for better debugging)
+    - [ ] add api to rebuild core data from json, and render it
 
 bugs:
 - [ ] fix duplicated link from class and parent class, it also break clicking highlight

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/cli.py

@@ -7,7 +7,7 @@ import os
 from typing import Optional
 
 from fastapi import FastAPI
-from fastapi_voyager.graph import Analytics
+from fastapi_voyager.voyager import Voyager
 from fastapi_voyager.version import __version__
 from fastapi_voyager import server as viz_server
 
@@ -49,7 +49,7 @@ def load_fastapi_app_from_file(module_path: str, app_name: str = "app") -> Optio
 def load_fastapi_app_from_module(module_name: str, app_name: str = "app") -> Optional[FastAPI]:
     """Load FastAPI app from a Python module name."""
     try:
-        # 临时将当前工作目录添加到 Python 路径中
+        # Temporarily add the current working directory to sys.path
         current_dir = os.getcwd()
         if current_dir not in sys.path:
             sys.path.insert(0, current_dir)
@@ -73,7 +73,7 @@ def load_fastapi_app_from_module(module_name: str, app_name: str = "app") -> Opt
                 print(f"Error: No attribute '{app_name}' found in module '{module_name}'")
                 return None
         finally:
-            # 清理：如果我们添加了路径，则移除它
+            # Cleanup: if we added the path, remove it
             if path_added and current_dir in sys.path:
                 sys.path.remove(current_dir)
             
@@ -95,7 +95,7 @@ def generate_visualization(
 ):
 
     """Generate DOT file for FastAPI router visualization."""
-    analytics = Analytics(
+    analytics = Voyager(
         include_tags=tags,
         schema=schema,
         show_fields=show_fields,
@@ -105,7 +105,7 @@ def generate_visualization(
 
     analytics.analysis(app)
 
-    dot_content = analytics.generate_dot()
+    dot_content = analytics.render_dot()
     
     # Optionally write to file
     with open(output_file, 'w', encoding='utf-8') as f:

fastapi_voyager-0.5.2/src/fastapi_voyager/render.py

@@ -0,0 +1,163 @@
+from fastapi_voyager.type import SchemaNode, ModuleNode, Link, Tag, Route, FieldType, PK
+from fastapi_voyager.module import build_module_tree
+
+
+class Renderer:
+    def __init__(
+        self,
+        *,
+        show_fields: FieldType = 'single',
+        module_color: dict[str, str] | None = None,
+        schema: str | None = None,
+    ) -> None:
+        self.show_fields = show_fields if show_fields in ('single', 'object', 'all') else 'single'
+        self.module_color = module_color or {}
+        self.schema = schema
+
+    def render_schema_label(self, node: SchemaNode) -> str:
+        has_base_fields = any(f.from_base for f in node.fields)
+        fields = [n for n in node.fields if n.from_base is False]
+
+        if self.show_fields == 'all':
+            _fields = fields
+        elif self.show_fields == 'object':
+            _fields = [f for f in fields if f.is_object is True]
+        else:  # 'single'
+            _fields = []
+
+        fields_parts: list[str] = []
+        if self.show_fields == 'all' and has_base_fields:
+            fields_parts.append('<tr><td align="left" cellpadding="8"><font color="#999">  Inherited Fields ... </font></td></tr>')
+
+        for field in _fields:
+            type_name = field.type_name[:25] + '..' if len(field.type_name) > 25 else field.type_name
+            display_xml = f'<s align="left">{field.name}: {type_name}</s>' if field.is_exclude else f'{field.name}: {type_name}'
+            field_str = f"""<tr><td align="left" port="f{field.name}" cellpadding="8"><font>  {display_xml}    </font></td></tr>"""
+            fields_parts.append(field_str)
+
+        header_color = 'tomato' if node.id == self.schema else '#009485'
+        header = f"""<tr><td cellpadding="1.5" bgcolor="{header_color}" align="center" colspan="1" port="{PK}"> <font color="white">    {node.name}    </font> </td> </tr>"""
+        field_content = ''.join(fields_parts) if fields_parts else ''
+        return f"""<<table border="1" cellborder="0" cellpadding="0" bgcolor="white"> {header} {field_content}   </table>>"""
+
+    def _handle_schema_anchor(self, source: str) -> str:
+        if '::' in source:
+            a, b = source.split('::', 1)
+            return f'"{a}":{b}'
+        return f'"{source}"'
+
+    def render_link(self, link: Link) -> str:
+        h = self._handle_schema_anchor
+        if link.type == 'tag_route':
+            return f"""{h(link.source)}:e -> {h(link.target)}:w [style = "solid", minlen=3];"""
+        elif link.type == 'route_to_schema':
+            return f"""{h(link.source)}:e -> {h(link.target)}:{PK} [style = "solid", dir="back", arrowtail="odot", minlen=3];"""
+        elif link.type == 'schema':
+            return f"""{h(link.source)}:e -> {h(link.target)}:w [style = "solid", label = "", dir="back", minlen=3, arrowtail="odot"];"""
+        elif link.type == 'parent':
+            return f"""{h(link.source)}:e -> {h(link.target)}:w [style = "solid, dashed", dir="back", minlen=3, taillabel = "< inherit >", color = "purple", tailport="n"];"""
+        elif link.type == 'subset':
+            return f"""{h(link.source)}:e -> {h(link.target)}:w [style = "solid, dashed", dir="back", minlen=3, taillabel = "< subset >", color = "orange", tailport="n"];"""
+        else:
+            raise ValueError(f'Unknown link type: {link.type}')
+
+    def render_module(self, mod: ModuleNode) -> str:
+        color = self.module_color.get(mod.fullname)
+        inner_nodes = [
+            f'''
+                "{node.id}" [
+                    label = {self.render_schema_label(node)}
+                    shape = "plain"
+                    margin="0.5,0.1"
+                ];''' for node in mod.schema_nodes
+        ]
+        inner_nodes_str = '\n'.join(inner_nodes)
+        child_str = '\n'.join(self.render_module(m) for m in mod.modules)
+        return f'''
+            subgraph cluster_module_{mod.fullname.replace('.', '_')} {{
+                tooltip="{mod.fullname}"
+                color = "#666"
+                style="rounded"
+                label = "  {mod.name}"
+                labeljust = "l"
+                {(f'pencolor = "{color}"' if color else 'pencolor="#ccc"')}
+                {(f'penwidth = 3' if color else 'penwidth=""')}
+                {inner_nodes_str}
+                {child_str}
+            }}'''
+
+    def render_dot(self, tags: list[Tag], routes: list[Route], nodes: list[SchemaNode], links: list[Link]) -> str:
+        modules = build_module_tree(nodes)
+
+        tag_str = '\n'.join([
+            f'''
+            "{t.id}" [
+                label = "    {t.name}    "
+                shape = "record"
+                margin="0.5,0.1"
+            ];''' for t in tags
+        ])
+
+        route_str = '\n'.join([
+            f'''
+            "{r.id}" [
+                label = "    {r.name}    "
+                margin="0.5,0.1"
+                shape = "record"
+            ];''' for r in routes
+        ])
+
+        modules_str = '\n'.join(self.render_module(m) for m in modules)
+        link_str = '\n'.join(self.render_link(link) for link in links)
+
+        dot_str = f'''
+        digraph world {{
+            pad="0.5"
+            nodesep=0.8
+            fontname="Helvetica,Arial,sans-serif"
+            node [fontname="Helvetica,Arial,sans-serif"]
+            edge [
+                fontname="Helvetica,Arial,sans-serif"
+                color="gray"
+            ]
+            graph [
+                rankdir = "LR"
+            ];
+            node [
+                fontsize = "16"
+            ];
+
+            subgraph cluster_tags {{ 
+                color = "#aaa"
+                margin=18
+                style="dashed"
+                label = "  Tags"
+                labeljust = "l"
+                fontsize = "20"
+                {tag_str}
+            }}
+
+            subgraph cluster_router {{
+                color = "#aaa"
+                margin=18
+                style="dashed"
+                label = "  Routes"
+                labeljust = "l"
+                fontsize = "20"
+                {route_str}
+            }}
+
+            subgraph cluster_schema {{
+                color = "#aaa"
+                margin=18
+                style="dashed"
+                label="  Schema"
+                labeljust="l"
+                fontsize="20"
+                    {modules_str}
+            }}
+
+            {link_str}
+            }}
+        '''
+        return dot_str

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/server.py

@@ -1,12 +1,13 @@
 from pathlib import Path
-from typing import Optional, Dict
+from typing import Optional
 from fastapi import FastAPI
 from starlette.middleware.gzip import GZipMiddleware
 from pydantic import BaseModel
-from fastapi.responses import HTMLResponse, PlainTextResponse
+from fastapi.responses import HTMLResponse, PlainTextResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
-from fastapi_voyager.graph import Analytics
-from fastapi_voyager.type import Tag, FieldInfo
+from fastapi_voyager.voyager import Voyager
+from fastapi_voyager.type import Tag, FieldInfo, CoreData
+from fastapi_voyager.render import Renderer
 
 
 WEB_DIR = Path(__file__).parent / "web"
@@ -50,12 +51,12 @@ def create_app_with_fastapi(
 
 	@app.get("/dot", response_model=OptionParam)
 	def get_dot() -> str:
-		analytics = Analytics(module_color=module_color, load_meta=True)
-		analytics.analysis(target_app)
-		dot = analytics.generate_dot()
+		voyager = Voyager(module_color=module_color, load_meta=True)
+		voyager.analysis(target_app)
+		dot = voyager.render_dot()
 
 		# include tags and their routes
-		tags = analytics.tags
+		tags = voyager.tags
 
 		schemas = [
 			SchemaType(
@@ -64,7 +65,7 @@ def create_app_with_fastapi(
 				fields=s.fields,
 				source_code=s.source_code,
 				vscode_link=s.vscode_link
-			) for s in analytics.nodes
+			) for s in voyager.nodes
 		]
 		schemas.sort(key=lambda s: s.name)
 
@@ -72,7 +73,7 @@ def create_app_with_fastapi(
 
 	@app.post("/dot", response_class=PlainTextResponse)
 	def get_filtered_dot(payload: Payload) -> str:
-		analytics = Analytics(
+		voyager = Voyager(
 			include_tags=payload.tags,
 			schema=payload.schema_name,
 			schema_field=payload.schema_field,
@@ -81,8 +82,27 @@ def create_app_with_fastapi(
 			route_name=payload.route_name,
 			load_meta=False,
 		)
-		analytics.analysis(target_app)
-		return analytics.generate_dot()
+		voyager.analysis(target_app)
+		return voyager.render_dot()
+
+	@app.post("/dot-core-data", response_model=CoreData)
+	def get_filtered_dot_core_data(payload: Payload) -> str:
+		voyager = Voyager(
+			include_tags=payload.tags,
+			schema=payload.schema_name,
+			schema_field=payload.schema_field,
+			show_fields=payload.show_fields,
+			module_color=module_color,
+			route_name=payload.route_name,
+			load_meta=False,
+		)
+		voyager.analysis(target_app)
+		return voyager.dump_core_data()
+	
+	@app.post('/dot-render-core-data', response_class=PlainTextResponse)
+	def render_dot_from_core_data(core_data: CoreData) -> str:
+		renderer = Renderer(show_fields=core_data.show_fields, module_color=core_data.module_color, schema=core_data.schema)
+		return renderer.render_dot(core_data.tags, core_data.routes, core_data.nodes, core_data.links)
 
 	@app.get("/", response_class=HTMLResponse)
 	def index():

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/type.py

@@ -1,5 +1,6 @@
-from dataclasses import dataclass, field
-from typing import Literal
+from dataclasses import field
+from pydantic.dataclasses import dataclass
+from typing import Literal, Optional
 
 @dataclass
 class NodeBase:
@@ -39,11 +40,12 @@ class ModuleNode:
 
 
 # type: 
-#    - entry: tag -> route, route -> response model
+#    - tag_route: tag -> route
+#    - route_to_schema: route -> response model
 #    - subset: schema -> schema (subset)
 #    - parent: schema -> schema (inheritance)
-#    - internal: schema -> schema (field reference)
-LinkType = Literal['internal', 'parent', 'entry', 'subset']
+#    - schema: schema -> schema (field reference)
+LinkType = Literal['schema', 'parent', 'tag_route', 'subset', 'route_to_schema']
 
 @dataclass
 class Link:
@@ -55,3 +57,16 @@ class Link:
     source_origin: str
     target_origin: str
     type: LinkType
+
+FieldType = Literal['single', 'object', 'all']
+PK = "PK"
+
+@dataclass
+class CoreData:
+    tags: list[Tag]
+    routes: list[Route]
+    nodes: list[SchemaNode]
+    links: list[Link]
+    show_fields: FieldType
+    module_color: Optional[dict[str, str]] = None
+    schema: Optional[str] = None

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.4.5"
+__version__ = "0.5.2"

fastapi_voyager-0.4.5/src/fastapi_voyager/graph.py → fastapi_voyager-0.5.2/src/fastapi_voyager/voyager.py

@@ -1,5 +1,4 @@
 import inspect
-from typing import Literal
 from fastapi import FastAPI, routing
 from fastapi_voyager.type_helper import (
     get_core_types,
@@ -12,20 +11,18 @@ from fastapi_voyager.type_helper import (
     update_forward_refs
 )
 from pydantic import BaseModel
-from fastapi_voyager.type import Route, SchemaNode, Link, Tag, ModuleNode, LinkType
-from fastapi_voyager.module import build_module_tree
+from fastapi_voyager.type import Route, SchemaNode, Link, Tag, LinkType, FieldType, PK, CoreData
 from fastapi_voyager.filter import filter_graph
+from fastapi_voyager.render import Renderer
+import pydantic_resolve.constant as const
 
-# support pydantic-resolve's ensure_subset
-ENSURE_SUBSET_REFERENCE = '__pydantic_resolve_ensure_subset_reference__'
-PK = "PK"
 
-class Analytics:
+class Voyager:
     def __init__(
             self, 
             schema: str | None = None, 
             schema_field: str | None = None,
-            show_fields: Literal['single', 'object', 'all'] = 'single',
+            show_fields: FieldType = 'single',
             include_tags: list[str] | None = None,
             module_color: dict[str, str] | None = None,
             route_name: str | None = None,
@@ -94,8 +91,8 @@ class Analytics:
             route_obj = Route(
                 id=route_id,
                 name=route_name,
-                vscode_link=get_vscode_link(route.endpoint) if self.load_meta else None,
-                source_code=inspect.getsource(route.endpoint) if self.load_meta else None
+                vscode_link=get_vscode_link(route.endpoint) if self.load_meta else '',
+                source_code=inspect.getsource(route.endpoint) if self.load_meta else ''
             )
 
             self.routes.append(route_obj)
@@ -106,7 +103,7 @@ class Analytics:
                 source_origin=tag_id,
                 target=route_id,
                 target_origin=route_id,
-                type='entry'
+                type='tag_route'
             ))
 
             # add response_models and create links from route -> response_model
@@ -118,7 +115,7 @@ class Analytics:
                         source_origin=route_id,
                         target=self.generate_node_head(target_name),
                         target_origin=target_name,
-                        type='entry'
+                        type='route_to_schema'
                     ))
 
                     schemas.append(schema)
@@ -143,8 +140,8 @@ class Analytics:
                 id=full_name, 
                 module=schema.__module__,
                 name=schema.__name__,
-                source_code=get_source(schema) if self.load_meta else None,
-                vscode_link=get_vscode_link(schema) if self.load_meta else None,
+                source_code=get_source(schema) if self.load_meta else '',
+                vscode_link=get_vscode_link(schema) if self.load_meta else '',
                 fields=get_pydantic_fields(schema, bases_fields)
             )
         return full_name
@@ -185,8 +182,10 @@ class Analytics:
         update_forward_refs(schema)
         self.add_to_node_set(schema)
 
+        base_fields = set()
+
         # handle schema inside ensure_subset(schema)
-        if subset_reference := getattr(schema, ENSURE_SUBSET_REFERENCE, None):
+        if subset_reference := getattr(schema,  const.ENSURE_SUBSET_REFERENCE, None):
             if is_inheritance_of_pydantic_base(subset_reference):
 
                 self.add_to_node_set(subset_reference)
@@ -201,6 +200,12 @@ class Analytics:
         # handle bases
         for base_class in schema.__bases__:
             if is_inheritance_of_pydantic_base(base_class):
+                # collect base class field names to avoid duplicating inherited fields
+                try:
+                    base_fields.update(getattr(base_class, 'model_fields', {}).keys())
+                except Exception:
+                    # be defensive in case of unconventional BaseModel subclasses
+                    pass
                 self.add_to_node_set(base_class)
                 self.add_to_link_set(
                     source=self.generate_node_head(full_class_name(schema)),
@@ -212,6 +217,9 @@ class Analytics:
 
         # handle fields
         for k, v in schema.model_fields.items():
+            # skip fields inherited from base classes
+            if k in base_fields:
+                continue
             annos = get_core_types(v.annotation)
             for anno in annos:
                 if anno and is_inheritance_of_pydantic_base(anno):
@@ -223,98 +231,34 @@ class Analytics:
                         source_origin=full_class_name(schema),
                         target=self.generate_node_head(full_class_name(anno)),
                         target_origin=full_class_name(anno),
-                        type='internal'):
+                        type='schema'):
                         self.analysis_schemas(anno)
 
 
     def generate_node_head(self, link_name: str):
         return f'{link_name}::{PK}'
 
+    def dump_core_data(self):
+        _tags, _routes, _nodes, _links = filter_graph(
+            schema=self.schema,
+            schema_field=self.schema_field,
+            tags=self.tags,
+            routes=self.routes,
+            nodes=self.nodes,
+            links=self.links,
+            node_set=self.node_set,
+        )
+        return CoreData(
+            tags=_tags,
+            routes=_routes,
+            nodes=_nodes,
+            links=_links,
+            show_fields=self.show_fields,
+            module_color=self.module_color,
+            schema=self.schema
+        )
 
-    def generate_node_label(self, node: SchemaNode):
-        has_base_fields = any(f.from_base for f in node.fields)
-
-        fields = [n for n in node.fields if n.from_base is False]
-
-        name = node.name
-        fields_parts: list[str] = []
-
-        if self.show_fields == 'all':
-            _fields = fields
-            if has_base_fields:
-                fields_parts.append('<tr><td align="left" cellpadding="8"><font color="#999">  Inherited Fields ... </font></td></tr>')
-        elif self.show_fields == 'object':
-            _fields = [f for f in fields if f.is_object is True]
-            
-        else:  # 'single'
-            _fields = []
-
-        for field in _fields:
-            type_name = field.type_name[:25] + '..' if len(field.type_name) > 25 else field.type_name
-            display_xml = f'<s align="left">{field.name}: {type_name}</s>' if field.is_exclude else f'{field.name}: {type_name}'
-            field_str = f"""<tr><td align="left" port="f{field.name}" cellpadding="8"><font>  {display_xml}    </font></td></tr>""" 
-            fields_parts.append(field_str)
-        
-        header_color = 'tomato' if node.id == self.schema else '#009485'
-        header = f"""<tr><td cellpadding="1.5" bgcolor="{header_color}" align="center" colspan="1" port="{PK}"> <font color="white">    {name}    </font> </td> </tr>"""
-        field_content = ''.join(fields_parts) if fields_parts else ''
-
-        return f"""<<table border="1" cellborder="0" cellpadding="0" bgcolor="white"> {header} {field_content}   </table>>"""
-
-    def generate_dot(self):
-
-        def generate_link(link: Link):
-            if link.type == 'internal':
-                return f'''{handle_entry(link.source)}:e -> {handle_entry(link.target)}:w [ {get_link_attributes(link)} ];'''
-            else:
-                return f'''{handle_entry(link.source)} -> {handle_entry(link.target)} [ {get_link_attributes(link)} ];'''
-
-
-        def get_link_attributes(link: Link):
-            if link.type == 'parent':
-                return 'style = "solid, dashed", dir="back", minlen=3, taillabel = "< inherit >", color = "purple", tailport="n"'
-            elif link.type == 'entry':
-                return 'style = "solid", label = "", minlen=3, tailport="e", headport="w"'
-            elif link.type == 'subset':
-                return 'style = "solid, dashed", dir="back", minlen=3, taillabel = "< subset >", color = "orange", tailport="n"'
-
-            return 'style = "solid", arrowtail="odot", dir="back", minlen=3'
-
-        def render_module(mod: ModuleNode):
-            color = self.module_color.get(mod.fullname)
-            # render schema nodes inside this module
-            inner_nodes = [
-                f'''
-                "{node.id}" [
-                    label = {self.generate_node_label(node)}
-                    shape = "plain"
-                    margin="0.5,0.1"
-                ];''' for node in mod.schema_nodes
-            ]
-            inner_nodes_str = '\n'.join(inner_nodes)
-
-            # render child modules recursively
-            child_str = '\n'.join(render_module(m) for m in mod.modules)
-
-            return f'''
-            subgraph cluster_module_{mod.fullname.replace('.', '_')} {{
-                color = "#666"
-                style="rounded"
-                label = "  {mod.name}"
-                labeljust = "l"
-                {(f'pencolor = "{color}"' if color else 'pencolor="#ccc"')}
-                {(f'penwidth = 3' if color else 'penwidth=""')}
-                {inner_nodes_str}
-                {child_str}
-            }}'''
-
-        def handle_entry(source: str):
-            if '::' in source:
-                a, b = source.split('::', 1)
-                return f'"{a}":{b}'
-            return f'"{source}"'
-
-
+    def render_dot(self):
         _tags, _routes, _nodes, _links = filter_graph(
             schema=self.schema,
             schema_field=self.schema_field,
@@ -324,79 +268,5 @@ class Analytics:
             links=self.links,
             node_set=self.node_set,
         )
-        _modules = build_module_tree(_nodes)
-
-        tags = [
-            f'''
-            "{t.id}" [
-                label = "    {t.name}    "
-                shape = "record"
-                margin="0.5,0.1"
-            ];''' for t in _tags]
-        tag_str = '\n'.join(tags)
-
-        routes = [
-            f'''
-            "{r.id}" [
-                label = "    {r.name}    "
-                margin="0.5,0.1"
-                shape = "record"
-            ];''' for r in _routes]
-        route_str = '\n'.join(routes)
-
-        modules_str = '\n'.join(render_module(m) for m in _modules)
-
-        links = [ generate_link(link) for link in _links ]
-        link_str = '\n'.join(links)
-
-        template = f'''
-        digraph world {{
-            pad="0.5"
-            nodesep=0.8
-            fontname="Helvetica,Arial,sans-serif"
-            node [fontname="Helvetica,Arial,sans-serif"]
-            edge [
-                fontname="Helvetica,Arial,sans-serif"
-                color="gray"
-            ]
-            graph [
-                rankdir = "LR"
-            ];
-            node [
-                fontsize = "16"
-            ];
-
-            subgraph cluster_tags {{ 
-                color = "#aaa"
-                margin=18
-                style="dashed"
-                label = "  Tags"
-                labeljust = "l"
-                fontsize = "20"
-                {tag_str}
-            }}
-
-            subgraph cluster_router {{
-                color = "#aaa"
-                margin=18
-                style="dashed"
-                label = "  Routes"
-                labeljust = "l"
-                fontsize = "20"
-                {route_str}
-            }}
-
-            subgraph cluster_schema {{
-                color = "#aaa"
-                margin=18
-                style="dashed"
-                label="  Schema"
-                labeljust="l"
-                fontsize="20"
-                    {modules_str}
-            }}
-
-            {link_str}
-            }}
-        '''
-        return template
+        renderer = Renderer(show_fields=self.show_fields, module_color=self.module_color, schema=self.schema)
+        return renderer.render_dot(_tags, _routes, _nodes, _links)

fastapi_voyager-0.5.2/src/fastapi_voyager/web/component/render-graph.js

@@ -0,0 +1,87 @@
+import { GraphUI } from "../graph-ui.js";
+const { defineComponent, ref, onMounted, nextTick } = window.Vue;
+
+export default defineComponent({
+	name: "RenderGraph",
+	props: {
+		coreData: { type: [Object, Array], required: false, default: null },
+	},
+	emits: ["close"],
+	setup(props, { emit }) {
+		const containerId = `graph-render-${Math.random().toString(36).slice(2, 9)}`;
+		const hasRendered = ref(false);
+		const loading = ref(false);
+		let graphInstance = null;
+
+		async function ensureGraph() {
+			await nextTick();
+			if (!graphInstance) {
+				graphInstance = new GraphUI(`#${containerId}`);
+			}
+		}
+
+		async function renderFromDot(dotText) {
+			if (!dotText) return;
+			await ensureGraph();
+			await graphInstance.render(dotText);
+			hasRendered.value = true;
+		}
+
+		async function renderFromCoreData() {
+			if (!props.coreData) return;
+			loading.value = true;
+			try {
+				const res = await fetch("/dot-render-core-data", {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify(props.coreData),
+				});
+				const dotText = await res.text();
+				await renderFromDot(dotText);
+				if (window.Quasar?.Notify) {
+					window.Quasar.Notify.create({ type: "positive", message: "Rendered" });
+				}
+			} catch (e) {
+				console.error("Render from core data failed", e);
+				if (window.Quasar?.Notify) {
+					window.Quasar.Notify.create({ type: "negative", message: "Render failed" });
+				}
+			} finally {
+				loading.value = false;
+			}
+		}
+
+		async function reload() {
+			await renderFromCoreData();
+		}
+
+		onMounted(async () => {
+			await reload();
+		});
+
+		function close() {
+			emit("close");
+		}
+
+		return { containerId, close, hasRendered, reload, loading };
+	},
+	template: `
+		<div style="height:100%; position:relative; background:#fff;">
+			<q-btn
+				flat dense round icon="close"
+				aria-label="Close"
+				@click="close"
+				style="position:absolute; top:6px; right:6px; z-index:11; background:rgba(255,255,255,0.85);"
+			/>
+			<q-btn
+				flat dense round icon="refresh"
+				aria-label="Reload"
+				:loading="loading"
+				@click="reload"
+				style="position:absolute; top:6px; right:46px; z-index:11; background:rgba(255,255,255,0.85);"
+			/>
+			<div :id="containerId" style="width:100%; height:100%; overflow:auto; background:#fafafa"></div>
+		</div>
+	`,
+});
+

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/web/index.html

@@ -110,13 +110,23 @@
           </div>
 
           <div class="col-auto">
-            <q-btn
+            <q-btn-dropdown
               class="q-ml-md"
+              split
               :loading="state.generating"
               @click="onGenerate"
               label="Generate"
               outline
-            />
+            >
+              <q-list>
+                <q-item clickable v-close-popup @click="onDumpData">
+                  <q-item-section>Dump data</q-item-section>
+                </q-item>
+                <q-item clickable v-close-popup @click="openImportDialog">
+                  <q-item-section>Import data</q-item-section>
+                </q-item>
+              </q-list>
+            </q-btn-dropdown>
           </div>
           <div class="col-auto">
             <q-btn flat @click="onReset" label="Reset" />
@@ -204,6 +214,45 @@
           @close="showRouteCode = false" />
       </q-dialog>
 
+      <!-- Dump Core Data Dialog -->
+      <q-dialog v-model="showDumpDialog" :maximized="true" :persistent="false">
+        <div style="height:100%; position:relative; background:#fff;">
+          <q-btn
+            flat dense round icon="content_copy"
+            aria-label="Copy"
+            @click="copyDumpJson"
+            style="position:absolute; top:6px; right:62px; z-index:11; background:rgba(255,255,255,0.85);"
+          ></q-btn>
+          <q-btn
+            flat dense round icon="close"
+            aria-label="Close"
+            @click="showDumpDialog = false"
+            style="position:absolute; top:6px; right:6px; z-index:11; background:rgba(255,255,255,0.85);"
+          ></q-btn>
+          <div>
+            <pre style="padding:20px; overflow: auto;"><code>{{ dumpJson }}</code></pre>
+          </div>
+        </div>
+      </q-dialog>
+
+      <!-- Import Core Data Dialog -->
+      <q-dialog v-model="showImportDialog" :persistent="true">
+        <q-card style="min-width:70vw; max-width:90vw;">
+          <q-card-section class="text-h6">Import core data JSON</q-card-section>
+          <q-card-section >
+            <q-btn color="primary" label="Render" @click="onImportConfirm" />
+          </q-card-section>
+          <q-card-section>
+            <q-input v-model="importJsonText" type="textarea" autogrow filled label="Paste JSON here" />
+          </q-card-section>
+        </q-card>
+      </q-dialog>
+
+      <!-- Render Graph Dialog (from imported core data) -->
+      <q-dialog v-model="showRenderGraph" :maximized="true" :persistent="false">
+        <render-graph :core-data="renderCoreData" @close="showRenderGraph = false" />
+      </q-dialog>
+
       <div id="graph" style="width: 100%; flex: 1 1 auto; overflow: auto"></div>
     </div>
 

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/src/fastapi_voyager/web/vue-main.js

@@ -1,6 +1,7 @@
 import SchemaFieldFilter from "./component/schema-field-filter.js";
 import SchemaCodeDisplay from "./component/schema-code-display.js";
 import RouteCodeDisplay from "./component/route-code-display.js";
+import RenderGraph from "./component/render-graph.js";
 import { GraphUI } from "./graph-ui.js";
 const { createApp, reactive, onMounted, watch, ref } = window.Vue;
 
@@ -25,16 +26,23 @@ const app = createApp({
       rawTags: [], // [{ name, routes: [{ id, name }] }]
       rawSchemas: [], // [{ name, fullname }]
       rawSchemasFull: [], // full objects with source_code & fields
-  initializing: true,
+      initializing: true,
     });
     const showDetail = ref(false);
     const showSchemaFieldFilter = ref(false);
-  const showSchemaCode = ref(false);
-  const showRouteCode = ref(false);
+    const showSchemaCode = ref(false);
+    const showRouteCode = ref(false);
+    // Dump/Import dialogs and rendered graph dialog
+    const showDumpDialog = ref(false);
+    const dumpJson = ref("");
+    const showImportDialog = ref(false);
+    const importJsonText = ref("");
+  const showRenderGraph = ref(false);
+  const renderCoreData = ref(null);
     const schemaName = ref(""); // used by detail dialog
     const schemaFieldFilterSchema = ref(null); // external schemaName for schema-field-filter
-  const schemaCodeName = ref("");
-  const routeCodeId = ref("");
+    const schemaCodeName = ref("");
+    const routeCodeId = ref("");
     function openDetail() {
       showDetail.value = true;
     }
@@ -94,10 +102,13 @@ const app = createApp({
           name: s.name,
           fullname: s.fullname,
         }));
-        state.routeItems = data.tags.map((t) => t.routes).flat().reduce((acc, r) => {
-          acc[r.id] = r;
-          return acc;
-        }, {});
+        state.routeItems = data.tags
+          .map((t) => t.routes)
+          .flat()
+          .reduce((acc, r) => {
+            acc[r.id] = r;
+            return acc;
+          }, {});
 
         state.tagOptions = state.rawTags.map((t) => t.name);
         state.schemaOptions = state.rawSchemas.map((s) => ({
@@ -161,6 +172,62 @@ const app = createApp({
       }
     }
 
+    async function onDumpData() {
+      try {
+        const payload = {
+          tags: state.tag ? [state.tag] : null,
+          schema_name: state.schemaFullname || null,
+          route_name: state.routeId || null,
+          show_fields: state.showFields,
+        };
+        const res = await fetch("/dot-core-data", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+        const json = await res.json();
+        dumpJson.value = JSON.stringify(json, null, 2);
+        showDumpDialog.value = true;
+      } catch (e) {
+        console.error("Dump data failed", e);
+      }
+    }
+
+    async function copyDumpJson() {
+      try {
+        await navigator.clipboard.writeText(dumpJson.value || "");
+        if (window.Quasar?.Notify) {
+          window.Quasar.Notify.create({ type: "positive", message: "Copied" });
+        }
+      } catch (e) {
+        console.error("Copy failed", e);
+      }
+    }
+
+    function openImportDialog() {
+      importJsonText.value = "";
+      showImportDialog.value = true;
+    }
+
+    async function onImportConfirm() {
+      let payloadObj = null;
+      try {
+        payloadObj = JSON.parse(importJsonText.value || "{}");
+      } catch (e) {
+        if (window.Quasar?.Notify) {
+          window.Quasar.Notify.create({
+            type: "negative",
+            message: "Invalid JSON",
+          });
+        }
+        return;
+      }
+      // Move the request into RenderGraph component: pass the parsed object and let the component call /dot-render-core-data
+      renderCoreData.value = payloadObj;
+      showRenderGraph.value = true;
+      showImportDialog.value = false;
+    }
+
     function showDialog() {
       schemaFieldFilterSchema.value = null;
       showSchemaFieldFilter.value = true;
@@ -203,6 +270,18 @@ const app = createApp({
       showRouteCode,
       schemaCodeName,
       routeCodeId,
+      // dump/import
+      showDumpDialog,
+      dumpJson,
+      copyDumpJson,
+      onDumpData,
+      showImportDialog,
+      importJsonText,
+      openImportDialog,
+      onImportConfirm,
+      // render graph dialog
+      showRenderGraph,
+      renderCoreData,
     };
   },
 });
@@ -210,4 +289,5 @@ app.use(window.Quasar);
 app.component("schema-field-filter", SchemaFieldFilter);
 app.component("schema-code-display", SchemaCodeDisplay);
 app.component("route-code-display", RouteCodeDisplay);
+app.component("render-graph", RenderGraph);
 app.mount("#q-app");

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/tests/demo.py

@@ -48,10 +48,12 @@ class PageSprint(serv.Sprint):
 class PageOverall(BaseModel):
     sprints: list[PageSprint]
 
+class PageOverallWrap(PageOverall):
+    content: str
 
-@app.get("/page_overall", tags=['for-page'], response_model=PageOverall)
+@app.get("/page_overall", tags=['for-page'], response_model=PageOverallWrap)
 async def get_page_info():
-    page_overall = PageOverall(sprints=[]) # focus on schema only
+    page_overall = PageOverallWrap(content="Page Overall Content", sprints=[]) # focus on schema only
     return await Resolver().resolve(page_overall)
 
 

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/tests/service/schema.py

@@ -1,4 +1,4 @@
-from fastapi_voyager.graph import Analytics
+from fastapi_voyager.voyager import Voyager
 from pydantic import BaseModel
 from pydantic_resolve import ensure_subset
 

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/tests/test_analysis.py

@@ -1,4 +1,4 @@
-from fastapi_voyager.graph import Analytics
+from fastapi_voyager.voyager import Voyager
 from pydantic import BaseModel
 from fastapi import FastAPI
 from typing import Optional
@@ -30,7 +30,7 @@ def test_analysis():
     def home2():
         return None
 
-    analytics = Analytics()
+    analytics = Voyager()
     analytics.analysis(app)
     assert len(analytics.nodes) == 3
     assert len(analytics.links) == 6

{fastapi_voyager-0.4.5 → fastapi_voyager-0.5.2}/tests/test_module.py

@@ -30,7 +30,7 @@ def test_build_module_tree_basic():
 
     # Assert: top-level modules
     names = sorted(m.name for m in top_modules)
-    assert names == ["pkg", "x"]
+    assert names == ["pkg", "x.y.z"]
 
     # pkg level
     pkg = _find_top(top_modules, "pkg")
@@ -87,25 +87,21 @@ def test_collapse_single_child_empty_modules():
         _sn("Peer", "a.b.x", "Peer"),
     ]
     top_modules = build_module_tree(schema_nodes)
-
+    print(top_modules)
     # 'a' should have one child path 'b', but due to branching at x, only a.b collapses into a.b
     # and below it, 'c.d' should collapse to 'c.d'. Final structure:
     # a
     #  └── b
     #       ├── c.d (holds Deep)
     #       └── x (holds Peer)
-    a = _find_top(top_modules, "a")
+    a = _find_top(top_modules, "a.b")
     assert a is not None
     assert a.schema_nodes == []
     # b remains as child of a
-    b = _find_child(a, "b")
+    b = _find_child(a, "c.d")
     assert b is not None
-    assert b.schema_nodes == []
+    assert [sn.name for sn in b.schema_nodes] == ['Deep']
     # collapsed node under b is named "c.d"
-    cd = _find_child(b, "c.d")
-    assert cd is not None
-    assert [sn.name for sn in cd.schema_nodes] == ["Deep"]
-    # sibling x remains
-    x = _find_child(b, "x")
+    x = _find_child(a, "x")
     assert x is not None
     assert [sn.name for sn in x.schema_nodes] == ["Peer"]