structured2graph 0.2.0__tar.gz → 0.2.1__tar.gz

{structured2graph-0.2.0 → structured2graph-0.2.1}/.env

@@ -23,7 +23,7 @@ ANTHROPIC_API_KEY="sk-ant-api03-vXCucqmmzT44s_YtHgbq_Y7-aHlFC2YwRplQeWi_nhvzbvkk
 # SQL2MG_LOG_LEVEL=INFO
 
 # Source Database Selection - options: mysql, postgresql
-SOURCE_DB_TYPE=postgresql
+SOURCE_DB_TYPE=mysql
 
 # # MySQL Database Configuration (used when SOURCE_DB_TYPE=mysql)
 MYSQL_HOST=localhost
@@ -33,8 +33,8 @@ MYSQL_DATABASE=employees
 MYSQL_PORT=3306
 
 # PostgreSQL Database Configuration (used when SOURCE_DB_TYPE=postgresql)
-# POSTGRES_HOST=localhost
-POSTGRES_HOST=postgres-dev
+POSTGRES_HOST=localhost
+# POSTGRES_HOST=postgres-dev
 POSTGRES_USER=postgres
 POSTGRES_PASSWORD=postgres
 POSTGRES_DATABASE=postgres

{structured2graph-0.2.0 → structured2graph-0.2.1}/.env.example

@@ -1,3 +1,6 @@
+# NOTE: To configure environment, copy this file into .env file (under the same
+# folder) and adjust the values.
+
 # LLM API Configuration (choose one or more)
 # OpenAI
 OPENAI_API_KEY=your_actual_openai_api_key

{structured2graph-0.2.0 → structured2graph-0.2.1}/Dockerfile

@@ -2,11 +2,17 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
+# Install editors for interactive mapping editing
+RUN apt-get update && apt-get install -y --no-install-recommends vim-tiny neovim \
+    && ln -s /usr/bin/vim.tiny /usr/bin/vi \
+    && rm -rf /var/lib/apt/lists/*
+ENV EDITOR=nvim
+
 # Install uv for fast dependency management
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 
 # Install the released package from PyPI
-RUN uv pip install --system structured2graph
+RUN uv pip install --system structured2graph==0.2.1
 
 # Copy .env.example as reference; users supply real values at runtime
 # via: docker run -it --env-file .env memgraph/structured2graph

{structured2graph-0.2.0 → structured2graph-0.2.1}/Dockerfile.local

@@ -2,6 +2,12 @@ FROM python:3.12-slim
 
 WORKDIR /app
 
+# Install editors for interactive mapping editing
+RUN apt-get update && apt-get install -y --no-install-recommends vim-tiny neovim \
+    && ln -s /usr/bin/vim.tiny /usr/bin/vi \
+    && rm -rf /var/lib/apt/lists/*
+ENV EDITOR=nvim
+
 # Install uv for fast dependency management
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
 

{structured2graph-0.2.0 → structured2graph-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structured2graph
-Version: 0.2.0
+Version: 0.2.1
 Summary: Database migration agent from structured data (e.g. SQL) to graph.
 Project-URL: Homepage, https://github.com/memgraph/ai-toolkit
 Project-URL: Repository, https://github.com/memgraph/ai-toolkit

{structured2graph-0.2.0 → structured2graph-0.2.1}/core/hygm/models/llm_models.py

@@ -165,10 +165,17 @@ class LLMGraphModel(BaseModel):
                 )
                 node_constraints.append(graph_constraint)
 
+        # Build a lookup from node name → source table
+        node_table_map = {}
+        node_pk_map = {}
+        for node in self.nodes:
+            node_table_map[node.name] = node.source_table
+            node_pk_map[node.name] = node.primary_key
+
         # Convert relationships
         graph_relationships = []
         for llm_rel in self.relationships:
-            # Find source/target node labels
+            # Find source/target node labels and tables
             from_labels = []
             to_labels = []
             for node in self.nodes:
@@ -177,6 +184,16 @@ class LLMGraphModel(BaseModel):
                 if node.name == llm_rel.to_node:
                     to_labels = node.labels
 
+            from_table = node_table_map.get(llm_rel.from_node, "")
+            to_table = node_table_map.get(llm_rel.to_node, "")
+            from_pk = node_pk_map.get(llm_rel.from_node, "id")
+            to_pk = node_pk_map.get(llm_rel.to_node, "id")
+
+            # For one-to-many the FK lives in the "from" side's table;
+            # use the target table as the source table name.
+            # Fall back to the from_table when we can't determine better.
+            source_table = to_table or from_table
+
             # Create relationship properties
             rel_properties = []
             for prop_name in llm_rel.properties:
@@ -188,14 +205,14 @@ class LLMGraphModel(BaseModel):
                 )
                 rel_properties.append(rel_prop)
 
-            # Create relationship source
+            # Create relationship source with actual SQL table/column info
             rel_source = RelationshipSource(
-                type="derived",
-                name=f"{llm_rel.from_node}_{llm_rel.name}_{llm_rel.to_node}",
-                location=f"derived.{llm_rel.name}",
+                type="table",
+                name=source_table,
+                location=f"database.schema.{source_table}",
                 mapping={
-                    "start_node": llm_rel.from_node,
-                    "end_node": llm_rel.to_node,
+                    "start_node": f"{from_table}.{from_pk}",
+                    "end_node": f"{to_table}.{to_pk}",
                     "edge_type": llm_rel.name,
                 },
             )

{structured2graph-0.2.0 → structured2graph-0.2.1}/core/hygm/strategies/deterministic.py

@@ -147,17 +147,39 @@ class DeterministicStrategy(BaseModelingStrategy):
             primary_keys = from_table_info.get("primary_keys", [])
             from_pk = primary_keys[0] if primary_keys else f"{from_table}_id"
 
+            # Use the join table name for many-to-many, otherwise the from_table
+            join_table = rel_data.get("join_table", "")
+            source_table = join_table or from_table
+
+            # Build column references
+            if join_table:
+                # Many-to-many: both FK columns live in the join table
+                from_col = rel_data.get("join_from_column", "id")
+                to_col = rel_data.get("join_to_column", "id")
+                start_ref = f"{join_table}.{from_col}"
+                end_ref = f"{join_table}.{to_col}"
+            else:
+                # One-to-many: from_col is in from_table, to_col is in to_table
+                from_col = rel_data.get("from_column", "id")
+                to_col = rel_data.get("to_column", "id")
+                start_ref = f"{from_table}.{from_col}"
+                end_ref = f"{to_table}.{to_col}"
+
             # Create relationship source
+            mapping = {
+                "start_node": start_ref,
+                "end_node": end_ref,
+                "edge_type": rel_name,
+                "from_pk": from_pk,
+            }
+            if join_table:
+                mapping["join_table"] = join_table
+
             rel_source = RelationshipSource(
                 type="table",
-                name=rel_data.get("constraint_name", rel_name),
-                location=f"database.schema.{from_table}",
-                mapping={
-                    "start_node": (f"{from_table}.{rel_data.get('from_column', 'id')}"),
-                    "end_node": (f"{to_table}.{rel_data.get('to_column', 'id')}"),
-                    "edge_type": rel_name,
-                    "from_pk": from_pk,  # Add primary key for migration agent
-                },
+                name=source_table,
+                location=f"database.schema.{source_table}",
+                mapping=mapping,
             )
 
             # Create relationship
@@ -244,19 +266,20 @@ class DeterministicStrategy(BaseModelingStrategy):
 
     def _generate_relationship_name(self, rel_data: Dict[str, Any]) -> str:
         """Generate a semantic relationship name from relationship data."""
+        # For many-to-many, use the join table name directly
+        join_table = rel_data.get("join_table", "")
+        if join_table:
+            return join_table.upper()
+
         constraint_name = rel_data.get("constraint_name", "")
         if constraint_name:
             # Extract meaningful name from constraint
             if "_fk" in constraint_name:
-                join_table = constraint_name.split("_fk")[0]
+                name = constraint_name.split("_fk")[0]
             else:
-                join_table = constraint_name
+                name = constraint_name
+            return name.upper() if name else "CONNECTS"
 
-            if join_table:
-                return join_table.upper()
-            else:
-                return "CONNECTS"
-        else:
-            from_table = rel_data.get("from_table", "")
-            to_table = rel_data.get("to_table", "")
-            return f"{from_table.upper()}_TO_{to_table.upper()}"
+        from_table = rel_data.get("from_table", "")
+        to_table = rel_data.get("to_table", "")
+        return f"{from_table.upper()}_TO_{to_table.upper()}"

{structured2graph-0.2.0 → structured2graph-0.2.1}/database/analyzer.py

@@ -212,21 +212,28 @@ class DatabaseAnalyzer(ABC):
         if len(table_info.foreign_keys) < 2:
             return False
 
-        # Count non-FK columns (excluding common metadata columns)
+        # Count non-FK columns (excluding common metadata / temporal columns
+        # that often appear on join tables as relationship properties)
         non_fk_columns = []
         fk_column_names = {fk.column_name for fk in table_info.foreign_keys}
-        metadata_columns = {
+        auxiliary_columns = {
             "id",
             "created_at",
             "updated_at",
             "created_on",
             "updated_on",
             "timestamp",
+            "from_date",
+            "to_date",
+            "start_date",
+            "end_date",
+            "valid_from",
+            "valid_to",
         }
 
         for col in table_info.columns:
             field_name = col.name.lower()
-            if col.name not in fk_column_names and field_name not in metadata_columns:
+            if col.name not in fk_column_names and field_name not in auxiliary_columns:
                 non_fk_columns.append(col.name)
 
         # If most columns are foreign keys, it's likely a join table
@@ -234,9 +241,9 @@ class DatabaseAnalyzer(ABC):
         fk_ratio = len(table_info.foreign_keys) / total_columns
 
         # Consider it a join table if:
-        # - At least 2 FKs and FK ratio > 0.5, OR
-        # - All columns are FKs or metadata columns
-        return (len(table_info.foreign_keys) >= 2 and fk_ratio > 0.5) or len(
+        # - At least 2 FKs and FK ratio >= 0.5, OR
+        # - All columns are FKs or auxiliary columns
+        return (len(table_info.foreign_keys) >= 2 and fk_ratio >= 0.5) or len(
             non_fk_columns
         ) == 0
 

{structured2graph-0.2.0 → structured2graph-0.2.1}/main.py

@@ -59,6 +59,9 @@ LOG_LEVEL_CHOICES = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "NOTSET"]
 
 PROVIDER_CHOICES = ["openai", "anthropic", "gemini"]
 
+# Sentinel returned by edit_mapping_interactive to signal a reset
+_RESET = object()
+
 
 def _lower_env(name: str) -> Optional[str]:
     value = os.getenv(name)
@@ -783,6 +786,7 @@ def edit_mapping_interactive(
         print("  /edit    - open mapping in " + editor)
         print("  /save    - save and exit")
         print("  /cancel  - discard changes and exit")
+        print("  /reset   - discard mapping and regenerate from scratch")
         print("\nOr describe changes in natural language (sent to LLM), e.g.:")
         print("  Add a Person label node mapped from the people table")
         print("  Rename label Person to User")
@@ -812,6 +816,8 @@ def edit_mapping_interactive(
                         print("Mapping updated from editor.")
                         print_mapping_summary(mapping)
                     _print_editor_banner()
+                elif cmd == "reset":
+                    return _RESET
                 else:
                     print(f"Unknown command: {user_input}")
                 continue
@@ -851,34 +857,14 @@ def edit_mapping_interactive(
     return mapping
 
 
-def generate_mapping(
+def _generate_fresh_mapping(
     agent: SQLToMemgraphAgent,
     source_db_config: Dict[str, Any],
-    mapping_path: str,
-) -> None:
-    """
-    Generate or edit a mapping file.
-
-    If the file already exists it is loaded and the user enters an interactive
-    editing session. Otherwise the source database is analysed and a new
-    mapping is created from scratch.
-    """
-    output = Path(mapping_path)
-
-    # If mapping already exists, load it and enter edit mode
-    if output.exists():
-        with open(output, "r", encoding="utf-8") as f:
-            mapping = json.load(f)
-
-        print(f"📄 Loaded existing mapping from {output}")
-        print_mapping_summary(mapping)
-        edit_mapping_interactive(mapping, agent.llm, mapping_path)
-        return
-
+) -> Dict[str, Any]:
+    """Analyse the source database and return a new mapping dict."""
     from database.factory import DatabaseAnalyzerFactory
     from core.hygm import HyGM
 
-    # 1. Connect and analyse the source database
     print("🔍 Analyzing source database schema...")
     config = source_db_config.copy()
     db_type = config.pop("database_type", "mysql")
@@ -891,7 +877,6 @@ def generate_mapping(
     analyzer.disconnect()
     print(f"  Found {len(hygm_data.get('entity_tables', {}))} entity tables")
 
-    # 2. Build the graph model via HyGM
     print("🎯 Creating graph model...")
     graph_modeler = HyGM(
         llm=agent.llm,
@@ -907,16 +892,48 @@ def generate_mapping(
         f"{len(graph_model.edges)} relationship types"
     )
 
-    # 3. Write mapping file
-    mapping = graph_model_to_mapping(graph_model)
-    output.parent.mkdir(parents=True, exist_ok=True)
-    with open(output, "w", encoding="utf-8") as f:
-        json.dump(mapping, f, indent=2)
-    print(f"\n📄 Mapping file written to {output}")
+    return graph_model_to_mapping(graph_model)
+
+
+def generate_mapping(
+    agent: SQLToMemgraphAgent,
+    source_db_config: Dict[str, Any],
+    mapping_path: str,
+) -> None:
+    """
+    Generate or edit a mapping file.
+
+    If the file already exists it is loaded and the user enters an interactive
+    editing session. Otherwise the source database is analysed and a new
+    mapping is created from scratch. The user can type /reset at any point
+    to discard the mapping and regenerate from the source database.
+    """
+    output = Path(mapping_path)
+
+    if output.exists():
+        with open(output, "r", encoding="utf-8") as f:
+            mapping = json.load(f)
+        print(f"📄 Loaded existing mapping from {output}")
+    else:
+        mapping = _generate_fresh_mapping(agent, source_db_config)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        with open(output, "w", encoding="utf-8") as f:
+            json.dump(mapping, f, indent=2)
+        print(f"\n📄 Mapping file written to {output}")
+
     print_mapping_summary(mapping)
 
-    # 4. Enter interactive editing
-    edit_mapping_interactive(mapping, agent.llm, mapping_path)
+    while True:
+        result = edit_mapping_interactive(mapping, agent.llm, mapping_path)
+        if result is not _RESET:
+            break
+        print("\n🔄 Resetting mapping — regenerating from source database...\n")
+        mapping = _generate_fresh_mapping(agent, source_db_config)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        with open(output, "w", encoding="utf-8") as f:
+            json.dump(mapping, f, indent=2)
+        print(f"\n📄 Mapping file written to {output}")
+        print_mapping_summary(mapping)
 
 
 def main(argv: Optional[list[str]] = None) -> None:

{structured2graph-0.2.0 → structured2graph-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "structured2graph"
-version = "0.2.0"
+version = "0.2.1"
 description = "Database migration agent from structured data (e.g. SQL) to graph."
 readme = "README.md"
 license = "MIT"

structured2graph-0.2.1/skills/publish-dockerhub.md

@@ -0,0 +1,13 @@
+---
+description: Build and publish the structured2graph Docker image to Docker Hub
+user-invocable: true
+---
+
+Read the current version from `pyproject.toml` (the `version` field under `[project]`).
+
+Build and push multi-platform (amd64 + arm64) with both the version tag and `latest`:
+```bash
+docker buildx build --platform linux/amd64,linux/arm64 -t memgraph/structured2graph:<version> -t memgraph/structured2graph:latest --push .
+```
+
+Replace `<version>` with the actual version from `pyproject.toml`.

{structured2graph-0.2.0 → structured2graph-0.2.1}/utils/environment.py

@@ -42,9 +42,34 @@ def _strip_quotes_from_env() -> None:
             os.environ[key] = val[1:-1]
 
 
+def _find_dotenv() -> Optional[str]:
+    """Search well-known locations for a .env file.
+
+    Returns the first path that exists, or None.  The search order is:
+    1. Current working directory
+    2. /app (Docker WORKDIR convention)
+    3. Directory containing this source file (dev checkout)
+    """
+    candidates = [
+        os.path.join(os.getcwd(), ".env"),
+        "/app/.env",
+        os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env"),
+    ]
+    for path in candidates:
+        if os.path.isfile(path):
+            return path
+    return None
+
+
 def load_environment() -> None:
     """Load environment variables from .env file."""
-    load_dotenv()
+    dotenv_path = _find_dotenv()
+    if dotenv_path:
+        logger.info("Loading .env from %s", dotenv_path)
+        load_dotenv(dotenv_path)
+    else:
+        # Fall back to default find_dotenv() behaviour
+        load_dotenv()
     _strip_quotes_from_env()
 
 

{structured2graph-0.2.0 → structured2graph-0.2.1}/uv.lock

@@ -3548,7 +3548,7 @@ wheels = [
 
 [[package]]
 name = "structured2graph"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },