mengzhx/semantica
1
0
Fork 0
mirror of https://github.com/semantica-agi/semantica.git synced 2026-08-29 04:26:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
affe3aa8bd5fe3f552d0fa4e4a04eaf0d6663a3b
semantica/semantica/export/methods.py
T

817 lines
29 KiB
Python
Raw Blame History

"""
Export Methods Module
This module provides all export methods as simple, reusable functions for
exporting knowledge graphs, entities, relationships, and data to various formats.
It supports multiple export approaches and integrates with the method registry
for extensibility.
Supported Methods:
RDF Export:
- "turtle": Turtle format export
- "rdfxml": RDF/XML format export
- "jsonld": JSON-LD format export
- "ntriples": N-Triples format export
- "n3": N3 format export
JSON Export:
- "json": Standard JSON format export
- "json-ld": JSON-LD format export
CSV Export:
- "csv": CSV format export with configurable delimiter
Graph Export:
- "graphml": GraphML format export
- "gexf": GEXF format export
- "dot": DOT format export
- "json": JSON graph format export
YAML Export:
- "yaml": YAML format export
- "semantic_network": Semantic network YAML export
- "schema": Schema YAML export
OWL Export:
- "owl-xml": OWL/XML format export
- "turtle": OWL in Turtle format
Vector Export:
- "json": JSON vector format
- "numpy": NumPy format
- "binary": Binary format
- "faiss": FAISS format
LPG Export:
- "cypher": Cypher query format for Neo4j/Memgraph
- "lpg": Labeled Property Graph format
Report Generation:
- "html": HTML report format
- "markdown": Markdown report format
- "json": JSON report format
- "text": Plain text report format
Algorithms Used:
RDF Export:
- RDF Serialization: Multiple format serialization (Turtle, RDF/XML, JSON-LD, N-Triples, N3)
- Namespace Management: Namespace registration, conflict resolution, declaration generation
- RDF Validation: RDF syntax validation, triplet validation, namespace validation
- URI Generation: Hash-based and text-based URI assignment for RDF resources
- Triplet Extraction: Entity and relationship to RDF triplet conversion
- Format Conversion: Cross-format RDF conversion algorithms
LPG (Labeled Property Graph) Export:
- LPG Serialization: Labeled Property Graph format for Neo4j, Memgraph, and similar databases
- Node Label Assignment: Entity type to node label mapping
- Relationship Type Mapping: Relationship type to edge label conversion
- Property Serialization: Entity and relationship properties to LPG property format
- Cypher Query Generation: Cypher CREATE statements for graph database import
- Batch Node/Relationship Export: Efficient batch processing for large graphs
- Index Generation: Index and constraint generation for graph databases
JSON/JSON-LD Export:
- JSON Serialization: Standard JSON serialization with configurable indentation
- JSON-LD Context Management: @context generation and management
- Knowledge Graph Serialization: Graph structure to JSON/JSON-LD conversion
- Metadata Embedding: Provenance and metadata serialization in JSON structure
- Pretty Printing: Formatted JSON output with indentation
CSV Export:
- Tabular Serialization: Entity and relationship to CSV row conversion
- Field Extraction: Dynamic field name extraction from data structures
- Delimiter Handling: Configurable delimiter support (comma, tab, semicolon)
- Header Generation: Automatic CSV header row generation
- Metadata Serialization: JSON string serialization for complex metadata fields
- Multi-file Export: Knowledge graph split into multiple CSV files (entities, relationships)
Graph Export:
- GraphML Serialization: GraphML format generation for graph visualization tools
- GEXF Serialization: GEXF format generation for Gephi and similar tools
- DOT Serialization: Graphviz DOT format generation
- Node/Edge Attribute Mapping: Property to graph attribute conversion
- Graph Structure Conversion: Knowledge graph to graph format transformation
YAML Export:
- YAML Serialization: Human-readable YAML format generation
- Semantic Network Export: Entity-relationship network to YAML conversion
- Schema Export: Ontology schema to YAML for human editing
- Pipeline Integration: Stage-specific YAML export for ontology generation pipeline
OWL Export:
- OWL-XML Serialization: OWL/XML format generation
- Turtle Serialization: OWL in Turtle format
- Class Hierarchy Export: Class definition and hierarchy serialization
- Property Export: Object and data property definition export
- OWL 2.0 Feature Support: Advanced OWL features (cardinality, restrictions, etc.)
- Ontology Validation: OWL syntax and semantic validation
Vector Export:
- Vector Serialization: Multiple format support (JSON, NumPy, Binary, FAISS)
- Vector Store Integration: Format conversion for Weaviate, Qdrant, FAISS
- Metadata Association: Vector-to-metadata mapping and serialization
- Batch Export: Efficient batch vector export processing
- Multi-dimensional Support: Variable dimension vector handling
Report Generation:
- Template Rendering: Template-based report generation (HTML, Markdown, JSON, Text)
- Quality Metrics Aggregation: Statistical aggregation of quality metrics
- Chart Generation: Visualization and chart generation (if enabled)
- Format Conversion: Cross-format report conversion
- Section Organization: Hierarchical report section organization
Key Features:
- Multiple export format methods
- Knowledge graph export with format dispatch
- Method dispatchers with registry support
- Custom method registration capability
- Consistent interface across all methods
Main Functions:
- export_rdf: RDF export wrapper
- export_json: JSON/JSON-LD export wrapper
- export_csv: CSV export wrapper
- export_graph: Graph format export wrapper
- export_yaml: YAML export wrapper
- export_owl: OWL export wrapper
- export_vector: Vector export wrapper
- export_lpg: LPG export wrapper
- generate_report: Report generation wrapper
- get_export_method: Get export method by name
- list_available_methods: List registered methods
Example Usage:
>>> from semantica.export.methods import export_rdf, export_json, export_lpg
>>> kg = {"entities": [...], "relationships": [...]}
>>> export_json(kg, "output.json", format="json")
>>> export_rdf(kg, "output.ttl", format="turtle")
>>> export_lpg(kg, "output.cypher", method="cypher")
"""
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Union
from ..utils.exceptions import ConfigurationError, ProcessingError
from ..utils.logging import get_logger
from .arrow_exporter import ArrowExporter
from .config import export_config
from .csv_exporter import CSVExporter
from .graph_exporter import GraphExporter
from .json_exporter import JSONExporter
from .lpg_exporter import LPGExporter
from .owl_exporter import OWLExporter
from .rdf_exporter import RDFExporter
from .registry import method_registry
from .report_generator import ReportGenerator
from .vector_exporter import VectorExporter
from .yaml_exporter import SemanticNetworkYAMLExporter, YAMLSchemaExporter
logger = get_logger("export_methods")
def export_rdf(
data: Union[Dict[str, Any], List[Dict[str, Any]]],
file_path: Union[str, Path],
format: str = "turtle",
method: str = "default",
**kwargs,
) -> None:
"""
Export data to RDF format (convenience function).
This is a user-friendly wrapper that exports data to RDF using the specified format.
Args:
data: Data to export (knowledge graph, entities, relationships, or triplets)
file_path: Output RDF file path
format: RDF format (default: "turtle")
- "turtle": Turtle format
- "rdfxml": RDF/XML format
- "jsonld": JSON-LD format
- "ntriples": N-Triples format
- "n3": N3 format
method: Export method (default: "default")
**kwargs: Additional options passed to RDFExporter
Examples:
>>> from semantica.export.methods import export_rdf
>>> export_rdf(kg, "output.ttl", format="turtle")
>>> export_rdf(entities, "output.rdf", format="rdfxml")
"""
# Check for custom method in registry
custom_method = method_registry.get("rdf", method)
if custom_method and custom_method is not export_rdf:
try:
return custom_method(data, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("rdf")
config.update(kwargs)
exporter = RDFExporter(**config)
exporter.export(data, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to export RDF: {e}")
raise
def export_json(
data: Union[Dict[str, Any], List[Dict[str, Any]]],
file_path: Union[str, Path],
format: str = "json",
method: str = "default",
**kwargs,
) -> None:
"""
Export data to JSON/JSON-LD format (convenience function).
This is a user-friendly wrapper that exports data to JSON or JSON-LD format.
Args:
data: Data to export (knowledge graph, entities, relationships)
file_path: Output JSON file path
format: Export format (default: "json")
- "json": Standard JSON format
- "json-ld": JSON-LD format
method: Export method (default: "default")
**kwargs: Additional options passed to JSONExporter
Examples:
>>> from semantica.export.methods import export_json
>>> export_json(kg, "output.json", format="json")
>>> export_json(kg, "output.jsonld", format="json-ld")
"""
# Check for custom method in registry
custom_method = method_registry.get("json", method)
if custom_method and custom_method is not export_json:
try:
return custom_method(data, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("json")
config.update(kwargs)
config["format"] = format
exporter = JSONExporter(**config)
exporter.export(data, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to export JSON: {e}")
raise
def export_csv(
data: Union[List[Dict[str, Any]], Dict[str, List[Dict[str, Any]]]],
file_path: Union[str, Path],
method: str = "default",
**kwargs,
) -> None:
"""
Export data to CSV format (convenience function).
This is a user-friendly wrapper that exports data to CSV format.
Args:
data: Data to export (list of dicts or dict with list values)
file_path: Output CSV file path (or base path for multiple files)
method: Export method (default: "default")
**kwargs: Additional options passed to CSVExporter
Examples:
>>> from semantica.export.methods import export_csv
>>> export_csv(entities, "entities.csv")
>>> export_csv({"entities": [...], "relationships": [...]}, "output_base")
"""
# Check for custom method in registry
custom_method = method_registry.get("csv", method)
if custom_method and custom_method is not export_csv:
try:
return custom_method(data, file_path, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("csv")
config.update(kwargs)
exporter = CSVExporter(**config)
exporter.export(data, file_path, **kwargs)
except Exception as e:
logger.error(f"Failed to export CSV: {e}")
raise
def export_arrow(
data: Union[List[Dict[str, Any]], Dict[str, List[Dict[str, Any]]]],
file_path: Union[str, Path],
method: str = "default",
**kwargs,
) -> None:
"""
Export data to Apache Arrow format (convenience function).
This is a user-friendly wrapper that exports data to Arrow IPC format.
Args:
data: Data to export (list of dicts or dict with list values)
file_path: Output Arrow file path (or base path for multiple files)
method: Export method (default: "default")
**kwargs: Additional options passed to ArrowExporter
Examples:
>>> from semantica.export.methods import export_arrow
>>> export_arrow(entities, "entities.arrow")
>>> export_arrow({"entities": [...], "relationships": [...]}, "output_base")
"""
# Check for custom method in registry
custom_method = method_registry.get("arrow", method)
if custom_method and custom_method is not export_arrow:
try:
return custom_method(data, file_path, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("arrow")
config.update(kwargs)
exporter = ArrowExporter(**config)
exporter.export(data, file_path, **kwargs)
except Exception as e:
logger.error(f"Failed to export Arrow: {e}")
raise
def export_graph(
graph_data: Dict[str, Any],
file_path: Union[str, Path],
format: str = "json",
method: str = "default",
**kwargs,
) -> None:
"""
Export graph data to graph format (convenience function).
This is a user-friendly wrapper that exports graph data to various graph formats.
Args:
graph_data: Graph data dictionary with nodes and edges
file_path: Output graph file path
format: Graph format (default: "json")
- "graphml": GraphML format
- "gexf": GEXF format
- "dot": DOT format
- "json": JSON graph format
method: Export method (default: "default")
**kwargs: Additional options passed to GraphExporter
Examples:
>>> from semantica.export.methods import export_graph
>>> export_graph(graph_data, "graph.graphml", format="graphml")
>>> export_graph(graph_data, "graph.gexf", format="gexf")
"""
# Check for custom method in registry
custom_method = method_registry.get("graph", method)
if custom_method and custom_method is not export_graph:
try:
return custom_method(graph_data, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("graph")
config.update(kwargs)
config["format"] = format
exporter = GraphExporter(**config)
exporter.export(graph_data, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to export graph: {e}")
raise
def export_yaml(
data: Union[Dict[str, Any], List[Dict[str, Any]]],
file_path: Union[str, Path],
method: str = "semantic_network",
**kwargs,
) -> None:
"""
Export data to YAML format (convenience function).
This is a user-friendly wrapper that exports data to YAML format.
Args:
data: Data to export (semantic network, entities, relationships)
file_path: Output YAML file path
method: Export method (default: "semantic_network")
- "semantic_network": Semantic network YAML export
- "schema": Schema YAML export
**kwargs: Additional options passed to YAML exporters
Examples:
>>> from semantica.export.methods import export_yaml
>>> export_yaml(semantic_network, "network.yaml", method="semantic_network")
>>> export_yaml(schema, "schema.yaml", method="schema")
"""
# Check for custom method in registry
custom_method = method_registry.get("yaml", method)
if custom_method and custom_method is not export_yaml:
try:
return custom_method(data, file_path, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("yaml")
config.update(kwargs)
if method == "semantic_network":
exporter = SemanticNetworkYAMLExporter(**config)
exporter.export(data, file_path, **kwargs)
elif method == "schema":
exporter = YAMLSchemaExporter(**config)
yaml_content = exporter.export_ontology_schema(data, **kwargs)
with open(file_path, "w", encoding="utf-8") as f:
f.write(yaml_content)
else:
raise ProcessingError(f"Unknown YAML export method: {method}")
except Exception as e:
logger.error(f"Failed to export YAML: {e}")
raise
def export_owl(
ontology: Dict[str, Any],
file_path: Union[str, Path],
format: str = "owl-xml",
method: str = "default",
**kwargs,
) -> None:
"""
Export ontology to OWL format (convenience function).
This is a user-friendly wrapper that exports ontologies to OWL format.
Args:
ontology: Ontology data dictionary
file_path: Output OWL file path
format: OWL format (default: "owl-xml")
- "owl-xml": OWL/XML format
- "turtle": OWL in Turtle format
method: Export method (default: "default")
**kwargs: Additional options passed to OWLExporter
Examples:
>>> from semantica.export.methods import export_owl
>>> export_owl(ontology, "ontology.owl", format="owl-xml")
>>> export_owl(ontology, "ontology.ttl", format="turtle")
"""
# Check for custom method in registry
custom_method = method_registry.get("owl", method)
if custom_method and custom_method is not export_owl:
try:
return custom_method(ontology, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("owl")
config.update(kwargs)
config["format"] = format
exporter = OWLExporter(**config)
exporter.export(ontology, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to export OWL: {e}")
raise
def export_vector(
vectors: Union[List, Dict[str, Any]],
file_path: Union[str, Path],
format: str = "json",
method: str = "default",
**kwargs,
) -> None:
"""
Export vectors to vector format (convenience function).
This is a user-friendly wrapper that exports vectors to various vector formats.
Args:
vectors: Vector data (list of vectors or dict with vector data)
file_path: Output vector file path
format: Vector format (default: "json")
- "json": JSON vector format
- "numpy": NumPy format
- "binary": Binary format
- "faiss": FAISS format
method: Export method (default: "default")
**kwargs: Additional options passed to VectorExporter
Examples:
>>> from semantica.export.methods import export_vector
>>> export_vector(vectors, "vectors.json", format="json")
>>> export_vector(vectors, "vectors.npy", format="numpy")
"""
# Check for custom method in registry
custom_method = method_registry.get("vector", method)
if custom_method and custom_method is not export_vector:
try:
return custom_method(vectors, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("vector")
config.update(kwargs)
config["format"] = format
exporter = VectorExporter(**config)
exporter.export(vectors, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to export vector: {e}")
raise
def export_lpg(
knowledge_graph: Dict[str, Any],
file_path: Union[str, Path],
method: str = "cypher",
**kwargs,
) -> None:
"""
Export knowledge graph to LPG format (convenience function).
This is a user-friendly wrapper that exports knowledge graphs to LPG format
(Cypher queries for Neo4j, Memgraph, etc.).
Args:
knowledge_graph: Knowledge graph dictionary with entities and relationships
file_path: Output Cypher file path
method: Export method (default: "cypher")
- "cypher": Cypher query format
- "lpg": Labeled Property Graph format
**kwargs: Additional options passed to LPGExporter
Examples:
>>> from semantica.export.methods import export_lpg
>>> export_lpg(kg, "graph.cypher", method="cypher")
"""
# Check for custom method in registry
custom_method = method_registry.get("lpg", method)
if custom_method and custom_method is not export_lpg:
try:
return custom_method(knowledge_graph, file_path, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("lpg")
config.update(kwargs)
exporter = LPGExporter(**config)
exporter.export_knowledge_graph(knowledge_graph, file_path, **kwargs)
except Exception as e:
logger.error(f"Failed to export LPG: {e}")
raise
def generate_report(
data: Dict[str, Any],
file_path: Union[str, Path],
format: str = "markdown",
method: str = "default",
**kwargs,
) -> None:
"""
Generate report (convenience function).
This is a user-friendly wrapper that generates reports in various formats.
Args:
data: Report data dictionary
file_path: Output report file path
format: Report format (default: "markdown")
- "html": HTML report format
- "markdown": Markdown report format
- "json": JSON report format
- "text": Plain text report format
method: Report generation method (default: "default")
**kwargs: Additional options passed to ReportGenerator
Examples:
>>> from semantica.export.methods import generate_report
>>> generate_report(metrics, "report.html", format="html")
>>> generate_report(analysis, "report.md", format="markdown")
"""
# Check for custom method in registry
custom_method = method_registry.get("report", method)
if custom_method and custom_method is not generate_report:
try:
return custom_method(data, file_path, format=format, **kwargs)
except Exception as e:
logger.warning(
f"Custom method {method} failed: {e}, falling back to default"
)
try:
# Get config
config = export_config.get_method_config("report")
config.update(kwargs)
config["format"] = format
generator = ReportGenerator(**config)
generator.generate_report(data, file_path, format=format, **kwargs)
except Exception as e:
logger.error(f"Failed to generate report: {e}")
raise
def export_knowledge_graph(
knowledge_graph: Dict[str, Any],
file_path: Union[str, Path],
format: str = "json",
method: Optional[str] = None,
**kwargs,
) -> None:
"""
Export knowledge graph to specified format (unified convenience function).
This is a user-friendly wrapper that automatically routes to the appropriate
exporter based on the file extension or format parameter.
Args:
knowledge_graph: Knowledge graph dictionary with entities and relationships
file_path: Output file path (format auto-detected from extension if format not specified)
format: Export format (auto-detected from file extension if not specified)
- "json", "json-ld": JSONExporter
- "csv": CSVExporter
- "ttl", "turtle": RDFExporter (turtle)
- "rdf", "rdfxml": RDFExporter (rdfxml)
- "graphml": GraphExporter (graphml)
- "gexf": GraphExporter (gexf)
- "dot": GraphExporter (dot)
- "yaml", "yml": YAML exporters
- "owl": OWLExporter
- "cypher": LPGExporter
method: Optional specific export method
**kwargs: Additional options passed to exporter
Examples:
>>> from semantica.export.methods import export_knowledge_graph
>>> export_knowledge_graph(kg, "output.json", format="json")
>>> export_knowledge_graph(kg, "output.ttl", format="turtle")
>>> export_knowledge_graph(kg, "output.cypher", format="cypher")
"""
# Auto-detect format from file extension if not specified
if not format:
file_path_obj = Path(file_path)
ext = file_path_obj.suffix.lower()
format_map = {
".json": "json",
".jsonld": "json-ld",
".csv": "csv",
".ttl": "turtle",
".rdf": "rdfxml",
".graphml": "graphml",
".gexf": "gexf",
".dot": "dot",
".yaml": "yaml",
".yml": "yaml",
".owl": "owl-xml",
".cypher": "cypher",
}
format = format_map.get(ext, "json")
# Route to appropriate exporter
if format in ["json", "json-ld"]:
export_json(knowledge_graph, file_path, format=format, method=method, **kwargs)
elif format == "csv":
export_csv(knowledge_graph, file_path, method=method, **kwargs)
elif format in ["turtle", "rdfxml", "jsonld", "ntriples", "n3"]:
export_rdf(knowledge_graph, file_path, format=format, method=method, **kwargs)
elif format in ["graphml", "gexf", "dot"]:
export_graph(knowledge_graph, file_path, format=format, method=method, **kwargs)
elif format in ["yaml", "yml"]:
export_yaml(knowledge_graph, file_path, method=method, **kwargs)
elif format in ["owl-xml", "owl"]:
export_owl(knowledge_graph, file_path, format=format, method=method, **kwargs)
elif format == "cypher":
export_lpg(knowledge_graph, file_path, method=method, **kwargs)
else:
raise ProcessingError(f"Unknown export format: {format}")
def get_export_method(task: str, name: str) -> Optional[Callable]:
"""
Get a registered export method.
Args:
task: Task type ("rdf", "json", "csv", "graph", "yaml", "owl", "vector", "lpg", "report", "export")
name: Method name
Returns:
Registered method or None if not found
Examples:
>>> from semantica.export.methods import get_export_method
>>> method = get_export_method("json", "custom_method")
>>> if method:
... result = method(data, "output.json")
"""
return method_registry.get(task, name)
def list_available_methods(task: Optional[str] = None) -> Dict[str, List[str]]:
"""
List all available export methods.
Args:
task: Optional task type filter
Returns:
Dictionary mapping task types to method names
Examples:
>>> from semantica.export.methods import list_available_methods
>>> all_methods = list_available_methods()
>>> json_methods = list_available_methods("json")
"""
return method_registry.list_all(task)
# Register default methods
method_registry.register("rdf", "default", export_rdf)
method_registry.register("rdf", "turtle", export_rdf)
method_registry.register("rdf", "rdfxml", export_rdf)
method_registry.register("rdf", "jsonld", export_rdf)
method_registry.register("json", "default", export_json)
method_registry.register("json", "json", export_json)
method_registry.register("json", "json-ld", export_json)
method_registry.register("csv", "default", export_csv)
method_registry.register("csv", "csv", export_csv)
method_registry.register("graph", "default", export_graph)
method_registry.register("graph", "graphml", export_graph)
method_registry.register("graph", "gexf", export_graph)
method_registry.register("graph", "dot", export_graph)
method_registry.register("yaml", "default", export_yaml)
method_registry.register("yaml", "semantic_network", export_yaml)
method_registry.register("yaml", "schema", export_yaml)
method_registry.register("owl", "default", export_owl)
method_registry.register("owl", "owl-xml", export_owl)
method_registry.register("owl", "turtle", export_owl)
method_registry.register("vector", "default", export_vector)
method_registry.register("vector", "json", export_vector)
method_registry.register("vector", "numpy", export_vector)
method_registry.register("lpg", "default", export_lpg)
method_registry.register("lpg", "cypher", export_lpg)
method_registry.register("report", "default", generate_report)
method_registry.register("report", "html", generate_report)
method_registry.register("report", "markdown", generate_report)
method_registry.register("export", "default", export_knowledge_graph)
method_registry.register("export", "knowledge_graph", export_knowledge_graph)
Reference in New Issue View Git Blame Copy Permalink