pelican-nlp 0.3.2__tar.gz → 0.3.3__tar.gz

{pelican_nlp-0.3.2/pelican_nlp.egg-info → pelican_nlp-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pelican_nlp
-Version: 0.3.2
+Version: 0.3.3
 Summary: Preprocessing and Extraction of Linguistic Information for Computational Analysis
 Author-email: Yves Pauli <yves.pauli@gmail.com>
 License-Expression: CC-BY-NC-4.0

{pelican_nlp-0.3.2/examples/PyPI_testing_discourse → pelican_nlp-0.3.3/examples/example_discourse}/config_discourse.yml

@@ -7,11 +7,15 @@ discourse: &discourse_flag true
 #general configurations; always adapt
 language: "german" # Possibly add options for German and English
 
-task_name: "interview" # Give name of task used for creation of the input file (e.g., ['fluency', 'interview'])
-corpus_names:
+task_name: "interview"
+
+#Create analysis corpus, group files based on corpus entity.
+corpus_key: "acq"
+corpus_values: #group names
+  - "placebo"
   - "schizophrenia"
 
-metric_to_extract: "embeddings" #Possible options: 'logits' or 'embeddings'
+metric_to_extract: "logits" #Possible options: 'logits' or 'embeddings'
 
 number_of_speakers: 3
 subject_speakertag: "B"
@@ -43,7 +47,7 @@ options_logits:
   keep_speakertags: true
 
 options_embeddings:
-  tokenization_method: "model_roberta" #or "whitespace", "model"
+  tokenization_method: "model" #"model" or "whitespace"
   max_length: 512 #max sequence length
   model_name: "xlm-roberta-base" #e.g. "fastText", "xlm-roberta-base"
   pytorch_based_model: true
@@ -59,10 +63,10 @@ options_embeddings:
     remove_punctuation_and_symbols: true
     remove_brackets_and_content: true
   semantic-similarity: false
+  distance-from-randomness: false
   window_size: null
   clean_tokens: false
-  
-  distance-from-randomness: false
+  divergence_from_optimality: false
 #================================================================================
 
 #Extra configurations:
@@ -93,13 +97,13 @@ normalization_options:
   method: "lemmatization" #Options: lemmatization or stemming
 #================================================================
 
+create_aggregation_of_results: false
+output_document_information: false
+
 #Detail configurations; Changes optional, mostly used for quality checking / error handling
 number_of_subjects: null # Specify number of subjects; if 'null', number of subjects is automatically detected
 multiple_sessions: false # Set to True if multiple sessions per subject
 
 recompute_everything: true #If set to 'false' pelican-nlp will try to reuse previously computed results stored on your drive
 
-create_aggregation_of_results: false
-output_document_information: false
-
 

{pelican_nlp-0.3.2/pelican_nlp/configuration_files → pelican_nlp-0.3.3/examples/example_fluency}/config_fluency.yml

@@ -8,7 +8,8 @@ fluency_task: &fluency_flag true
 language: "german"
 multiple_sessions: &session_flag false
 
-corpus_names: #names of fluency tasks (e.g. "animals", "clothes")
+corpus_key: "acq"
+corpus_values: #names of fluency tasks (e.g. "animals", "clothes")
   - "animals"
   - "clothes"
   - "food"
@@ -103,5 +104,3 @@ filename_components:
   metric: true
   additional_tags: []
 
-
-

pelican_nlp-0.3.3/examples/example_general/config_general.yml

@@ -0,0 +1,146 @@
+# Master Configuration File
+# ========================
+
+# Basic Settings
+# -------------
+input_file: "text"  # Options: 'text' or 'audio'
+language: "german"
+recompute_everything: true  # If false will give warning if output folder already exists
+
+# Task Configuration
+# -----------------
+task_name: null  # Name of task used for creation of data
+fluency_task: &fluency_flag false  # Flag for fluency-specific settings
+discourse: &discourse_flag false  # Flag for discourse-specific settings
+
+# Corpus Configuration
+# ------------------
+corpus_key: null # Entity key to group files for analysis
+corpus_values:  # Corresponding entity values found in dataset
+  - "healthy-control"
+  - "placebo"
+
+# Session and Subject Settings
+# --------------------------
+multiple_sessions: false
+number_of_subjects: null  # If null, auto-detected
+number_of_speakers: 1 # Specify amount of speakers for discourse files
+subject_speakertag: null  # Speaker tag for subject (e.g., "B"), only for discourse
+
+# Document Structure
+# ----------------
+has_multiple_sections: false
+has_section_titles: false
+section_identification: null  # e.g., "Section:", in case of multiple sections
+number_of_sections: null  # If null, auto-detected, specify for multiple sections to check section detection
+
+# Processing Pipeline
+# -----------------
+pipeline_options: # Just for data preprocessing without metric extraction
+  quality_check: false
+  clean_text: true
+  tokenize_text: false
+  normalize_text: false
+
+# Metric Extraction
+# ---------------
+metric_to_extract: "embeddings"  # Options: 'embeddings', 'logits'
+output_document_information: true
+
+# Cleaning Options
+# --------------
+cleaning_options:
+  general_cleaning: true # General cleaning applied to most datasets, check specifications in section "general_cleaning_options"
+  remove_punctuation: false
+  lowercase: true
+  remove_brackets_and_bracketcontent: false
+  remove_timestamps: false
+  timestamp_pattern_example: null  # e.g., "#00:00:23-00#", only if remove_timestamps = True
+  # Fluency-specific options
+  fluency_task: *fluency_flag
+  word_splitter: ';'
+  remove_hyphens: true
+  remove_duplicates: true
+
+general_cleaning_options:
+  strip_whitespace: true
+  merge_multiple_whitespaces: true
+  remove_whitespace_before_punctuation: true
+  merge_newline_characters: true
+  remove_backslashes: true
+
+# Embedding Options
+# ---------------
+options_embeddings:
+  tokenization_method: "whitespace"  # Options: 'whitespace', 'model'
+  model_name: "fastText"  # Options: 'fastText', 'xlm-roberta-base'
+  pytorch_based_model: false
+  method: "model_instance"
+  max_length: 512
+  clean_embedding_tokens: true
+  remove_punctuation: false
+  lowercase: false
+  keep_speakertags: false
+  semantic-similarity: true
+  window_size: null
+  clean_tokens: true
+  divergence_from_optimality: false
+  output_options:
+    exclude_special_tokens: true
+    remove_'_'_character: true
+    remove_speaker_labels: true
+    remove_punctuation_and_symbols: true
+    remove_brackets_and_content: true
+
+# Logits Options
+# -------------
+options_logits:
+  chunk_size: 128
+  overlap_size: 64
+  tokenization_method: "model"
+  model_name: "DiscoResearch/Llama3-German-8B-32k"
+  remove_punctuation: true
+  lowercase: true
+  keep_speakertags: true
+
+# Analysis Options
+# --------------
+options_semantic-similarity:
+  window_sizes:  # 'all' or window size as integer
+    - 2
+    - 8
+
+options_dis_from_randomness:
+  window_size: 8
+  min_len: null
+  bootstrap: 10000
+  shuffle_mode: 'include0_includeN'
+  parallel_computing: false
+
+# Normalization Options
+# -------------------
+normalization_options:
+  method: "lemmatization"  # Options: 'lemmatization', 'stemming'
+
+# Document Information Output
+# -------------------------
+document_information_output:
+  parameters:
+    - subject_ID
+    - fluency_word_count
+    - fluency_duplicate_count
+
+# Filename Configuration
+# --------------------
+filename_components:
+  subject: true    # mandatory
+  session: false
+  task: true       # mandatory
+  task_addition: false
+  corpus: true     # mandatory
+  metric: true
+  additional_tags: []
+
+# Additional Settings
+# -----------------
+create_aggregation_of_results: true

pelican_nlp-0.3.3/pelican_nlp/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.3"

pelican_nlp-0.3.3/pelican_nlp/cli.py

@@ -0,0 +1,34 @@
+import os
+from pathlib import Path
+from pelican_nlp.main import Pelican
+from pelican_nlp.config import RUN_TESTS, run_tests
+
+def main():
+    # Run tests if enabled
+    if RUN_TESTS:
+        print("Running tests...")
+        run_tests()
+        return
+
+    # Get the package directory's sample_configuration_files folder
+    package_dir = Path(__file__).parent
+    config_dir = package_dir / 'sample_configuration_files'
+    
+    if not config_dir.exists():
+        print("sample_configuration_files directory not found in package directory.")
+        return
+        
+    config_files = [f for f in os.listdir(config_dir) if f.endswith(".yml")]
+    if not config_files:
+        print("No .yml configuration file found in the sample_configuration_files directory.")
+        return
+
+    if len(config_files) > 1:
+        print("More than one configuration file found in sample_configuration_files directory - please specify which one to use")
+        return
+
+    config_file = str(config_dir / config_files[0])
+    print(f"Using configuration file: {config_file}")
+
+    pelican = Pelican(config_file)
+    pelican.run()

pelican_nlp-0.3.3/pelican_nlp/config.py

@@ -0,0 +1,35 @@
+"""
+Global configuration settings for the Pelican project.
+
+This file is not the configuration.yml file created for the users adaptations.
+For consistency of pipeline, DO NOT CHANGE.
+"""
+
+# Debug flag
+DEBUG_MODE = True
+
+# Test flag - set to True to run all example tests
+RUN_TESTS = False
+
+def debug_print(*args, **kwargs):
+    """Print only if debug mode is enabled."""
+    DEBUG_MODE = True
+    if DEBUG_MODE:
+        print(*args, **kwargs)
+
+def run_tests():
+    """Run all example tests if RUN_TESTS is enabled."""
+    if RUN_TESTS:
+        import unittest
+        from pathlib import Path
+
+        # Get the path to the test file
+        test_file = Path(__file__).parent / "utils" / "unittests" / "test_examples.py"
+
+        # Create a test suite and add the test file
+        loader = unittest.TestLoader()
+        suite = loader.discover(str(test_file.parent), pattern="test_examples.py")
+
+        # Run the tests
+        runner = unittest.TextTestRunner(verbosity=2)
+        runner.run(suite)

pelican_nlp-0.3.3/pelican_nlp/extraction/extract_embeddings.py

@@ -0,0 +1,106 @@
+from pelican_nlp.extraction.language_model import Model
+from pelican_nlp.preprocessing.text_tokenizer import TextTokenizer
+
+from pelican_nlp.config import debug_print
+
+class EmbeddingsExtractor:
+    def __init__(self, embeddings_configurations, project_path):
+        self.embeddings_configurations = embeddings_configurations
+        self.model_name = embeddings_configurations['model_name']  # Embedding model instance (e.g., fastText, RoBERTa)
+        self.model = Model(self.model_name, project_path)
+        self.Tokenizer = TextTokenizer(self.embeddings_configurations['tokenization_method'], self.model_name,
+                                       self.embeddings_configurations['max_length'])
+
+        self.model.load_model()
+        self.model_instance = self.model.model_instance
+
+    def extract_embeddings_from_text(self, text_list):
+
+        doc_entry_list = []
+
+        for text in text_list:
+
+            embeddings = {}
+
+            # Tokenize the input text
+            inputs = self.Tokenizer.tokenize_text(text)
+            debug_print(f'inputs are: {inputs}')
+
+            if self.embeddings_configurations['pytorch_based_model']:
+                #e.g. RoBERTa Model or Llama Model
+                import torch
+                with torch.no_grad():
+                    if 'llama' in self.model_name.lower():
+                        # Handle Llama models which expect input_ids directly
+                        outputs = self.model_instance(input_ids=inputs['input_ids'])
+                    else:
+                        # Handle RoBERTa and other models that accept **inputs
+                        if isinstance(inputs, dict):
+                            # Ensure inputs are on the same device as the model
+                            inputs = {k: v.to(self.model_instance.device) for k, v in inputs.items()}
+                            debug_print(f"Model inputs: {inputs}")
+                            outputs = self.model_instance(**inputs, output_hidden_states=True)
+                        else:
+                            debug_print(f"Input type: {type(inputs)}")
+                            debug_print(f"Input content: {inputs}")
+                            
+                            # If inputs is a list of strings, convert to token IDs first
+                            if isinstance(inputs, list):
+                                if isinstance(inputs[0], str):
+                                    # Convert tokens to IDs
+                                    token_ids = self.Tokenizer.tokenizer.convert_tokens_to_ids(inputs)
+                                    debug_print(f"Token IDs: {token_ids}")
+                                    inputs = torch.tensor([token_ids], device=self.model_instance.device)
+                                else:
+                                    # If it's already a list of numbers, convert directly
+                                    inputs = torch.tensor([inputs], device=self.model_instance.device)
+                            else:
+                                # If it's already a tensor, just move to device
+                                inputs = inputs.to(self.model_instance.device)
+                            
+                            debug_print(f"Final tensor shape: {inputs.shape}")
+                            
+                            # Ensure proper shape
+                            if len(inputs.shape) == 1:
+                                inputs = inputs.unsqueeze(0)  # Add batch dimension
+                            
+                            # Create attention mask
+                            attention_mask = torch.ones_like(inputs)
+                            debug_print(f"Model inputs - input_ids: {inputs.shape}, attention_mask: {attention_mask.shape}")
+                            outputs = self.model_instance(input_ids=inputs, attention_mask=attention_mask, output_hidden_states=True)
+                            debug_print(f"Model outputs type: {type(outputs)}")
+                            debug_print(f"Model outputs attributes: {dir(outputs)}")
+
+                # Get word embeddings (last hidden state)
+                if outputs is None:
+                    raise ValueError("Model returned None output")
+                
+                if hasattr(outputs, 'hidden_states') and outputs.hidden_states is not None:
+                    word_embeddings = outputs.hidden_states[-1]
+                    debug_print(f"Using hidden_states, shape: {word_embeddings.shape}")
+                elif hasattr(outputs, 'last_hidden_state'):
+                    word_embeddings = outputs.last_hidden_state
+                    debug_print(f"Using last_hidden_state, shape: {word_embeddings.shape}")
+                else:
+                    raise ValueError(f"Model output has neither hidden_states nor last_hidden_state. Available attributes: {dir(outputs)}")
+
+                # Extract input_ids and convert them back to tokens
+                if isinstance(inputs, dict):
+                    input_ids = inputs['input_ids'][0].tolist()
+                else:
+                    input_ids = inputs[0].tolist()
+                tokens = self.Tokenizer.tokenizer.convert_ids_to_tokens(input_ids)
+
+                # Now align the tokens and embeddings
+                for token, embedding in zip(tokens, word_embeddings[0]):
+                    embeddings[token]=embedding.tolist()
+
+            else:
+                if self.model_name == 'fastText':
+                    embeddings = []
+                    for token in inputs:
+                        embeddings.append((token, self.model_instance.get_word_vector(token)))
+
+            doc_entry_list.append(embeddings)
+
+        return doc_entry_list, len(inputs)

{pelican_nlp-0.3.2 → pelican_nlp-0.3.3}/pelican_nlp/extraction/extract_logits.py

@@ -22,7 +22,12 @@ class LogitsExtractor:
         chunk_size = self.options['chunk_size']
         overlap_size = self.options['overlap_size']
 
-        input_ids = tokens.to(self.device)
+        # Convert list of token IDs to tensor if needed
+        if isinstance(tokens, list):
+            input_ids = torch.tensor([tokens], device=self.device)
+        else:
+            input_ids = tokens.to(self.device)
+            
         chunks = self._split_into_chunks(input_ids, chunk_size, overlap_size)
 
         per_token_data = []

{pelican_nlp-0.3.2 → pelican_nlp-0.3.3}/pelican_nlp/extraction/language_model.py

@@ -4,7 +4,7 @@ import os
 import shutil
 
 from accelerate import init_empty_weights, infer_auto_device_map, dispatch_model
-from transformers import AutoModelForCausalLM
+from transformers import AutoModelForCausalLM, AutoModelForMaskedLM, AutoModel
 
 class Model:
     def __init__(self, model_name, project_path):
@@ -75,7 +75,6 @@ class Model:
             
             print(f'FastText model loaded successfully from {model_path}')
         elif self.model_name == 'xlm-roberta-base':
-            from transformers import AutoModel
             self.model_instance = AutoModel.from_pretrained(
                 self.model_name,
                 trust_remote_code=trust_remote_code,

{pelican_nlp-0.3.2 → pelican_nlp-0.3.3}/pelican_nlp/main.py

@@ -25,9 +25,10 @@ from pelican_nlp.utils.setup_functions import subject_instantiator, load_config,
 from pelican_nlp.preprocessing import LPDS
 from pelican_nlp.utils.filename_parser import parse_lpds_filename
 
-from pelican_nlp.config import debug_print
+from pelican_nlp.config import debug_print, RUN_TESTS, run_tests
 
 project_path = '/home/yvespauli/PycharmProjects/PyPI_testing_fluency/config_fluency.yml'
+#project_path = '/home/yvespauli/PycharmProjects/PyPI_testing_discourse/config_discourse.yml'
 
 class Pelican:
 
@@ -40,12 +41,12 @@ class Pelican:
         # If no config path is provided, use the default config from package; used for dev-mode
         if config_path is None:
             package_dir = Path(__file__).parent
-            default_config = package_dir / 'configuration_files' / 'config_fluency.yml'
+            default_config = package_dir / 'sample_configuration_files' / 'config_fluency.yml'
             if default_config.exists():
                 config_path = str(default_config)
                 print(f"Using default configuration file: {config_path}")
             else:
-                sys.exit('Error: Default configuration file not found in package.')
+                sys.exit('Error: Default configuration file not found in sample_configuration_files folder.')
         
         # Verify the provided path is a YAML file
         elif not config_path.endswith(('.yml', '.yaml')):
@@ -72,12 +73,6 @@ class Pelican:
         """Execute the main processing pipeline."""
         self._clear_gpu_memory()
 
-        '''
-        #run unittests in dev_mode; not yet implemented
-        if self.dev_mode:
-            self._run_tests()
-        '''
-
         self._handle_output_directory()
         
         # Check/Create LPDS
@@ -229,4 +224,8 @@ class Pelican:
 
 
 if __name__ == '__main__':
-    Pelican(project_path, dev_mode=True).run()
+    if RUN_TESTS:
+        print("Running tests...")
+        run_tests()
+    else:
+        Pelican(project_path, dev_mode=True).run()

{pelican_nlp-0.3.2 → pelican_nlp-0.3.3}/pelican_nlp/preprocessing/text_tokenizer.py

@@ -24,7 +24,8 @@ class TextTokenizer:
             # Tokenize using the model's tokenizer
             return self.tokenizer(text, return_tensors='pt', truncation=True, padding=True, max_length=self.max_sequence_length).to(self.device_used)
         elif method == 'model':
-            return self.tokenizer.encode(text, return_tensors='pt')
+            # For model method, return token IDs directly
+            return self.tokenizer.encode(text, add_special_tokens=True)
         else:
             raise ValueError(f"Unsupported tokenization method: {method}")
 
@@ -34,10 +35,14 @@ class TextTokenizer:
     def get_tokenizer(self):
         if self.tokenization_method == 'model' or self.tokenization_method == 'model_roberta':
             from transformers import AutoTokenizer
+            if not self.model_name:
+                raise ValueError("model_name must be provided for model-based tokenization methods")
             return AutoTokenizer.from_pretrained(
                 self.model_name,
                 trust_remote_code=False,  # Don't execute arbitrary model code
                 use_safetensors=True
             )
-        else:
+        elif self.tokenization_method == 'whitespace':
             return None
+        else:
+            raise ValueError(f"Unsupported tokenization method: {self.tokenization_method}")

pelican_nlp-0.3.3/pelican_nlp/project_graph/graph_visualization.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+Graph Visualization for Pelican-nlp Project
+===========================================
+
+This script creates a visual representation of the Pelican-nlp project structure
+using graphviz.
+"""
+
+from graphviz import Digraph
+
+def create_pelican_graph():
+    # Create a new directed graph
+    dot = Digraph(comment='Pelican-nlp Project Structure')
+    dot.attr(rankdir='TB')
+    
+    # Set node styles
+    dot.attr('node', shape='box', style='rounded,filled')
+    
+    # Main Components
+    with dot.subgraph(name='cluster_main') as c:
+        c.attr(label='Main Components')
+        c.attr('node', fillcolor='lightblue')
+        c.node('Pelican', 'Pelican\n(Main Controller)')
+        c.node('LPDS', 'LPDS\n(Data Structure)')
+        c.node('Corpus', 'Corpus\n(Document Collection)')
+        c.node('Subject', 'Subject\n(Grouping Unit)')
+        c.node('Document', 'Document\n(Data Container)')
+        c.node('AudioDocument', 'AudioDocument\n(Audio Data)')
+    
+    # Core Processing
+    with dot.subgraph(name='cluster_core') as c:
+        c.attr(label='Core Processing')
+        c.attr('node', fillcolor='lightgreen')
+        c.node('Config', 'Configuration\n(config.py)')
+        c.node('CLI', 'Command Line Interface\n(cli.py)')
+        c.node('Main', 'Main Entry Point\n(main.py)')
+    
+    # Preprocessing Components
+    with dot.subgraph(name='cluster_preprocessing') as c:
+        c.attr(label='Preprocessing')
+        c.attr('node', fillcolor='lightyellow')
+        c.node('TextTokenizer', 'Text Tokenizer\n(text_tokenizer.py)')
+        c.node('TextNormalizer', 'Text Normalizer\n(text_normalizer.py)')
+        c.node('TextCleaner', 'Text Cleaner\n(text_cleaner.py)')
+        c.node('TextImporter', 'Text Importer\n(text_importer.py)')
+        c.node('SpeakerDiarization', 'Speaker Diarization\n(speaker_diarization.py)')
+        c.node('Pipeline', 'Preprocessing Pipeline\n(pipeline.py)')
+    
+    # Extraction Components
+    with dot.subgraph(name='cluster_extraction') as c:
+        c.attr(label='Feature Extraction')
+        c.attr('node', fillcolor='lightpink')
+        c.node('LogitsExtractor', 'Logits Extractor\n(extract_logits.py)')
+        c.node('EmbeddingsExtractor', 'Embeddings Extractor\n(extract_embeddings.py)')
+        c.node('LanguageModel', 'Language Model\n(language_model.py)')
+        c.node('AcousticFeatures', 'Acoustic Features\n(acoustic_feature_extraction.py)')
+        c.node('SemanticSimilarity', 'Semantic Similarity\n(semantic_similarity.py)')
+        c.node('RandomnessDistance', 'Distance from Randomness\n(distance_from_randomness.py)')
+    
+    # Utility Components
+    with dot.subgraph(name='cluster_utils') as c:
+        c.attr(label='Utilities')
+        c.attr('node', fillcolor='lightgrey')
+        c.node('FilenameParser', 'Filename Parser\n(filename_parser.py)')
+        c.node('CSVFunctions', 'CSV Functions\n(csv_functions.py)')
+        c.node('SetupFunctions', 'Setup Functions\n(setup_functions.py)')
+    
+    # Main Relationships
+    dot.edge('Pelican', 'LPDS', 'manages')
+    dot.edge('Pelican', 'Corpus', 'processes')
+    dot.edge('Pelican', 'Subject', 'instantiates')
+    dot.edge('Corpus', 'Document', 'contains')
+    dot.edge('Subject', 'Document', 'groups')
+    dot.edge('Document', 'AudioDocument', 'extends')
+    
+    # Core Processing Relationships
+    dot.edge('CLI', 'Main', 'calls')
+    dot.edge('Main', 'Pelican', 'instantiates')
+    dot.edge('Pelican', 'Config', 'uses')
+    
+    # Preprocessing Relationships
+    dot.edge('Pipeline', 'TextTokenizer', 'uses')
+    dot.edge('Pipeline', 'TextNormalizer', 'uses')
+    dot.edge('Pipeline', 'TextCleaner', 'uses')
+    dot.edge('Pipeline', 'TextImporter', 'uses')
+    dot.edge('Pipeline', 'SpeakerDiarization', 'uses')
+    dot.edge('Corpus', 'Pipeline', 'executes')
+    
+    # Extraction Relationships
+    dot.edge('Corpus', 'LogitsExtractor', 'uses')
+    dot.edge('Corpus', 'EmbeddingsExtractor', 'uses')
+    dot.edge('LogitsExtractor', 'LanguageModel', 'uses')
+    dot.edge('EmbeddingsExtractor', 'LanguageModel', 'uses')
+    dot.edge('Corpus', 'AcousticFeatures', 'uses')
+    dot.edge('Corpus', 'SemanticSimilarity', 'uses')
+    dot.edge('Corpus', 'RandomnessDistance', 'uses')
+    
+    # Utility Relationships
+    dot.edge('Pelican', 'FilenameParser', 'uses')
+    dot.edge('Corpus', 'CSVFunctions', 'uses')
+    dot.edge('Pelican', 'SetupFunctions', 'uses')
+    
+    # Save the graph
+    dot.render('pelican_structure_detailed', format='png', cleanup=True)
+    print("Detailed graph visualization has been created as 'pelican_structure_detailed.png'")
+
+if __name__ == '__main__':
+    create_pelican_graph()