nodeqmindmap 2.2.0__py3-none-any.whl

nodeqmindmap/__init__.py

@@ -0,0 +1,21 @@
+"""nodeqmindmap — Python port of the nodeq-mindmap npm package.
+
+Provides MindMapNode, PipelineEngine, and JsonSchemaAdapter.
+The D3 visualization layer is browser-only; this port covers data modelling and pipeline logic.
+"""
+
+from .types import MindMapNode, DataSample, TransformationRule, PipelinePerformance, PipelineConfig, ExecutionResult, PipelineStats
+from .adapter import JsonSchemaAdapter
+from .pipeline import PipelineEngine
+
+__all__ = [
+    "MindMapNode",
+    "DataSample",
+    "TransformationRule",
+    "PipelinePerformance",
+    "PipelineConfig",
+    "ExecutionResult",
+    "PipelineStats",
+    "JsonSchemaAdapter",
+    "PipelineEngine",
+]

nodeqmindmap/adapter.py

@@ -0,0 +1,79 @@
+"""JsonSchemaAdapter — mirrors json-adapter.ts / JsonSchemaAdapter in index.ts."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .types import MindMapNode
+
+_KNOWN_KEYS = {"topic", "title", "name", "summary", "description", "skills", "children"}
+
+
+class JsonSchemaAdapter:
+    """Converts arbitrary Python dicts/lists into a MindMapNode tree."""
+
+    @staticmethod
+    def convert_to_standard(data: Any) -> MindMapNode:
+        if not isinstance(data, dict):
+            return MindMapNode(topic=str(data) if data is not None else "Invalid Data")
+
+        topic = (
+            data.get("topic")
+            or data.get("title")
+            or data.get("name")
+            or "Root"
+        )
+        summary = data.get("summary") or data.get("description") or ""
+        skills_raw = data.get("skills")
+        skills = [str(s) for s in skills_raw] if isinstance(skills_raw, list) else []
+
+        root = MindMapNode(topic=topic, summary=summary, skills=skills)
+
+        # Explicit children
+        if isinstance(data.get("children"), list):
+            for child in data["children"]:
+                root.children.append(JsonSchemaAdapter.convert_to_standard(child))
+
+        # Remaining keys as child nodes
+        for key, value in data.items():
+            if key in _KNOWN_KEYS:
+                continue
+            if value is None:
+                continue
+            if isinstance(value, dict):
+                root.children.append(
+                    MindMapNode(
+                        topic=key,
+                        children=[JsonSchemaAdapter.convert_to_standard(value)],
+                    )
+                )
+            elif isinstance(value, list):
+                items = value[:20]
+                child = MindMapNode(
+                    topic=key,
+                    summary=f"{len(value)} item(s)",
+                )
+                for i, item in enumerate(items):
+                    if isinstance(item, dict):
+                        child.children.append(
+                            MindMapNode(
+                                topic=f"{key}[{i}]",
+                                children=[JsonSchemaAdapter.convert_to_standard(item)],
+                            )
+                        )
+                    else:
+                        child.children.append(MindMapNode(topic=str(item)))
+                root.children.append(child)
+            else:
+                root.children.append(MindMapNode(topic=f"{key}: {value}"))
+
+        return root
+
+    @staticmethod
+    def extract_schema(data: Any) -> dict[str, str]:
+        """Return a flat field→type mapping from a dict or list-of-dict."""
+        if isinstance(data, list):
+            return JsonSchemaAdapter.extract_schema(data[0]) if data else {}
+        if isinstance(data, dict):
+            return {k: type(v).__name__ for k, v in data.items()}
+        return {}

nodeqmindmap/pipeline.py

@@ -0,0 +1,198 @@
+"""PipelineEngine — mirrors pipeline-engine.ts."""
+
+from __future__ import annotations
+
+import threading
+from datetime import datetime
+from typing import Any
+
+from .types import (
+    DataSample,
+    ExecutionResult,
+    PipelineConfig,
+    PipelinePerformance,
+    PipelineStats,
+    TransformationRule,
+)
+
+
+class PipelineEngine:
+    """Manages in-memory ETL pipelines."""
+
+    def __init__(self) -> None:
+        self._pipelines: dict[str, PipelineConfig] = {}
+        self._next_id = 1
+        self._lock = threading.Lock()
+
+    def create_pipeline(
+        self,
+        name: str,
+        input_sample: DataSample,
+        output_sample: DataSample,
+        options: dict[str, Any] | None = None,
+    ) -> PipelineConfig:
+        options = options or {}
+        with self._lock:
+            pipeline_id = f"pipeline_{self._next_id}"
+            self._next_id += 1
+
+        model_config: dict[str, Any] = options.get("model_config") or {"type": "auto"}
+        data_sources: list[dict[str, Any]] = options.get("data_sources") or []
+        etl_config: dict[str, Any] = options.get("etl_options") or {}
+
+        pipeline = PipelineConfig(
+            id=pipeline_id,
+            name=name,
+            input_sample=input_sample,
+            output_sample=output_sample,
+            transformation_rules=[],
+            model_config=model_config,
+            accuracy=0.85,
+            version="1.0.0",
+            created_at=datetime.now(),
+            data_sources=data_sources,
+            etl_config=etl_config,
+            performance=PipelinePerformance(throughput=100, latency=50, error_rate=0.01),
+        )
+
+        with self._lock:
+            self._pipelines[pipeline_id] = pipeline
+
+        return pipeline
+
+    def update_pipeline(
+        self,
+        pipeline_id: str,
+        input_sample: DataSample | None = None,
+        output_sample: DataSample | None = None,
+    ) -> PipelineConfig:
+        with self._lock:
+            pipeline = self._pipelines.get(pipeline_id)
+        if pipeline is None:
+            raise ValueError(f"Pipeline {pipeline_id} not found")
+        if input_sample is not None:
+            pipeline.input_sample = input_sample
+        if output_sample is not None:
+            pipeline.output_sample = output_sample
+        return pipeline
+
+    def execute_pipeline(self, pipeline_id: str, input_data: Any) -> ExecutionResult:
+        with self._lock:
+            exists = pipeline_id in self._pipelines
+        if not exists:
+            raise ValueError(f"Pipeline {pipeline_id} not found")
+        return ExecutionResult(
+            processed=True,
+            data=input_data,
+            timestamp=datetime.now(),
+            pipeline_id=pipeline_id,
+        )
+
+    def get_pipeline(self, pipeline_id: str) -> PipelineConfig | None:
+        with self._lock:
+            return self._pipelines.get(pipeline_id)
+
+    def get_all_pipelines(self) -> list[PipelineConfig]:
+        with self._lock:
+            return list(self._pipelines.values())
+
+    def get_pipeline_stats(self, pipeline_id: str) -> PipelineStats:
+        with self._lock:
+            pipeline = self._pipelines.get(pipeline_id)
+        if pipeline is None:
+            raise ValueError(f"Pipeline {pipeline_id} not found")
+        return PipelineStats(
+            id=pipeline.id,
+            name=pipeline.name,
+            performance=pipeline.performance,
+            version=pipeline.version,
+            last_executed=datetime.now(),
+        )
+
+    def generate_pipeline_code(self, pipeline_id: str) -> str:
+        with self._lock:
+            pipeline = self._pipelines.get(pipeline_id)
+        if pipeline is None:
+            raise ValueError(f"Pipeline {pipeline_id} not found")
+        fn_name = pipeline.name.replace(" ", "_")
+        return (
+            f"# Generated pipeline code for {pipeline.name}\n"
+            f"def {fn_name}(input_data):\n"
+            f"    # TODO: add transformation logic\n"
+            f"    return input_data\n"
+        )
+
+    def get_pipeline_execution_mode(self, _pipeline_id: str) -> str:
+        return "static"
+
+    def is_pipeline_static(self, _pipeline_id: str) -> bool:
+        return True
+
+    def pipeline_to_mindmap(self, pipeline: PipelineConfig):
+        """Convert a PipelineConfig to a MindMapNode tree (import delayed to avoid circular)."""
+        from .types import MindMapNode
+
+        mode = self.get_pipeline_execution_mode(pipeline.id)
+        is_static = self.is_pipeline_static(pipeline.id)
+        mode_label = "Static compiled execution" if is_static else "Dynamic execution"
+
+        children = [
+            MindMapNode(
+                topic="Execution Mode",
+                summary=mode_label,
+                skills=[f"Mode: {mode.upper()}"],
+            )
+        ]
+
+        if pipeline.data_sources:
+            src_children = []
+            for src in pipeline.data_sources:
+                t = src.get("type", "")
+                conn = src.get("connection", {})
+                label = conn.get("host") or conn.get("apiEndpoint") or "Local"
+                src_children.append(MindMapNode(topic=t, summary=label))
+            children.append(
+                MindMapNode(
+                    topic="Data Sources",
+                    summary=f"{len(pipeline.data_sources)} connected sources",
+                    children=src_children,
+                )
+            )
+
+        children.append(
+            MindMapNode(
+                topic="Input Schema",
+                summary="Data input configuration",
+                skills=list(pipeline.input_sample.schema.keys()),
+            )
+        )
+
+        rule_children = [
+            MindMapNode(
+                topic=f"{r.source_field} → {r.target_field}",
+                summary=f"{r.type} ({int(r.confidence * 100)}%)",
+            )
+            for r in pipeline.transformation_rules
+        ]
+        children.append(
+            MindMapNode(
+                topic="Transformations",
+                summary=f"{len(pipeline.transformation_rules)} rules",
+                children=rule_children,
+            )
+        )
+
+        children.append(
+            MindMapNode(
+                topic="Output Schema",
+                summary="Data output configuration",
+                skills=list(pipeline.output_sample.schema.keys()),
+            )
+        )
+
+        return MindMapNode(
+            topic=pipeline.name,
+            summary=f"ETL Pipeline - Accuracy: {pipeline.accuracy * 100:.1f}%",
+            skills=[f"Version: {pipeline.version}"],
+            children=children,
+        )

nodeqmindmap/types.py

@@ -0,0 +1,82 @@
+"""Type definitions for nodeqmindmap — mirrors types.ts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class MindMapNode:
+    topic: str
+    summary: str = ""
+    skills: list[str] = field(default_factory=list)
+    children: list["MindMapNode"] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"topic": self.topic}
+        if self.summary:
+            d["summary"] = self.summary
+        if self.skills:
+            d["skills"] = self.skills
+        if self.children:
+            d["children"] = [c.to_dict() for c in self.children]
+        return d
+
+
+@dataclass
+class DataSample:
+    format: str
+    schema: dict[str, Any]
+    data: Any
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class TransformationRule:
+    source_field: str
+    target_field: str
+    type: str           # direct | rename | divide | multiply | convert | constant
+    confidence: float   # 0–1
+    factor: float | None = None  # used by divide/multiply rules
+
+
+@dataclass
+class PipelinePerformance:
+    throughput: float = 100.0   # records/sec
+    latency: float = 50.0       # ms
+    error_rate: float = 0.01    # 0–1
+
+
+@dataclass
+class PipelineConfig:
+    id: str
+    name: str
+    input_sample: DataSample
+    output_sample: DataSample
+    transformation_rules: list[TransformationRule]
+    model_config: dict[str, Any]
+    accuracy: float
+    version: str
+    created_at: datetime
+    data_sources: list[dict[str, Any]] = field(default_factory=list)
+    etl_config: dict[str, Any] = field(default_factory=dict)
+    performance: PipelinePerformance = field(default_factory=PipelinePerformance)
+
+
+@dataclass
+class ExecutionResult:
+    processed: bool
+    data: Any
+    timestamp: datetime
+    pipeline_id: str
+
+
+@dataclass
+class PipelineStats:
+    id: str
+    name: str
+    performance: PipelinePerformance
+    version: str
+    last_executed: datetime

nodeqmindmap-2.2.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: nodeqmindmap
+Version: 2.2.0
+Summary: Python port of nodeq-mindmap: MindMapNode data model and ETL pipeline engine
+License: MIT
+Project-URL: Homepage, https://github.com/workflow-builder/nodeq-mindmap
+Keywords: mindmap,etl,pipeline,visualization,career-map
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# nodeq-mindmap
+
+[![npm version](https://badge.fury.io/js/nodeq-mindmap.svg)](https://badge.fury.io/js/nodeq-mindmap)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Interactive D3.js mind map visualization library with a built-in ETL pipeline engine. Render career maps, org charts, or any hierarchical JSON data in the browser, and define data transformation pipelines in code.
+
+## Features
+
+- **Universal JSON rendering** — any JSON object is automatically converted to a mind map
+- **Interactive** — click to expand/collapse nodes, zoom, pan
+- **Themeable** — control colors, font, node size
+- **Framework agnostic** — works with React, Vue, Angular, or vanilla JS
+- **ETL pipeline engine** — define input/output schemas, track transformation rules, and execute pipelines in memory
+- **Pipeline visualization** — render an active pipeline as a mind map to explore its structure
+- **CLI** — generate SVG files from JSON on the command line (headless via jsdom)
+
+## Installation
+
+```bash
+npm install nodeq-mindmap
+```
+
+D3 v7 is a peer dependency:
+
+```bash
+npm install d3
+```
+
+## Quick Start
+
+### Browser / bundler
+
+```javascript
+import { NodeQMindMap } from 'nodeq-mindmap';
+
+const map = new NodeQMindMap({
+  container: '#my-container',   // CSS selector or HTMLElement
+  data: {
+    topic: 'Software Engineer',
+    children: [
+      { topic: 'Frontend', skills: ['React', 'TypeScript'] },
+      { topic: 'Backend',  skills: ['Node.js', 'PostgreSQL'] },
+    ]
+  },
+  width: 900,
+  height: 600,
+  onNodeClick: (node) => console.log(node.topic),
+});
+
+map.render();
+```
+
+### Any JSON shape
+
+`JsonSchemaAdapter.convertToStandard()` converts arbitrary JSON into the `MindMapNode` tree format before rendering:
+
+```javascript
+import { NodeQMindMap, JsonSchemaAdapter } from 'nodeq-mindmap';
+
+const raw = { name: 'My API', version: '2.0', routes: ['/users', '/posts'] };
+const data = JsonSchemaAdapter.convertToStandard(raw);
+
+new NodeQMindMap({ container: '#root', data }).render();
+```
+
+## API
+
+### `new NodeQMindMap(config)`
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `container` | `string \| HTMLElement` | required | CSS selector or DOM element |
+| `data` | `any` | required | Hierarchical data (see `MindMapNode`) |
+| `width` | `number` | `800` | SVG width in px |
+| `height` | `number` | `600` | SVG height in px |
+| `theme` | `Partial<Theme>` | — | Colors, font, fontSize |
+| `interactive` | `boolean` | `true` | Enable click/hover |
+| `zoomable` | `boolean` | `true` | Enable pan/zoom |
+| `collapsible` | `boolean` | `true` | Click nodes to collapse |
+| `onNodeClick` | `(node) => void` | — | Click callback |
+| `onNodeHover` | `(node) => void` | — | Hover callback |
+
+### Instance methods
+
+```typescript
+map.render()                    // Draw the mind map
+map.updateData(data)            // Replace data and re-render
+map.updateTheme(theme)          // Merge theme and re-render
+map.exportSVG()                 // Return SVG markup string
+map.destroy()                   // Remove SVG from DOM
+
+// Pipeline helpers
+await map.createDataPipeline(name, inputSample, outputSample, options?)
+map.executePipeline(inputData)
+map.getAllPipelines()
+map.switchToPipeline(pipelineId)
+```
+
+### `MindMapNode` shape
+
+```typescript
+interface MindMapNode {
+  topic: string;          // Node label (required)
+  summary?: string;       // Subtitle shown in detail panels
+  skills?: string[];      // Tag list
+  children?: MindMapNode[];
+}
+```
+
+### `Theme` options
+
+```typescript
+{
+  nodeColor: string;       // default '#4299e1'
+  textColor: string;       // default '#2d3748'
+  linkColor: string;       // default '#a0aec0'
+  backgroundColor: string; // default '#ffffff'
+  fontSize: number;        // default 14
+  fontFamily: string;      // default 'Arial, sans-serif'
+}
+```
+
+## Pipeline Engine
+
+`PipelineEngine` is a standalone class for defining and running in-memory ETL pipelines. It does not require a browser.
+
+```javascript
+import { PipelineEngine } from 'nodeq-mindmap';
+
+const engine = new PipelineEngine();
+
+const pipeline = await engine.createPipeline(
+  'User ETL',
+  { format: 'json', schema: { id: 'number', name: 'string' }, data: { id: 1, name: 'Alice' } },
+  { format: 'json', schema: { userId: 'number', displayName: 'string' }, data: { userId: 1, displayName: 'Alice' } }
+);
+
+const result = engine.executePipeline(pipeline.id, { id: 2, name: 'Bob' });
+// { processed: true, data: { id: 2, name: 'Bob' }, timestamp, pipelineId }
+
+console.log(engine.generatePipelineCode(pipeline.id));
+// Outputs a TypeScript function stub for the pipeline
+```
+
+### `PipelineEngine` methods
+
+```typescript
+createPipeline(name, inputSample, outputSample, options?)  // async, returns PipelineConfig
+updatePipeline(id, inputSample?, outputSample?)            // async
+executePipeline(id, inputData)                             // sync, returns result object
+getPipeline(id)                                            // returns PipelineConfig | undefined
+getAllPipelines()                                           // returns PipelineConfig[]
+getPipelineStats(id)                                       // returns perf stats
+generatePipelineCode(id)                                   // returns TS function stub
+```
+
+## CLI
+
+```bash
+# Generate an SVG mind map from a JSON file
+npx nodeq-mindmap generate -i data.json -o output.svg
+
+# Create a pipeline definition from input/output samples
+npx nodeq-mindmap create-pipeline -n "My ETL" -i input.json -o output.json
+```
+
+The `generate` command uses jsdom to run D3 headlessly — no browser required.
+
+## Ports
+
+Server-side / language-specific ports of the data model and pipeline engine are available:
+
+- **Go** — `packages/go/` — `MindMapNode`, `PipelineEngine`, `JsonSchemaAdapter` as a Go module
+- **Python** — `packages/python/` — `MindMapNode`, `PipelineEngine`, `JsonSchemaAdapter` as Python dataclasses
+
+These ports implement the same data structures and pipeline logic without the D3 visualization layer.
+
+## License
+
+MIT

nodeqmindmap-2.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+nodeqmindmap/__init__.py,sha256=5pA9aS78LWVg15i-6quvlmlERkicjw1qU9D3voOKOHc,655
+nodeqmindmap/adapter.py,sha256=iF0YAektF6PEewIcP4QysAC4wrw3DYMGWDqxHG9CU9g,2891
+nodeqmindmap/pipeline.py,sha256=RKWENf3T9jix9NxfY153jATUdPa9jxycziTKGtCSF24,6551
+nodeqmindmap/types.py,sha256=-pVhHui5w-xuEygR6hTQLArVgH8f3PapEiqtgrGw3RQ,2013
+nodeqmindmap-2.2.0.dist-info/METADATA,sha256=oWe4nQ1OjYIsvq7NNit74rCDrNro1jKC-1MS1iOm0YI,6426
+nodeqmindmap-2.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nodeqmindmap-2.2.0.dist-info/top_level.txt,sha256=RJ63Cza9EOgvGXojlNqLCjsr2UENA6fykEGwVnLRf7U,13
+nodeqmindmap-2.2.0.dist-info/RECORD,,

nodeqmindmap-2.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nodeqmindmap-2.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nodeqmindmap