pelican-nlp 0.1.0__py3-none-any.whl

pelican_nlp/extraction/test_documents/wallace_1.15_3.txt

@@ -0,0 +1 @@
+In der trüben Kulisse Londons, die von einem unaufhörlich niederprasselnden Regen fast erdrückt wurde, befand sich die berüchtigte Seemannstaverne "Zum Lachenden Krake" in Wapping's dunkler Gasse. Ihr Ruf war ebenso zwielichtig wie die Stammgäste, die sich dort in trister Regelmäßigkeit einfanden. In einer dunklen Ecke des Gasthauses saß ein Mann, dessen finstere Erscheinung kaum ins Licht drang. Sein Name war Ryder Sparrow, ein Name, der durch das East End raunte wie ein geflüstertes Geheimnis. Er war ein Detektiv, bislang vergeblich darum bemüht, unseren mysteriösen Antagonisten - das "Schwarze Phantom" - dingfest zu machen. Der Fall des Schwarzen Phantoms war ein Mysterium, das nicht nur Scotland Yard, sondern ganz England in Atem hielt. Dieser unbekannte Dramatiker der Dunkelheit verübte seine Straftaten im Schutze der Nacht und ließ der Polizei nichts anderes als zertrümmerte Fensterrahmen und leere Tresore vor. Sein brillantester Coup, der beraubte Globe Plaza Verarbeitungstresor, hing wie ein Damoklesschwert über Ryders Karriere, denn es war wohlbekannt, dass der melancholische Detektiv bereits mehrere Fälle durch dessen nicht fassbare Handschrift it bohämmernden Details verbinden konnte. Ryder hob seinen Blick zum hartgesottenen Barmann, einer Koryphäe und ungeschlagener Bewahrer aller Gerüchte die über die Theke gingen. "Hammon, was hört man über das Phantom?", fragte Ryder mit einem zugleich einzigen Ausdruck aus Hoffnung und Müdigkeit. Hammon wischte mit seinem Küchentuch über die fleckige Bar und nagelte Ryder mit einem Blick fest, der besagte, dass man mehr erhalten würde, als was Worte ausdrücken können, wenn er sprach. "Ryder, der Wind weht von Thief Lane her. Die Zwillinge Mallory werden heute Nacht ihre Karten im Kopf stechen; die könnten mehr wissen." Hammon schnappte das Tuch mit einem kräftigen zweimaligen Zucken ein. "Such sie bei der Mitternachtsschicht in Dockseide." Ryder wusste, dass der Abend von einem Licht durchtränkt war, das nur metaphorisch seine Schritte beleuchten konnte, und mit dem raschen Schulterzug seines Trenchcoats entschied er, diesem oder jenem Weg nachzugehen. Die Docks waren umweht von Lagermief und nasser Holzstöße; der Zustand schnappte gierig nach jedem, der eine noch unverboschene Nase durch den Nebel streckte. Die Mallory-Zwillinge, Fred und George, waren bekannte Namen – flüssig in Lug und Trug, und ihre Informationen entsprachen dem Klang klirrender Münzen mehr denn einem Gefühl roher Realität. Fred Mallory blitzte Ryder mit einem feinen Nicken entgegen - sie begriffen sich auf einer gemeinsamen stillen Talfahrt durch das Meer der moralischen Verpackung. "Das Phantom?", erwiderte Fred, bevor Ryder eine Arbeitwichse beginnen könnte. "Vielleicht lag's im Tain Memorial Auktionshaus diets Komm, mehr kann ich nicht sagen..." Ryders Augenmerk verharrte länger als er sollte - war dies eine verdeckte Gönnung wichtige Subtilitäten eines gesichtslosen Phantasmas? Das Fingerdümpeln der alten Taschenuhr in seiner Westentasche erinnerte ihn daran, dass Zeit längst nicht neutral zwischen Wahrheit und Verrat verharrte. Er wandte sich um, seinen Beinen ein zusätzliches Scheit Selbstzerstreuung gestattend. Zur dunklen bewölkten Stunde desjenigen Morgens, klopfte Regen entlang Londons Straßen, wobei Ryder Sparrow sicheren Tritt fassen wollte auf der Triangulierung dünnerweise gestauchter Spuren – signifikant das throndsüchtige Auge seiner Stillseelsword. Die Auktionschauser zeugten wabenaufgeschlossenen Mitgesellen - aber frei wurden Quilten unter deckschützen Vereinsmeiereien, ihre sanfthellbrisischen Optionen abwehrverfangen. Drinnen kurz beleuchtet verneurten erhellsgehend Sa

pelican_nlp/extraction/test_documents/wallace_1.1_3.txt

@@ -0,0 +1 @@
+In der trüben Kulisse Londons, die von einem unaufhörlich niederprasselnden Regen fast erdrückt wurde, befand sich die berüchtigte Seemannstaverne "Zum grünen Papagei" in einem der dunkleren Winkel von Limehouse. Es war ein namentlich kaum beachtetes lokal, das doch in den geheimen Gassen des Verbrechens eine bedeutende Rolle spielte. Der grüne Papagei, der hinter der Theke thronte – eine prächtige, doch seltsam bedrohlich wirkende Statue –, bot einem ganz bestimmten Besucher jedes Mal ein unbehagliches Gefühl. Inspector George Hastings vom Scotland Yard trat an diesem düsteren Abend in den schummrigen Raum. Die Geräusche des Ortes – das gedämpfte Gemurmel der Gäste, das gelegentliche Klingeln von Münzen auf Holz und das plötzliche, schallende Lachen – fanden einen Drang in seine Gehörgänge, als wären sie Nachrichten einer längst im Verborgenen gefangenen Welt. Hastings schob sich mit dem gewohnten, unaufdringlichen Selbst bewussten Tritt durch die wenigen Schatten der Anwesenden und fixierte sein Interesse auf Seamus O'Reilly, den Barbesitzer. Ein irischer Einwanderer, dessen Vergangenheit in einem anrüchigen Schleier gehüllt war – O'Reilly war it bohnenlangjähriger Beobachtung und noch längerer Misstrauen. Seine großflächigen, rauen Hände waren ein Zeugnis der Arbeit, doch sein scharfes, neugieriges Auge verriet einen Geist, der nie zur Ruhe zu kommen schien. "Was kann ich für einen Hüter des Gesetzes tun?", brummte O'Reilly und stützte sich auf die polierte Theke. Der Lichtschimmer der sparsamen Beleuchtung zeigte das eine unregelmäßige Sammlung von Narben, die sein Gesicht durchzogen – Zeichen der zahlreichen Wirtshausschlägereien, in die er früher verwickelt gewesen war. "Nicht heute." Hastings verstärkte seinen Unterton freundlicher Höflichkeit. "Nicht als einen obligatorischen Mittwochabendbesuch, zweimal im Monat." "Twice im Mond, ja." Ein lodernder Funken erwachte in O'Reillys Augen, dann erlosch er so schnell wieder, wie er gekommen war. "Wegen der Papageistatue, richtig?" Diese Frage stellen hatte O’Reilly nichts wissend entblättern sollen, doch es war der Auftakt, den Hastings benötigt hatte. Bevor es jedoch zu einer tiefer gehenden Konversation kommen konnte, näherte sich eine weitere Gestalt seinem Platz an der Theke – ein dürrer Mann in einem makellosen Anzug, dessen präzise gefaltetes Einstecktuch sich auffällig von der erdrückenden Neutralität seines dunklen Kostüms abhob. Das rotsilkene Stück Stoff vermittelte ihm die Aura eines unruhigen Ozeans, begraben unter einer kalten See. "Mr. Parker", verkündete O'Reilly mit insgespieltem Respekt, der dem Neuankömmling zur Schau Stellung eines Mannes gerecht wurde, der es gewöhnt war zu erwarten, dass die Welt vor ihm in Sicherheit geht. "Oder sollte ich Sie 'Sir Thomas' nennen?" Thomas Parker réponse in einem amüsierten Ton. "Gerade hier, in diesem Raum, reicht 'Mr. Parker' aus." Je länger er sprach, desto deutlicher wurde für Hastings klar, dass Parker nicht das kompakte Rätsel war, das er vorgab zu sein. Man sagte sich, er stamme aus einer Familie der gehobeneren Londoner Gesellschaft, deren Ansichten über die dunkleren Ecken der Stadt wohl nur auf dem Papier existierten. Mit einem unverbindlichen Nicken verabschiedete sich Parker schnell und ließ die Bar hinter sich, wie jemand, der nichts weiteres erwartete. Ein signifikantes Bedürfnis, das oft eine Stillsegnung war, rührte sich bei Hastings in Auffassung zum Aufmerksamkeitsregel von O’Reillys Barbesucher heraus. Er witterte den Beginn von etwas Komplexem – einem Weben, gleich einer Spinnenqualität, das bislang nur die Umrisse einer Falle

pelican_nlp/extraction/test_documents/wallace_1_4.txt

@@ -0,0 +1 @@
+In den dichten Nebelschwaden Londons, die wie ein undurchschaubares Tuch über den Straßen schwebten, lagerten Geheimnisse, die nur auf ihre Entdeckung warteten. Im Herzen der Stadt, in den engen Gassen, wo das Gaslicht schummrig auf das Pflaster fiel, war ein Verbrechen geschehen, das die Bürger in Angst und Schrecken versetzte. Inspektor William Thorn, ein Mann von mittlerem Wuchs und durchdringendem Blick, stolzierte durch den nebelverhangenen Innenhof der Scotland Yard Headquarters. Der kalte Wind spielte mit seinen Mantelschößen, während er sich schnellstmöglich den Weg zum Büro von Kommissar Gordon bahnte. Die nächtlichen Straßen säumten Gestalten, die aus den Schatten traten und wieder hineinglitten, als Thorn den vertrauten Pfad entlangging. Im Büro empfing ihn Kommissar Gordon, ein hagerer Mann mit grimmiger Miene, der trotz seiner streng wirkenden Gesichtszüge eine väterliche Wärme ausstrahlte. Er saß hinter seinem massiven Schreibtisch, der mit Berichten und Karten überhäuft war, und seine blauen Augen fixierten Thorn, als dieser eintrat. „William“, begann Gordon ohne Umschweife in seiner gewohnt tiefen Stimme, „wir haben einen neuen Fall, der unsere ganze Aufmerksamkeit erfordert.“ Der Inspektor zog sich den Stuhl heran und nahm Platz. „Was ist geschehen, Sir?“ fragte er, während seine Gedanken bereits die verschiedenen Möglichkeiten durchspielten. „Gestern Nacht wurde in einem verlassenen Lagerhaus an der Themse die Leiche von Lord Harold Davenport gefunden. Es gibt bisher keine Hinweise, die uns auf das Motiv oder den Täter schließen lassen“, erklärte Gordon knapp und übergab Thorn eine Mappe mit den bisherigen Ermittlungen. Thorn öffnete die Mappe und überflog die ersten Seiten. Lord Davenport war bekannt für seinen exzentrischen Lebensstil, der ihn in die unterschiedlichsten Kreise Londons führte – von der vornehmen Gesellschaft bis hin zu den zwielichtigen Unterweltgestalten. Seine Verstrickungen in dubiose Geschäfte waren ebenso berüchtigt wie seine Fähigkeit, stets ungeschoren davonzukommen. Diese Tatsache allein machte seine Ermordung zu einem merkwürdigen Rätsel; wer immer ihn umgebracht hatte, musste ein dringendes Motiv gehabt haben. „Alle seine nahen Kontakte verbergen etwas“, merkte Gordon an und lehnte sich zurück. „Die Polizei fand ihn mit einem blutroten Seidentuch um den Hals geknotet – ein Symbol, das wir bisher nicht einordnen können.“ Thorn nickte, seine Gedanken rasten. „Und was ist mit seinem Personal, oder etwaigen Geschäftspartnern?“ „Einige der Bediensteten wurden befragt, doch alle scheinen nichts Bemerkenswertes zu wissen“, antwortete der Kommissar mit einem Seufzen. „Es gibt jedoch Gerüchte über eine mysteriöse Frau, die ihn in den Tagen vor seinem Tod regelmäßig besucht haben soll.“ Ein weiterer Hinweis, der eher zu Verwirrung als zur Klarheit beitrug. Thorn erhob sich, entschlossen die Ermittlungen aufzunehmen. Seine erste Station war das Herrenhaus der Davenports, das in einem noblen Viertel lag und dennoch in seiner düsteren Pracht ein gewisses Unbehagen auszudrücken schien. Das Geisterhafte, das über dem Anwesen lag, wurde noch verstärkt durch das fahlen Mondlicht, das sich in den hohen Fenstern spiegelte. Keine Bewegung signalisierten Leben, nichts, außer einem einsamen Diener, der Thorn die Tür öffnete. „Inspektor Thorn“, stellte dieser sich knapp vor und schritt mit dem Bediensteten die kahle Halle entlang hinein in die opulent eingerichtete Bibliothek. Lady Elizabeth Davenport, die Witwe des verstorbenen Lords, empfing ihn. Sie war eine schöne Frau mittleren Alters mit einer eleganten Haltung, die jedoch eine gewisse müde Traurigkeit nicht verbergen konnte. Ihr schwarzes Trauerkleid ließ sie geisterhaft erhaben wirken, und ihre Augen schimmerten unruhig. „Vielen Dank, dass Sie mich empfangen, Lady Davenport“, begann Thorn, während er sich setzte

pelican_nlp/main.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Pelican Project
+===============
+
+Pelican is a tool developed to enable consistent and reproducible language processing.
+Main entry point for the Pelican project handling document processing and metric extraction.
+
+Author: Yves Pauli
+Created: 2024-01-10
+Version: 1.0.0
+
+Copyright (c) 2024 Yves Pauli
+License: Attribution-NonCommercial 4.0 International
+All rights reserved.
+"""
+
+from pathlib import Path
+from typing import Dict, List
+import torch.cuda
+import sys
+
+from pelican_nlp.core import Corpus
+from pelican_nlp.utils.setup_functions import subject_instantiator, load_config, remove_previous_derivative_dir
+from pelican_nlp.preprocessing import LPDS
+
+# Constants
+# DEFAULT_CONFIG_PATH = 'configuration_files/config_morteza.yml'
+
+class Pelican:
+
+    """Main class for the Pelican project handling document processing and metric extraction."""
+    
+    def __init__(self, config_path: str = None, dev_mode: bool = True) -> None:
+        self.dev_mode = dev_mode
+        
+        # If no config path is provided, use the default config from package
+        if config_path is None:
+            package_dir = Path(__file__).parent
+            default_config = package_dir / '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.')
+        
+        # Verify the provided path is a YAML file
+        elif not config_path.endswith(('.yml', '.yaml')):
+            sys.exit('Error: Configuration file must be a YAML file (*.yml or *.yaml)')
+        
+        self.config = load_config(config_path)
+        self.project_path = Path(self.config['PATH_TO_PROJECT_FOLDER'])
+        self.path_to_subjects = self.project_path / 'subjects'
+        self.output_directory = self.project_path / 'derivatives'
+        self.task = self.config['task_name']
+        
+        # Add test configuration, TESTS NOT YET IMPLEMENTED
+        self.test_config = {
+            'run_all': True,  # Run all tests by default
+            'test_paths': ['tests'],  # Default test directory
+            'markers': [],  # Specific test markers to run
+            'skip_slow': True,  # Skip slow tests by default
+        }
+        
+        if not self.path_to_subjects.is_dir():
+            sys.exit('Error: Could not find subjects directory; check folder structure.')
+
+    def run(self) -> None:
+        """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
+        self._LPDS()
+        
+        # Instantiate all subjects
+        subjects = subject_instantiator(self.config)
+        
+        # Process each corpus
+        for corpus_name in self.config['corpus_names']:
+            self._process_corpus(corpus_name, subjects)
+
+    def _process_corpus(self, corpus_name: str, subjects: List) -> None:
+
+        """Process a single corpus including preprocessing and metric extraction."""
+        print(f'Processing corpus: {corpus_name}')
+
+        corpus_documents = self._identify_corpus_files(subjects, corpus_name)
+        corpus = Corpus(corpus_name, corpus_documents[corpus_name], self.config)
+
+        for document in corpus_documents[corpus_name]:
+            document.corpus_name = corpus_name
+
+        if self.config['input_file']=='text':
+            corpus.preprocess_all_documents()
+            print(f'Corpus {corpus_name} is preprocessed')
+
+            self._extract_metrics(corpus)
+
+            if self.config['create_aggregation_of_results']:
+                corpus.create_corpus_results_consolidation_csv()
+
+            if self.config['output_document_information']:
+                corpus.create_document_information_csv()
+
+
+        elif self.config['input_file']=='audio':
+            if self.config['opensmile_feature_extraction']:
+                corpus.extract_opensmile_features()
+
+            if self.config['prosogram_extraction']:
+                corpus.extract_prosogram()
+
+        del corpus
+
+
+    def _LPDS(self):
+        """Initialize LPDS and create derivative directory"""
+        lpds = LPDS(self.project_path, self.config['multiple_sessions'])
+        lpds.LPDS_checker()
+        lpds.derivative_dir_creator()
+
+    def _extract_metrics(self, corpus: Corpus) -> None:
+        """Extract specified metrics from the corpus."""
+        metric = self.config['metric_to_extract']
+        if metric == 'logits':
+            print('Extracting logits...')
+            corpus.extract_logits()
+        elif metric == 'embeddings':
+            print('Extracting embeddings...')
+            corpus.extract_embeddings()
+        else:
+            raise ValueError(f"Unsupported metric: {metric}")
+        
+        self._clear_gpu_memory()
+
+    def _identify_corpus_files(self, subjects: List, corpus: str) -> Dict:
+        """Identify and group files belonging to a specific corpus."""
+        corpus_dict = {corpus: []}
+        for subject in subjects:
+            for document in subject.documents:
+                name = Path(document.name)
+                document.extension = name.suffix
+                # Split by both '_' and '.' to get all parts
+                parts = name.stem.replace('.', '_').split('_')
+                # Check if corpus name appears in any part
+                if corpus in parts:
+                    corpus_dict[corpus].append(document)
+        return corpus_dict
+
+    def _handle_output_directory(self) -> None:
+        """Handle the output directory based on dev mode."""
+        if self.dev_mode:
+            remove_previous_derivative_dir(self.output_directory)
+        elif self.output_directory.exists():
+            self._prompt_for_continuation()
+
+    def _run_tests(self) -> None:
+        # Run unittests to test implemented functions... not yet in use
+        """Run test suite in development mode with configurable options."""
+        import pytest
+        print("Running tests in development mode...")
+
+        # Build pytest arguments
+        pytest_args = ["-v", "--no-header"]
+
+        # Add test paths
+        pytest_args.extend(self.test_config['test_paths'])
+
+        # Add markers if specified
+        for marker in self.test_config['markers']:
+            pytest_args.extend(["-m", marker])
+
+        # Skip slow tests if configured
+        if self.test_config['skip_slow']:
+            pytest_args.extend(["-m", "not slow"])
+
+        # Run pytest with constructed arguments
+        result = pytest.main(pytest_args)
+
+        # Handle test results
+        if result != 0:
+            print("Tests failed. Aborting execution.")
+            sys.exit(1)
+
+        print("All tests passed. Continuing with execution.\n")
+
+    @staticmethod
+    def _prompt_for_continuation() -> None:
+        """Prompt user for continuation if output directory exists."""
+        print('Warning: An output directory already exists. Continuing might invalidate previously computed results.')
+        confirm = input("Do you want to continue? Type 'yes' to proceed: ").strip().lower()
+        if confirm not in ('yes', 'y'):
+            print("Operation aborted.")
+            sys.exit(0)
+
+    @staticmethod
+    def _clear_gpu_memory() -> None:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+
+if __name__ == '__main__':
+    Pelican().run()

pelican_nlp/metrics_statistics/embeddings_metrics_statistics.py

@@ -0,0 +1,34 @@
+import numpy as np
+from itertools import combinations
+from scipy.spatial.distance import pdist, squareform
+
+class embeddings_metrics_statistics():
+    @staticmethod
+    def pairwise_similarities(embeddings, metric_function=None):
+        """Compute pairwise similarities between embeddings."""
+        distance_matrix = pdist(embeddings, metric='cosine')
+        similarity_matrix = 1 - squareform(distance_matrix)
+        return similarity_matrix
+
+    @staticmethod
+    def compute_window_statistics(similarities, window_size, aggregation_functions=[np.mean]):
+        """Compute aggregated statistics over a given window size."""
+        num_tokens = similarities.shape[0]
+        stats = {}
+
+        for start in range(0, num_tokens, window_size):
+            end = min(start + window_size, num_tokens)
+            window_similarities = similarities[start:end, start:end]
+            window_values = window_similarities[np.triu_indices_from(window_similarities, k=1)]
+
+            for func in aggregation_functions:
+                key = f'{func.__name__}_window_{window_size}'
+                stats.setdefault(key, []).append(func(window_values))
+
+        return {key: np.mean(values) for key, values in stats.items()}
+
+
+    @staticmethod
+    def aggregate_window(window_values, aggregation_functions=[np.mean]):
+        """Aggregates window values using specified functions."""
+        return {func.__name__: func(window_values) for func in aggregation_functions}

pelican_nlp/preprocessing/LPDS.py

@@ -0,0 +1,77 @@
+import re
+import os
+
+class LPDS:
+    def __init__(self, project_folder, multiple_sessions):
+        self.project_folder = project_folder
+        self.multiple_sessions = multiple_sessions
+        self.subjects_folder = os.path.join(self.project_folder, "subjects")
+        self.subject_folders = [f for f in os.listdir(self.subjects_folder) if
+                                os.path.isdir(os.path.join(self.subjects_folder, f))]
+
+    def LPDS_checker(self):
+        # Check if the main project folder exists
+        if not os.path.isdir(self.project_folder):
+            raise FileNotFoundError(f"Project folder '{self.project_folder}' does not exist.")
+
+        # Check for required files in the project folder
+        suggested_files = ["dataset_description.json", "README", "CHANGES", "participants.tsv"]
+        for file in suggested_files:
+            if not os.path.isfile(os.path.join(self.project_folder, file)):
+                print(f"Warning: Missing suggested file '{file}' in the project folder.")
+
+        # Check for the 'subjects' folder
+        if not os.path.isdir(self.subjects_folder):
+            raise FileNotFoundError("Error: The 'subjects' folder is missing in the project folder.")
+
+        # Check if there is at least one subfolder in 'subjects', ideally named 'sub-01'
+        if not self.subject_folders:
+            raise FileNotFoundError("Error: No subject subfolders found in the 'subjects' folder.")
+        if 'sub-01' not in self.subject_folders:
+            print("Warning: Ideally, subject folders should follow the naming convention 'sub-x'.")
+
+        # Iterate through subject subfolders
+        for subject_folder in self.subject_folders:
+            subject_path = os.path.join(self.subjects_folder, subject_folder)
+
+            # Check for session folders if project has sessions
+            if self.multiple_sessions:
+                session_folders = [f for f in os.listdir(subject_path) if
+                                   os.path.isdir(os.path.join(subject_path, f))]
+                if not session_folders:
+                    print(f"Warning: No session folders found in '{subject_folder}'.")
+                if 'ses-01' not in session_folders:
+                    print(f"Warning: Ideally, the session folders should follow the naming convention 'ses-x'.")
+
+            # Check for optional subject_metadata file
+            metadata_file = os.path.join(subject_path, "subject_metadata")
+            if not os.path.isfile(metadata_file):
+                #print(f"Note: Optional 'subject_metadata' file is missing in '{subject_folder}'.")
+                continue
+
+            session_folders = subject_folder
+
+            # Iterate through current level folders (subjects or sessions)
+            for session_folder in session_folders:
+                session_path = os.path.join(subject_path, session_folder)
+                task_folders = [f for f in os.listdir(session_path) if os.path.isdir(os.path.join(session_path, f))]
+
+                # Check for tasks inside session folder
+                for task_folder in task_folders:
+                    task_path = os.path.join(session_path, task_folder)
+                    task_files = [f for f in os.listdir(task_path) if os.path.isfile(os.path.join(task_path, f))]
+
+                    # Check naming convention for files in the task folder
+                    for file in task_files:
+                        if self.multiple_sessions:
+                            pattern = fr"^{subject_folder}_{session_folder}_{task_folder}.*"
+                        else:
+                            pattern = fr"^{subject_folder}_{task_folder}.*"
+                        if not re.match(pattern, file):
+                            print(f"Warning: File '{file}' in '{task_folder}' does not follow the LPDS naming conventions")
+
+    def derivative_dir_creator(self):
+        # Create the 'derivatives' folder if it doesn't exist
+        derivatives_folder = os.path.join(self.project_folder, "derivatives")
+        if not os.path.exists(derivatives_folder):
+            os.makedirs(derivatives_folder)

pelican_nlp/preprocessing/__init__.py

@@ -0,0 +1,7 @@
+# Import the core classes and functions for easier access
+from .text_importer import TextImporter
+from .text_cleaner import TextCleaner
+from .text_tokenizer import TextTokenizer
+from .text_normalizer import TextNormalizer
+from .pipeline import TextPreprocessingPipeline
+from .LPDS import LPDS

pelican_nlp/preprocessing/pipeline.py

@@ -0,0 +1,50 @@
+from pelican_nlp.preprocessing.text_tokenizer import TextTokenizer
+from pelican_nlp.preprocessing.text_cleaner import TextCleaner, FluencyCleaner
+from pelican_nlp.preprocessing.text_normalizer import TextNormalizer
+
+class TextPreprocessingPipeline:
+    """Pipeline for text preprocessing operations."""
+    
+    def __init__(self, config):
+        """Initialize pipeline with configuration.
+        
+        Args:
+            config: Dictionary of configuration options
+        """
+        self.config = config
+        self.pipeline_options = config['pipeline_options']
+        self.cleaner = None
+        self.normalizer = None
+        self.tokenizer = None
+
+    def process_document(self, document):
+        """Process a document through configured pipeline steps.
+        
+        Args:
+            document: Document object to process
+        """
+        print('Processing document (pipeline.py)')
+        
+        for option, enabled in self.pipeline_options.items():
+            if enabled:
+                processor = getattr(self, f"_{option}")
+                processor(document)
+
+    def _clean_text(self, document):
+        """Clean document text."""
+        self.cleaner = TextCleaner(self.config['cleaning_options'])
+        document.clean_text(self.cleaner)
+
+    def _tokenize_text(self, document):
+        """Tokenize document text."""
+        self.tokenizer = TextTokenizer(self.config['tokenization_options'])
+        document.tokenize_text(self.tokenizer)
+
+    def _normalize_text(self, document):
+        """Normalize document text."""
+        self.normalizer = TextNormalizer(self.config['normalization_options'])
+        document.normalize_text(self.normalizer)
+
+    def _quality_check(self, document):
+        """Placeholder for quality check implementation."""
+        pass

pelican_nlp/preprocessing/speaker_diarization.py

@@ -0,0 +1,33 @@
+import re
+from collections import Counter
+
+class TextDiarizer:
+    def __init__(self, method=None):
+        self.method = method
+
+
+    def speaker_tag_identification(self, text, num_speakers, exclude_speakers=None):
+        if exclude_speakers is None:
+            exclude_tags = []
+
+        # Regular expression to capture potential speaker tags
+        potential_tags = re.findall(r'^(\w+):', text, re.MULTILINE)
+
+        # Count occurrences of potential speaker tags
+        tag_counts = Counter(potential_tags)
+
+        # Filter likely speaker tags based on frequency and exclusion list
+        speaker_tags = [tag for tag, count in tag_counts.most_common(num_speakers) if tag not in exclude_speakers]
+
+        return speaker_tags
+
+    @staticmethod
+    def parse_speaker(text, speaker_tag, keep_speakertag=False):
+
+        pattern = rf"{re.escape(speaker_tag)}:\s*(.*?)(?=\n\s*\w+:|\Z)"
+        matches = re.findall(pattern, text, re.DOTALL)
+
+        if keep_speakertag:
+            return [f"{speaker_tag}: {match.strip()}" for match in matches]
+        else:
+            return [match.strip() for match in matches]

pelican_nlp/preprocessing/text_cleaner.py

@@ -0,0 +1,224 @@
+import string
+import re
+from collections import Counter
+
+class TextCleaner:
+    def __init__(self, options=None):
+        self.options = options
+
+    def clean(self, document, text, characters_to_remove=None):
+        """Clean text based on configured options.
+        
+        Args:
+            document: Document object containing metadata
+            text: Text to clean
+            characters_to_remove: Optional string of characters to remove
+        Returns:
+            Cleaned text string
+        """
+        if self.options.get('remove_timestamps', True):
+            text = remove_timestamps(text, self.options.get('timestamp_pattern_example'))
+
+        if characters_to_remove:  # Simplified condition
+            text = _remove_special_characters(text, characters_to_remove)
+
+        # Consolidate conditional blocks for better readability
+        cleaning_operations = [
+            ('fluency_task', lambda: self.clean_fluency_transcripts(document, text)),
+            ('remove_punctuation', lambda: remove_punctuation(text)),
+            ('lowercase', lambda: lowercase(text))
+        ]
+
+        for option, operation in cleaning_operations:
+            if self.options.get(option):
+                text = operation()
+
+        if self.options.get('general_cleaning', True):
+            replacements = [
+                (r'/', ''),
+                (r'\s+([?.!,"])', r'\1'),
+                (r'\n\s*\n', '\n'),
+                (r'\\', ''),
+                (' +', ' ')
+            ]
+            text = self._apply_replacements(text, replacements)
+
+        return text.strip()
+
+    @staticmethod
+    def _apply_replacements(text, replacements):
+        """Apply a list of regex replacements to text."""
+        for old, new in replacements:
+            text = re.sub(old, new, text)
+        return text
+
+    def clean_fluency_transcripts(self, document, content):
+        fluencyCleaner = FluencyCleaner(self.options)
+        return fluencyCleaner.cleanFluency(document, content)
+
+
+class FluencyCleaner:
+
+    def __init__(self, options=None):
+        self.options = options
+
+    def cleanFluency(self, document, content):
+        """Clean fluency task transcripts.
+        
+        Args:
+            document: Document object containing metadata
+            content: Text content to clean
+        Returns:
+            Cleaned text string
+        """
+        word_splitter = self.options['word_splitter']
+        # First split by word_splitter if defined
+        if word_splitter:
+            words = content.split(word_splitter)
+            # Further split each chunk by commas
+            temp_words = []
+            for chunk in words:
+                temp_words.extend(chunk.split(','))
+            words = temp_words
+        else:
+            # If no word_splitter defined, just split by commas
+            words = content.split(',')
+            
+        self.count_duplicates_and_hyphenated(document, words)
+
+        content = re.sub(r'\s+', '', content).strip()
+        # Apply the same splitting logic for the cleaned content
+        if word_splitter:
+            words = []
+            for chunk in content.split(word_splitter):
+                words.extend(chunk.split(','))
+        else:
+            words = content.split(',')
+        words = [word for word in words if word]
+
+        word_counter = Counter(words)
+        document.fluency_duplicate_count = sum(count - 1 for count in word_counter.values() if count > 1)
+
+        # Apply cleaning operations based on options
+        if self.options['remove_hyphens']:
+            words = [word.replace('-', '') for word in words]
+        if self.options['remove_duplicates']:
+            words = self.remove_duplicates(words)
+        if self.options['lowercase']:
+            words = lowercase(words)
+
+        return ' '.join(words)
+
+    @staticmethod
+    def remove_duplicates(words):
+
+        # Remove duplicate words while preserving order
+        word_counter = Counter(words)
+        seen = set()
+        cleaned_words = []
+
+        for word in words:
+            if word in seen and word_counter[word] > 1:
+                word_counter[word] -= 1
+            else:
+                cleaned_words.append(word)
+                seen.add(word)
+
+        return cleaned_words
+
+    @staticmethod
+    def count_duplicates_and_hyphenated(document, words):
+        word_counter = Counter(words)
+
+        document.number_of_duplicates = sum(count - 1 for count in word_counter.values() if count > 1)
+        document.number_of_hyphenated_words = sum(1 for word in words if '-' in word)
+
+
+def _remove_brackets_and_bracketcontent(text):
+    replacements = [
+        (r'\(.*?\)', ''),
+        (r'\<.*?\>', ''),
+        (r'\[.*?\]', ''),
+        (r'\{.*?\}', '')
+    ]
+    for old, new in replacements:
+        text = re.sub(old, new, text)
+    return text
+
+def remove_timestamps(text, example):
+    #removes timestamps with specified pattern
+    pattern = _detect_timestamp_pattern(example)
+    return re.sub(pattern, '', text)
+
+def _detect_timestamp_pattern(example):
+    pattern = re.escape(example)  # Escape special characters
+    pattern = re.sub(r'\d', r'\\d', pattern)  # Replace digits with \d
+    return pattern
+
+def lowercase(text):
+    if isinstance(text, str):
+        return text.lower()
+    elif isinstance(text, list):
+        return [token.lower() for token in text]
+    else:
+        raise ValueError("Input to _lowercase must be either a string or a list of tokens")
+
+def remove_punctuation(text):
+    if isinstance(text, str):
+        return text.translate(str.maketrans('', '', string.punctuation))
+    elif isinstance(text, list):
+        return [token.translate(str.maketrans('', '', string.punctuation)) for token in text]
+    else:
+        raise ValueError("Input to _remove_punctuation must be either a string or a list of tokens")
+
+def _remove_special_characters(text, characters_to_remove):
+    return text.translate(str.maketrans('', '', characters_to_remove))
+
+def remove_speaker_tags(text, speaker_tags):
+    pattern = re.compile(r'^(?:' + '|'.join(re.escape(tag) for tag in speaker_tags) + r'):\s*', re.MULTILINE)
+    return re.sub(pattern, '', text)
+
+def clean_subword_token_RoBERTa(token):
+    """Clean RoBERTa subword tokens.
+    
+    Args:
+        token: String token to clean
+    Returns:
+        Cleaned token or None if token should be ignored
+    """
+    # Special character mappings
+    char_mappings = {
+        '√§': 'ä',
+        '√º': 'ü',
+        '√∂': 'ö',
+        '√í': 'í'
+    }
+    
+    # Remove subword boundary marker
+    clean_token = token.replace("▁", "")
+    
+    # Replace special characters
+    for old, new in char_mappings.items():
+        clean_token = clean_token.replace(old, new)
+    
+    # Remove bracketed content
+    clean_token = re.sub(r"\[.*?\]|\(.*?\)", "", clean_token)
+    
+    # Keep only letters, numbers, and hyphens
+    clean_token = re.sub(r"[^A-Za-z0-9\u00C0-\u017F\-]", "", clean_token)
+    
+    return None if clean_token.isdigit() else clean_token.strip()
+
+
+def clean_token_generic(token):
+    """Generic token cleaning method for non-RoBERTa models.
+    This is a placeholder that should be implemented based on specific model needs.
+
+    Args:
+        token: String token to clean
+    Returns:
+        Cleaned token or None if token should be ignored
+    """
+    # TODO: Implement proper cleaning logic for other models
+    # For now, just return the token as is if it's not empty or None
+    return token.strip() if token and token.strip() else None