freeplane-and-yaml 0.1.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

freeplane_and_yaml/__init__.py

@@ -0,0 +1,10 @@
+from .convert import convert_yaml_file, converter
+from .llm_adapter import LLMAdapter
+from .text_to_mindmap import TextToMindMap
+
+__all__ = [
+    "convert_yaml_file", 
+    "converter",
+    "LLMAdapter",
+    "TextToMindMap",
+]

freeplane_and_yaml/cli.py

@@ -1,6 +1,6 @@
 import sys
 import os
-from .convert import convert_yaml_file  # Import your conversion logic
+from   freeplane_and_yaml.convert import convert_yaml_file  # Import your conversion logic
 
 
 def main():
@@ -31,10 +31,13 @@ def main():
     base_name = os.path.basename(input_file).replace(".yaml", ".mm")
     output_file = os.path.join(output_dir, base_name)
 
-    # Perform the conversion
+    # Perform the conversio
     try:
         convert_yaml_file(input_file, output_file)
         print(f"Conversion complete: {output_file}")
     except Exception as e:
         print(f"Error during conversion: {e}")
         sys.exit(1)
+
+if __name__ == "__main__":
+    main()

freeplane_and_yaml/convert_pdf_to_mindmap.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import tempfile
+import pymupdf4llm
+from .text_to_mindmap import TextToMindMap
+from .openai_adapter import OpenAIAdapter
+
+def convert_pdf_to_mindmap(base_name, input_file, mm_output, model, text_output, yaml_output):
+    # Step 1: Extract text from the PDF
+    print(f"Extracting text from {input_file}...")
+    # Ensure the file exists
+    if not os.path.isfile(input_file):
+        raise FileNotFoundError(f"PDF file not found: {input_file}")
+    # Extract text using PyMuPDF4LLM directly
+    extracted_text = pymupdf4llm.to_markdown(input_file)
+    # Save the extracted text if requested
+    if text_output:
+        with open(text_output, 'w', encoding='utf-8') as f:
+            f.write(extracted_text)
+        print(f"Saved extracted text to: {text_output}")
+    # If the text is empty, report an error
+    if not extracted_text.strip():
+        print("Error: No text could be extracted from the PDF", file=sys.stderr)
+        sys.exit(1)
+    # Step 2: Create the OpenAI adapter
+    # Create the adapter with specified model or default
+    adapter = OpenAIAdapter(model=model)
+    # Step 3: Create a temporary text file for the extracted content
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+        temp_file.write(extracted_text)
+        temp_file_path = temp_file.name
+    try:
+        # Step 4: Process the text with the text-to-mindmap service
+        print("Converting extracted text to mind map format...")
+        service = TextToMindMap(adapter)
+
+        # First try to get the YAML directly to inspect it
+        with open(temp_file_path, 'r', encoding='utf-8') as f:
+            text_content = f.read()
+
+        # Limit the text size to avoid timeouts
+        MAX_CHARS = 40000  # Large documents may cause timeouts
+        if len(text_content) > MAX_CHARS:
+            print(f"Document is large ({len(text_content)} chars). Truncating to {MAX_CHARS} chars to avoid timeouts.")
+            text_content = text_content[:MAX_CHARS] + "\n\n[Content truncated due to length...]"
+
+        try:
+            print(f"Sending document for processing...")
+            yaml_content = adapter.generate_mind_map_yaml(text_content)
+
+            # Save raw output for debugging
+            output_dir = os.path.dirname(mm_output)
+            debug_yaml_path = os.path.join(output_dir, f"{base_name}.raw.yaml")
+            with open(debug_yaml_path, 'w', encoding='utf-8') as f:
+                f.write(yaml_content)
+            print(f"Saved raw YAML for debugging to: {debug_yaml_path}")
+
+            # Now continue with the regular process
+            service.convert_text_file(temp_file_path, yaml_output, mm_output)
+        except Exception as e:
+            print(f"YAML conversion error: {e}")
+            print("Saving debug information and continuing...")
+            # Continue with original code path anyway
+            service.convert_text_file(temp_file_path, yaml_output, mm_output)
+
+        print("\nConversion successful!")
+        print(f"YAML output: {yaml_output}")
+        print(f"Mind map: {mm_output}")
+        if text_output:
+            print(f"Text output: {text_output}")
+
+    finally:
+        # Clean up the temporary file
+        if os.path.exists(temp_file_path):
+            os.unlink(temp_file_path)

freeplane_and_yaml/llm_adapter.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+import os
+
+# Default schema path - using a path that works both in development and when installed
+# First try the package-relative path (for installed package)
+DEFAULT_SCHEMA_PATH = os.path.join(os.path.dirname(__file__), 'schema', 'mindmap-schema.json')
+
+# If that doesn't exist, try the development path
+if not os.path.exists(DEFAULT_SCHEMA_PATH):
+    DEFAULT_SCHEMA_PATH = os.path.abspath(
+        os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+            "src", "schema", "mindmap-schema.json"
+        )
+    )
+
+
+class LLMAdapter(ABC):
+    """
+    Abstract base class for LLM adapters.
+    This follows the hexagonal architecture pattern to isolate the LLM service from our core logic.
+    """
+    
+    @abstractmethod
+    def generate_mind_map_yaml(self, text: str) -> str:
+        """
+        Generate a mind map in YAML format from the provided text,
+        following the schema defined in DEFAULT_SCHEMA_PATH.
+        
+        Args:
+            text: The text content to convert to a mind map
+            
+        Returns:
+            A string containing the YAML representation of the mind map
+        """
+        pass

freeplane_and_yaml/openai_adapter.py

@@ -0,0 +1,110 @@
+import os
+from openai import OpenAI
+from typing import Dict, Any
+from dotenv import load_dotenv
+from .llm_adapter import LLMAdapter, DEFAULT_SCHEMA_PATH
+from .yaml_utils import extract_yaml_from_markdown
+
+# Load environment variables from .env file
+load_dotenv()
+
+class OpenAIAdapter(LLMAdapter):
+    """
+    Adapter for OpenAI API.
+    
+    This class provides an implementation of the LLMAdapter for OpenAI models.
+    It makes API calls to OpenAI to generate mind maps from text.
+    """
+    
+    DEFAULT_MODEL = "gpt-4o"  # Default OpenAI model to use
+    
+    def __init__(self, api_key: str = None, model: str = None):
+        """
+        Initialize the adapter with API credentials.
+        
+        Args:
+            api_key: OpenAI API key, defaults to reading from OPENAI_API_KEY environment variable
+            model: OpenAI model to use, defaults to DEFAULT_MODEL
+        """
+        self.api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "No API key provided. Pass an API key to the constructor or "
+                "set the OPENAI_API_KEY environment variable in the .env file."
+            )
+        
+        self.model = model or self.DEFAULT_MODEL
+        self.client = OpenAI(api_key=self.api_key)
+            
+    def generate_mind_map_yaml(self, text: str) -> str:
+        """
+        Generate a mind map in YAML format using OpenAI.
+        
+        Args:
+            text: The text content to convert to a mind map
+            
+        Returns:
+            A string containing the YAML representation of the mind map
+        """
+        # Read the schema content
+        with open(DEFAULT_SCHEMA_PATH, 'r') as f:
+            schema = f.read()
+            
+        # Make the API call to OpenAI
+        yaml_content = self._call_openai_api(text, schema)
+        
+        return yaml_content
+    
+    def _call_openai_api(self, text: str, schema: str) -> str:
+        """
+        Call the OpenAI API with the text and schema.
+        
+        Args:
+            text: The text content to convert to a mind map
+            schema: The JSON schema content
+            
+        Returns:
+            The generated YAML content
+        """
+        try:
+            # Build system prompt and user prompt
+            system_prompt = "You are an expert at creating structured mind maps in YAML format. Your task is to organize the provided text into a hierarchical structure that follows the schema exactly. Every node must include both a title and a descriptive note providing context or details for that node. Only output valid YAML without any explanations, markdown code blocks, or extra text."
+            
+            user_prompt = f"""I'd like you to summarise a document as a yaml file following a schema.
+
+Please respond with ONLY the YAML content that follows the schema, without any additional text or explanations.
+The YAML should have a root node with an appropriate title and organized children nodes that capture
+the key points and structure of the text. Aim to have one node per 20 lines of input text.
+
+IMPORTANT: Every node (including the root and ALL child nodes) should include both a title AND a note. 
+The note should provide additional context, explanation, or details about that specific node.
+
+Here is the schema to follow:
+
+{schema}
+
+Here is the document to summarize:
+
+{text}"""
+
+            # Call the OpenAI API using the new client interface
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=16000,  # Maximum allowed for this model
+                temperature=0.2,  # Low temperature for more deterministic output
+            )
+            
+            # Extract the response content
+            content = response.choices[0].message.content
+            
+            # Use the utility function to extract YAML from markdown
+            content = extract_yaml_from_markdown(content)
+                
+            return content
+            
+        except Exception as e:
+            raise RuntimeError(f"Error calling OpenAI API: {str(e)}") from e

freeplane_and_yaml/pdf2mindmap.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Convert PDF files to mind maps using PyMuPDF4LLM and AI.
+"""
+
+import os
+import sys
+import argparse
+import tempfile
+import pymupdf4llm
+from dotenv import load_dotenv
+
+from freeplane_and_yaml.convert_pdf_to_mindmap import convert_pdf_to_mindmap
+from .text_to_mindmap import TextToMindMap
+from .openai_adapter import OpenAIAdapter
+
+# Load environment variables
+load_dotenv()
+
+
+def main():
+    """Main entry point for the pdf2mindmap command-line tool."""
+    parser = argparse.ArgumentParser(
+        description="Convert a PDF file to a mind map using PyMuPDF4LLM and OpenAI"
+    )
+    parser.add_argument(
+        "input_file", 
+        help="Path to the input PDF file"
+    )
+    parser.add_argument(
+        "output_dir", 
+        help="Directory to save the output files"
+    )
+    parser.add_argument(
+        "--model", 
+        help="OpenAI model to use (defaults to gpt-4o)"
+    )
+    parser.add_argument(
+        "--save-text",
+        action="store_true",
+        help="Save the extracted text to a file"
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate input file
+    if not os.path.isfile(args.input_file):
+        print(f"Error: Input PDF file '{args.input_file}' does not exist", file=sys.stderr)
+        sys.exit(1)
+        
+    # Make sure it's a PDF file
+    if not args.input_file.lower().endswith('.pdf'):
+        print(f"Error: Input file must be a PDF file: {args.input_file}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Validate output directory
+    if not os.path.isdir(args.output_dir):
+        try:
+            os.makedirs(args.output_dir, exist_ok=True)
+            print(f"Created output directory: {args.output_dir}")
+        except Exception as e:
+            print(f"Error: Could not create output directory '{args.output_dir}': {e}", file=sys.stderr)
+            sys.exit(1)
+    input_file = args.input_file
+    output_dir = args.output_dir
+    save_text = args.save_text
+    # Generate output file paths
+    base_name = os.path.splitext(os.path.basename(input_file))[0]
+    yaml_output = os.path.join(output_dir, f"{base_name}.yaml")
+    mm_output = os.path.join(output_dir, f"{base_name}.mm")
+    text_output = os.path.join(output_dir, f"{base_name}.txt") if save_text else None
+    model = args.model
+    
+    try:
+        convert_pdf_to_mindmap(base_name, input_file, mm_output, model, text_output, yaml_output)
+
+    except Exception as e:
+        print(f"Error during conversion: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+
+
+if __name__ == "__main__":
+    main()

freeplane_and_yaml/schema/mindmap-schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Mind Map Schema",
+  "description": "Schema for Freeplane-compatible mind map YAML format",
+  
+  "definitions": {
+    "node": {
+      "type": "object",
+      "required": ["title"],
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "The display text for the node"
+        },
+        "note": {
+          "type": "string",
+          "description": "Rich text note attached to the node"
+        },
+        "children": {
+          "type": "object",
+          "description": "Child nodes of this node",
+          "patternProperties": {
+            "^[a-zA-Z0-9_]+$": {
+              "$ref": "#/definitions/node"
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+
+  "type": "object",
+  "required": ["root"],
+  "properties": {
+    "root": {
+      "allOf": [
+        { "$ref": "#/definitions/node" },
+        { 
+          "required": ["children"],
+          "description": "The root node must have at least one child"
+        }
+      ]
+    }
+  },
+  "additionalProperties": false,
+
+  "examples": [
+    {
+      "root": {
+        "title": "Example Mind Map",
+        "note": "This is the root node",
+        "children": {
+          "topic1": {
+            "title": "First Topic",
+            "note": "Note for first topic",
+            "children": {
+              "subtopic1": {
+                "title": "Subtopic 1",
+                "note": "Note for subtopic"
+              }
+            }
+          },
+          "topic2": {
+            "title": "Second Topic",
+            "note": "Note for second topic"
+          }
+        }
+      }
+    }
+  ]
+}

freeplane_and_yaml/text_to_mindmap.py

@@ -0,0 +1,54 @@
+import os
+from typing import Optional
+from .llm_adapter import LLMAdapter
+from .convert import converter
+
+
+class TextToMindMap:
+    """
+    Service for converting text files to mind maps via LLM-generated YAML.
+    
+    This class follows the hexagonal architecture pattern, with the LLM adapter
+    injected through the constructor, allowing for easy testing and flexibility
+    in switching between different LLM providers.
+    """
+    
+    def __init__(self, llm_adapter: LLMAdapter):
+        """
+        Initialize the service with an LLM adapter.
+        
+        Args:
+            llm_adapter: An implementation of LLMAdapter
+        """
+        self.llm_adapter = llm_adapter
+            
+    def convert_text_file(self, input_file_path: str, output_yaml_path: str, output_mm_path: str = None) -> str:
+        """
+        Convert a text file to a mind map.
+        
+        Args:
+            input_file_path: Path to the text file to convert
+            output_yaml_path: Path where the YAML file should be saved
+            output_mm_path: Optional path where the Freeplane .mm file should be saved
+            
+        Returns:
+            The YAML content generated from the text
+        """
+        # Read the text file
+        with open(input_file_path, 'r', encoding='utf-8') as f:
+            text_content = f.read()
+            
+        # Convert text to YAML using the adapter
+        yaml_content = self.llm_adapter.generate_mind_map_yaml(text_content)
+        
+        # Save the YAML output
+        with open(output_yaml_path, 'w', encoding='utf-8') as f:
+            f.write(yaml_content)
+            
+        # Optionally convert to Freeplane .mm format
+        if output_mm_path:
+            mm_content = converter(yaml_content)
+            with open(output_mm_path, 'w', encoding='utf-8') as f:
+                f.write(mm_content)
+                
+        return yaml_content

freeplane_and_yaml/yaml_utils.py

@@ -0,0 +1,26 @@
+"""
+Utility functions for YAML handling.
+"""
+
+def extract_yaml_from_markdown(content):
+    """
+    Extract YAML content from markdown-formatted text.
+    
+    Args:
+        content: The markdown text containing YAML code blocks
+        
+    Returns:
+        The extracted YAML content
+    """
+    # Remove any initial text before the YAML content
+    if "```yaml" in content:
+        content = content.split("```yaml", 1)[1]
+        if "```" in content:
+            content = content.split("```", 1)[0]
+    elif "```" in content:
+        content = content.split("```", 1)[1]
+        if "```" in content:
+            content = content.split("```", 1)[0]
+            
+    # Clean up and return
+    return content.strip()

freeplane_and_yaml-0.3.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.1
+Name: freeplane-and-yaml
+Version: 0.3.0
+Summary: A tool to convert PDF files to Freeplane mind maps using OpenAI
+Home-page: https://github.com/romilly/freeplane-and-yaml
+Author: Romilly Cocking
+Author-email: romilly.cocking@gmail.com
+License: MIT
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML
+Requires-Dist: openai
+Requires-Dist: pymupdf4llm
+Requires-Dist: python-dotenv
+
+# PDF to Freeplane Mind Map Converter
+
+A Python tool that converts PDF documents into Freeplane mind maps using OpenAI. This allows you to automatically generate structured mind maps from PDF documents.
+
+You can read about how it got written using AI on [medium](https://medium.com/@romillyc/build-your-own-mind-map-tools-with-ai-b193564f2464?sk=b353aa7d16d6412e4aae8f3eab0ec554).
+That's a _friend link_ so you can read it even if you're not a subscriber.
+
+## Installation
+
+This project requires Python and should be run in a virtual environment:
+
+```bash
+# Create and activate virtual environment in the directory of your choice
+python -m venv venv
+source venv/bin/activate  # On Windows use: venv\Scripts\activate
+pip install freeplane-and-yaml
+```
+
+You'll need to set up your OpenAI API key in a `.env` file or as an environment variable:
+
+```bash
+# Create a .env file in your project directory
+echo "OPENAI_API_KEY=your_api_key_here" > .env
+```
+
+
+## Usage
+
+### Converting PDF Documents to Mind Maps
+
+To convert a PDF document to a Freeplane mind map:
+
+```bash
+# Convert a PDF file to a mind map
+pdf2mindmap path/to/document.pdf output_directory
+
+# Use a specific OpenAI model (default is gpt-4o-mini)
+pdf2mindmap path/to/document.pdf output_directory --model gpt-4-turbo
+
+# Also save the extracted text
+pdf2mindmap path/to/document.pdf output_directory --save-text
+```
+
+The tool performs these steps:
+1. Extracts text from the PDF using PyMuPDF4LLM (preserving structure as markdown)
+2. Processes the text with OpenAI to generate a structured mind map in YAML format
+3. Converts the YAML to a Freeplane mind map (.mm file)
+4. Saves all files in the output directory
+
+This is useful for:
+- Summarizing academic papers
+- Converting product requirements documents (PRDs)
+- Creating structured summaries of technical documentation
+- Organizing research notes or book content
+
+
+The generated `.mm` file can be opened in Freeplane. When you first open the file, Freeplane will show this warning dialog because the file wasn't created by Freeplane itself:
+
+![Freeplane Warning Dialog](images/warning-dialog.png)
+
+This is normal and expected — click OK to load the mind map.
+
+Here's an example of how the output looks:
+
+![Example Mind Map](images/Screenshot%20at%202025-02-12%2010-43-23.png)
+
+## Features
+
+- Converts PDF documents to Freeplane mind maps using OpenAI
+- Uses PyMuPDF4LLM for high-quality text extraction from PDFs
+- Creates hierarchical mind maps with node titles and notes
+- Automatically alternates between right and left positions for top-level nodes
+- Generates unique IDs for each node
+- Produces clean, well-structured YAML as an intermediate format
+- Supports different OpenAI models (default is gpt-4o-mini)
+
+## License
+
+_Apologies to readers from the USA. This README uses UK spelling._
+
+This project is licensed under the MIT Licence — see the [LICENCE](LICENSE) file for details.
+
+

freeplane_and_yaml-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+freeplane_and_yaml/__init__.py,sha256=x8BtsOuvatRJqbtZkqU93yf-h4OQJK2tkvi3WnIB5YM,226
+freeplane_and_yaml/cli.py,sha256=ETgW_67QglX7QhDJ4NQANiV134_V4vT3I70o--zwFNw,1271
+freeplane_and_yaml/convert.py,sha256=dyQLt2FlmCgsQOnutnp1DyLXzqk-guazL8TZwTH0vHI,3440
+freeplane_and_yaml/convert_pdf_to_mindmap.py,sha256=TR620sdvw9-4jKIeoK0eQko3kAD9LPH83TKndKJHYY4,3294
+freeplane_and_yaml/llm_adapter.py,sha256=Sd-ibim34Nunj1A45i4om0JkwhldjC_eFvkX1jhDhPg,1250
+freeplane_and_yaml/openai_adapter.py,sha256=1RKv_6Hb_9s9xqvLq3Vmu4g9We2vdbY8YfcTqiMuOLA,4312
+freeplane_and_yaml/pdf2mindmap.py,sha256=17WnRxP_w5eqI40IX7y9JIRsQEONGNrSm00PQKok7uA,2543
+freeplane_and_yaml/text_to_mindmap.py,sha256=f46jQFAvOb4u1tKRSROGdFAyqG62Smww-mBWS1ke1fM,1898
+freeplane_and_yaml/yaml_utils.py,sha256=W_K3kstknOFibZbMDnkxuTqVQO1hKGfNBOLLa9_GErM,718
+freeplane_and_yaml/schema/mindmap-schema.json,sha256=vCFcGjWcZTeTNozGChsRjEw-jYsYDiPxr-qVML8M_XE,1734
+freeplane_and_yaml-0.3.0.dist-info/LICENSE,sha256=gCmvBRHqGZibjt4wyMG81SeYWMKuhoGFVQh_Kn1wZ98,1072
+freeplane_and_yaml-0.3.0.dist-info/METADATA,sha256=ZV85Aw2fyntEKziT2E-RjvzV6PcTG99Afaz4oW2XQCw,3527
+freeplane_and_yaml-0.3.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+freeplane_and_yaml-0.3.0.dist-info/entry_points.txt,sha256=-k40S1cR7VRZViC202mFFI2OsUxmPPBzBiRh0wsMmHE,69
+freeplane_and_yaml-0.3.0.dist-info/top_level.txt,sha256=UY6T4vy985r4DAfWpM1D_n6t0cEis5SxtfkPPd-xDhQ,19
+freeplane_and_yaml-0.3.0.dist-info/RECORD,,

freeplane_and_yaml-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pdf2mindmap = freeplane_and_yaml.pdf2mindmap:main
+

freeplane_and_yaml-0.1.4.dist-info/METADATA

@@ -1,187 +0,0 @@
-Metadata-Version: 2.1
-Name: freeplane-and-yaml
-Version: 0.1.4
-Summary: A tool to convert YAML files to Freeplane MM format
-Home-page: https://github.com/romilly/freeplane-and-yaml
-Author: Romilly Cocking
-Author-email: romilly.cocking@gmail.com
-License: MIT
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: PyYAML
-
-# YAML to Freeplane Converter
-
-A Python tool that converts YAML files into Freeplane mind maps. This allows you to generate mind maps programmatically from structured YAML data.
-
-The YAML file can be created using [Claude AI](https://claude.ai/chat/). 
-A suitable prompt is given [below](https://github.com/romilly/freeplane-and-yaml?tab=readme-ov-file#converting-documents-to-yaml-using-claude-ai).
-
-You can read about how it got written using AI on [medium](https://medium.com/@romillyc/build-your-own-mind-map-tools-with-ai-b193564f2464?sk=b353aa7d16d6412e4aae8f3eab0ec554).
-That's a _friend link_ so you can read it even if you're not a subscriber.
-
-## Installation
-
-This project requires Python and should be run in a virtual environment:
-
-```bash
-# Create and activate virtual environment in the direcoty of your choice
-python -m venv venv
-source venv/bin/activate  # On Windows use: venv\Scripts\activate
-pip install freeplane-and-yaml
-```
-
-
-## Usage
-
-Your YAML file should follow this [schema](https://raw.githubusercontent.com/romilly/freeplane-and-yaml/refs/heads/main/src/schema/mindmap-schema.json). It includes an example.
-
-```json
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Mind Map Schema",
-  "description": "Schema for Freeplane-compatible mind map YAML format",
-  
-  "definitions": {
-    "node": {
-      "type": "object",
-      "required": ["title"],
-      "properties": {
-        "title": {
-          "type": "string",
-          "description": "The display text for the node"
-        },
-        "note": {
-          "type": "string",
-          "description": "Rich text note attached to the node"
-        },
-        "children": {
-          "type": "object",
-          "description": "Child nodes of this node",
-          "patternProperties": {
-            "^[a-zA-Z0-9_]+$": {
-              "$ref": "#/definitions/node"
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "additionalProperties": false
-    }
-  },
-
-  "type": "object",
-  "required": ["root"],
-  "properties": {
-    "root": {
-      "allOf": [
-        { "$ref": "#/definitions/node" },
-        { 
-          "required": ["children"],
-          "description": "The root node must have at least one child"
-        }
-      ]
-    }
-  },
-  "additionalProperties": false,
-
-  "examples": [
-    {
-      "root": {
-        "title": "Example Mind Map",
-        "note": "This is the root node",
-        "children": {
-          "topic1": {
-            "title": "First Topic",
-            "note": "Note for first topic",
-            "children": {
-              "subtopic1": {
-                "title": "Subtopic 1",
-                "note": "Note for subtopic"
-              }
-            }
-          },
-          "topic2": {
-            "title": "Second Topic",
-            "note": "Note for second topic"
-          }
-        }
-      }
-    }
-  ]
-}
-
-```
-
-### Converting YAML to Mind Map
-
-To convert a YAML file to a Freeplane mind map:
-
-```bash
-
-# Convert YAML and store mind map in temp
-convert data/marr.yaml temp
-```
-
-### YAML Schema requirements explained
-
-As the schema specifies, The YAML must conform to these rules:
-- Must have a root node with a title and at least one child
-- Each node requires a title
-- Notes are optional
-- Child node keys must be alphanumeric (including underscores)
-- No additional properties are allowed beyond title, note, and children
-
-For full schema details, see above.
-
-### Converting Documents to YAML using Claude AI
-
-You can use Claude Sonnet to automatically convert documents (PDFs, articles, specifications, etc.) into the required YAML format. Here's the workflow:
-
-1. Share your document and the schema (above) with Claude Sonnet.
-2. Use this prompt:
-   ```
-   I've uploaded a document and a schema file.  I'd like you to summarise the document as a yaml file following the schema that I uploaded.
-   ```
-3. Claude will generate a YAML file that follows the schema
-4. Save Claude's output as a .yaml file
-5. Convert it to a mind map using this tool
-
-This workflow is useful for:
-- Summarizing academic papers
-- Converting product requirements documents (PRDs)
-- Creating structured summaries of technical documentation
-- Organizing research notes
-
-
-The generated `.mm` file can be opened in Freeplane. When you first open the file, Freeplane will show this warning dialog because the file wasn't created by Freeplane itself:
-
-![Freeplane Warning Dialog](images/warning-dialog.png)
-
-This is normal and expected — click OK to load the mind map.
-
-Here's an example of how the output looks:
-
-![Example Mind Map](images/Screenshot%20at%202025-02-12%2010-43-23.png)
-
-## Features
-
-- Converts YAML structured data to Freeplane mind map format
-- Supports hierarchical node structure
-- Includes node titles and optional notes
-- Automatically alternates between right and left positions for top-level nodes
-- Generates unique IDs for each node
-- Validates input against JSON schema
-
-## License
-
-_Apologies to readers from the USA. This README uses UK spelling._
-
-This project is licensed under the MIT Licence — see the [LICENCE](LICENSE) file for details.
-
-

freeplane_and_yaml-0.1.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-freeplane_and_yaml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-freeplane_and_yaml/cli.py,sha256=qeUJXw2MqCf6Kv7c-K63-srGj339beL4JTrAXi5_-3c,1213
-freeplane_and_yaml/convert.py,sha256=dyQLt2FlmCgsQOnutnp1DyLXzqk-guazL8TZwTH0vHI,3440
-freeplane_and_yaml-0.1.4.dist-info/LICENSE,sha256=gCmvBRHqGZibjt4wyMG81SeYWMKuhoGFVQh_Kn1wZ98,1072
-freeplane_and_yaml-0.1.4.dist-info/METADATA,sha256=BVBe-V68MU9x5nvP1OZQD5cZHcjZqXgOtpZrOG7_7l4,5656
-freeplane_and_yaml-0.1.4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-freeplane_and_yaml-0.1.4.dist-info/entry_points.txt,sha256=kWuCk_RZlzcO9h7yk7uJ4dtJiccQxBocEuQPVt6qzxo,57
-freeplane_and_yaml-0.1.4.dist-info/top_level.txt,sha256=UY6T4vy985r4DAfWpM1D_n6t0cEis5SxtfkPPd-xDhQ,19
-freeplane_and_yaml-0.1.4.dist-info/RECORD,,

freeplane_and_yaml-0.1.4.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-convert = freeplane_and_yaml.cli:main
-