cedbox 0.1.0__py3-none-any.whl

cedbox/__init__.py

@@ -0,0 +1,13 @@
+"""
+CedBox - A Python utility package for data handling, input validation, Morse code processing, and audio generation.
+"""
+
+from cedbox.yggdrasil import Yggdrasil
+from cedbox.inputs import (
+    string_put, int_put, float_put, choice_put, 
+    bool_put, file_put, date_put, mail_put
+)
+from cedbox.easymorse import EasyMorse, MORSE_CODE_DICT
+from cedbox.easywav import EasyWav
+
+__version__ = "0.1.0"

cedbox/easymorse.py

@@ -0,0 +1,80 @@
+MORSE_CODE_DICT = {
+    'A': '.-', 'B': '-...',
+    'C': '-.-.', 'D': '-..', 'E': '.',
+    'F': '..-.', 'G': '--.', 'H': '....',
+    'I': '..', 'J': '.---', 'K': '-.-',
+    'L': '.-..', 'M': '--', 'N': '-.',
+    'O': '---', 'P': '.--.', 'Q': '--.-',
+    'R': '.-.', 'S': '...', 'T': '-',
+    'U': '..-', 'V': '...-', 'W': '.--',
+    'X': '-..-', 'Y': '-.--', 'Z': '--..',
+    '1': '.----', '2': '..---', '3': '...--',
+    '4': '....-', '5': '.....', '6': '-....',
+    '7': '--...', '8': '---..', '9': '----.',
+    '0': '-----', ', ': '--..--', '.': '.-.-.-',
+    '?': '..--..', '/': '-..-.', '-': '-....-',
+    '(': '-.--.', ')': '-.--.-', ':': '---...',
+}
+
+
+class EasyMorse:
+    """Class for creating and managing Morse code time units."""
+
+    def __init__(self, text, morse_dict=None, prefix:bool|str=False):
+        """
+        Initialize the MorseCodeTimes class.
+
+        Args:
+
+        """
+        morse_dict = morse_dict if morse_dict is not None else MORSE_CODE_DICT
+        morse_dict.update({' ': '_____'})
+        self.morse_dict = morse_dict
+        self.times_dict = self._create_times_dict()
+
+        if isinstance(prefix, bool):
+            self.prefix = "._._._-___._._._-___._._._-___-_._._._._-_____" if prefix else "" #VVV- as prefix
+        elif isinstance(prefix, str):
+            self.prefix = prefix
+
+        self.raw_text = text
+        self.text_to_morse = None
+        self.morse_code = None
+        self.morse_code_times = None
+        self.morse_message = None
+        self.morse_seq = None
+        self.set_text(text)
+
+
+    def _create_times_dict(self):
+        """
+        Convert Morse code dictionary to time units dictionary.
+
+        Returns:
+            dict: Dictionary mapping characters to tuples of time units.
+        """
+        times_dict = {
+            char: tuple(1 if c == '.' else 3 for c in code) 
+            for char, code in self.morse_dict.items()
+        }
+        times_dict.update({' ': (-5,)})
+        return times_dict
+
+
+    def set_text(self, raw_text: str):
+
+        self.raw_text = raw_text
+
+        self.text_to_morse = [char for char in self.raw_text.upper() if char in self.morse_dict]
+
+        morse_code = ['_'.join(self.morse_dict[char]) for char in self.text_to_morse]
+
+        self.morse_code = '___'.join(morse_code).replace('_______________', '_____')
+
+        self.morse_message = self.prefix + self.morse_code if self.prefix else self.morse_code
+
+        self.morse_seq = [{'.': 1, '-': 3, '_': -3}[char] for char in self.morse_message]
+
+if __name__ == "__main__":
+    morse = EasyMorse('KM km')
+    print(morse.morse_seq)

cedbox/easywav.py

@@ -0,0 +1,41 @@
+import wave
+import math
+import struct
+
+
+class EasyWav:
+    def __init__(self, sequence: list[int], sample_rate=44100, frequency=440, time_unit=100):
+        self.audio_samples: list[int] = []
+        self.sample_rate: int = sample_rate
+        self.frequency: int = frequency
+        sequence: list[int] = [time_unit*seq for seq in sequence]
+        self.sequence: list[int] = sequence
+        self.from_seq(sequence)
+
+    def _generate_samples(self, duration) -> list[int]:
+        if duration > 0:  # Signal
+            num_samples = int(abs(duration) * self.sample_rate / 1000)
+            return [int(32767 * math.sin(2 * math.pi * self.frequency * (float(i) / self.sample_rate)))
+                    for i in range(num_samples)]
+        else:  # Pause
+            num_samples = int(abs(duration) * self.sample_rate / 1000)
+            return [0] * num_samples
+
+    def from_seq(self, durations) -> None:
+        audio_samples = []
+        for duration in durations:
+            audio_samples.extend(self._generate_samples(duration))
+        self.audio_samples = audio_samples
+
+    def save(self, filename='output.wav') -> None:
+        with wave.open(filename, 'w') as wave_file:
+            wave_file.setnchannels(1)
+            wave_file.setsampwidth(2)
+            wave_file.setframerate(self.sample_rate)
+            wave_file.writeframes(struct.pack('h' * len(self.audio_samples), *self.audio_samples))
+
+
+if __name__ == '__main__':
+    data = [1, -1, 3, 1, -1, 3]
+    wav = EasyWav(sequence=data)
+    wav.save('output.wav')

cedbox/inputs.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+import pathlib
+import re
+import email.utils
+
+
+def string_put(text, max_times=None, times=1, default='') -> str:
+    raw_input = input(text)
+    if max_times and times == max_times:
+        print(f'Exceeded {max_times} Trys, using default Value {default}')
+        return default
+    else:
+        return raw_input
+
+
+def int_put(text, max_times=None, times=1, default=1, conditions=None) -> int:
+    if conditions is None:
+        conditions = []
+
+    raw_input = input(text)
+    try:
+        int_input = int(raw_input)
+        for condition in conditions:
+            assert condition(int_input)
+        return int_input
+    except Exception as e:
+        print(f'{raw_input} is not valid {e}')
+        if max_times and times >= max_times:
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        return int_put(text, max_times=max_times, times=times + 1, default=default, conditions=conditions)
+
+
+def float_put(text, max_times=None, times=1, default=1.0, conditions=None) -> float:
+    if conditions is None:
+        conditions = []
+
+    raw_input = input(text)
+    try:
+        float_input = float(raw_input)
+        for condition in conditions:
+            assert condition(float_input)
+        return float_input
+    except Exception as e:
+        print(f'{raw_input} is not valid {e}')
+        if max_times and times >= max_times:
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        return float_put(text, max_times=max_times, times=times + 1, default=default, conditions=conditions)
+
+
+def choice_put(text: str, choices: list, max_times=None, times=1, def_choice_by_index=1) -> str:
+    raw_input = input(text + f"({'/'.join(choices)})" + ': ')
+
+    if raw_input in choices:
+        return raw_input
+    else:
+        if max_times and times >= max_times:
+            default = choices[def_choice_by_index]
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        print(f'{raw_input} is not valid')
+        return choice_put(text, choices, max_times=max_times, times=times + 1, def_choice_by_index=def_choice_by_index)
+
+
+def bool_put(text: str, max_times=None, times=1, default=False) -> bool:
+    raw_input = choice_put(text, choices=['y', 'n'])
+
+    match raw_input:
+        case 'y':
+            return True
+        case 'n':
+            return False
+        case _:
+
+            print(f'{raw_input} is not valid')
+            return bool_put(text)
+
+
+def file_put(text, max_times=None, times=1, default=None):
+    raw_input = input(text).strip()
+
+    try:
+        path = pathlib.Path(raw_input)
+        assert path.exists()
+        return path
+    except Exception as e:
+        print(f'{raw_input} is not a valid Path: {e}')
+        if max_times and times >= max_times:
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        return file_put(text, max_times=max_times, times=times + 1, default=default)
+
+
+def date_put(text, max_times=None, times=1, default=None):
+    date_raw = input(f'{text}(YYYY-MM-DD)')
+
+    try:
+        date = datetime.strptime(date_raw, '%Y-%m-%d')
+    except Exception as e:
+        print(f'{date_raw} is not valid', e)
+        if max_times and times >= max_times:
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        return date_put(text, max_times=max_times, times=times + 1, default=default)
+    return date
+
+
+def mail_put(text, max_times=None, times=1, default=None):
+    email_str = input(text)
+    try:
+        email_address = email.utils.parseaddr(email_str)[1]
+        assert re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email_address)
+        return email_address
+    except Exception as e:
+        print(f'{email_str} is not valid', e)
+        if max_times and times >= max_times:
+            print(f'Exceeded {max_times} Trys, using default Value {default}')
+            return default
+        return mail_put(text, max_times=max_times, times=times + 1, default=default)

cedbox/yggdrasil.py

@@ -0,0 +1,223 @@
+import pandas as pd
+import sqlite3
+
+class Yggdrasil(dict):
+    def __init__(self, leaf_behavior='overwrite'):
+        """
+        Initialize a new Yggdrasil tree.
+
+        Args:
+            leaf_behavior (str or callable): How to handle duplicate leaf nodes.
+                If str, must be one of:
+                    'overwrite': Replace existing value (default)
+                    'append': Append to existing value if possible
+                    'add': Add to existing value if both are numeric
+                    'subtract': Subtract new value from existing value if both are numeric
+                    'multiply': Multiply with existing value if both are numeric
+                    'divide': Divide existing value by new value if both are numeric
+                If callable, must be a function that takes two arguments (existing_value, new_value)
+                and returns the value to be stored.
+        """
+        super().__init__()
+        self.leaf_behavior = leaf_behavior
+
+    def __getitem__(self, key):
+        if key not in self:
+            self[key] = self.__class__(leaf_behavior=self.leaf_behavior)
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, values=None):
+        if not isinstance(values, list) or not values:
+            # Handle leaf node behavior if the key already exists
+            if key in self and not isinstance(super().__getitem__(key), Yggdrasil):
+                existing_value = super().__getitem__(key)
+
+                # Check if leaf_behavior is a callable (custom function)
+                if callable(self.leaf_behavior):
+                    try:
+                        # Call the custom function with existing and new values
+                        new_value = self.leaf_behavior(existing_value, values)
+                        super().__setitem__(key, new_value)
+                    except Exception as e:
+                        # If the custom function fails, fall back to overwrite
+                        super().__setitem__(key, values)
+                # Apply the specified behavior
+                elif self.leaf_behavior == 'overwrite' or existing_value is None:
+                    # Default behavior - just overwrite
+                    super().__setitem__(key, values)
+                elif self.leaf_behavior == 'append':
+                    # Try to append values
+                    try:
+                        new_value = existing_value + values
+                        super().__setitem__(key, new_value)
+                    except (TypeError, ValueError):
+                        # If append fails, fall back to overwrite
+                        super().__setitem__(key, values)
+                elif self.leaf_behavior == 'add' and values is not None:
+                    # Try to add values numerically - only for numeric types
+                    if (isinstance(existing_value, (int, float)) and 
+                        isinstance(values, (int, float))):
+                        new_value = existing_value + values
+                        super().__setitem__(key, new_value)
+                    else:
+                        # For non-numeric types, fall back to overwrite
+                        super().__setitem__(key, values)
+                elif self.leaf_behavior == 'multiply' and values is not None:
+                    # Try to multiply values - only for numeric types
+                    if (isinstance(existing_value, (int, float)) and 
+                        isinstance(values, (int, float))):
+                        new_value = existing_value * values
+                        super().__setitem__(key, new_value)
+                    else:
+                        # For non-numeric types, fall back to overwrite
+                        super().__setitem__(key, values)
+                elif self.leaf_behavior == 'subtract' and values is not None:
+                    # Try to subtract values - only for numeric types
+                    if (isinstance(existing_value, (int, float)) and 
+                        isinstance(values, (int, float))):
+                        new_value = existing_value - values
+                        super().__setitem__(key, new_value)
+                    else:
+                        # For non-numeric types, fall back to overwrite
+                        super().__setitem__(key, values)
+                elif self.leaf_behavior == 'divide' and values is not None:
+                    # Try to divide values - only for numeric types
+                    if (isinstance(existing_value, (int, float)) and 
+                        isinstance(values, (int, float))):
+                        # Check for division by zero
+                        if values == 0:
+                            # For division by zero, fall back to overwrite
+                            super().__setitem__(key, values)
+                        else:
+                            new_value = existing_value / values
+                            super().__setitem__(key, new_value)
+                    else:
+                        # For non-numeric types, fall back to overwrite
+                        super().__setitem__(key, values)
+                else:
+                    # Unknown behavior or incompatible types, fall back to overwrite
+                    super().__setitem__(key, values)
+            else:
+                # Key doesn't exist or is a Yggdrasil instance, just set the value
+                super().__setitem__(key, values)
+            return
+
+        if key not in self:
+            super().__setitem__(key, self.__class__(leaf_behavior=self.leaf_behavior))
+
+        value = values.pop(0)
+        if values:
+            self[key].__setitem__(value, values)
+        else:
+            # When setting a leaf node, just set the value
+            # The behavior logic is already handled in the first part of this method
+            self[key] = value
+
+    def add_fiber(self, fiber):
+        """
+        Add a fiber (path) to the tree.
+
+        Args:
+            fiber: A list-like object or pandas Series representing a path in the tree.
+                  The first element is the root node, and subsequent elements form the path.
+        """
+        # Convert pandas Series to list if necessary
+        if isinstance(fiber, pd.Series):
+            fiber = fiber.tolist()
+
+        # Make a copy to avoid modifying the original
+        fiber_copy = fiber.copy() if hasattr(fiber, 'copy') else list(fiber)
+
+        sprout = fiber_copy.pop(0)
+        self[sprout] = fiber_copy
+
+    @classmethod
+    def from_dataframe(cls, df, leaf_behavior='overwrite'):
+        """
+        Create a new Yggdrasil tree from a pandas DataFrame.
+
+        Each row in the DataFrame will be added as a fiber to the tree.
+
+        Args:
+            df (pandas.DataFrame): The DataFrame to convert to a tree
+            leaf_behavior (str or callable): How to handle duplicate leaf nodes
+                                            (passed to Yggdrasil constructor)
+
+        Returns:
+            Yggdrasil: A new Yggdrasil tree containing the data from the DataFrame
+        """
+        tree = cls(leaf_behavior=leaf_behavior)
+
+        # Iterate through each row in the DataFrame
+        for _, row in df.iterrows():
+            # Add the row as a fiber to the tree
+            tree.add_fiber(row)
+
+        return tree
+
+    @classmethod
+    def from_sql(cls, query, connection, leaf_behavior='overwrite'):
+        """
+        Create a new Yggdrasil tree from a SQL query.
+
+        Executes the query and converts the result to a DataFrame,
+        then creates a tree from the DataFrame.
+
+        Args:
+            query (str): The SQL query to execute
+            connection: A database connection object (sqlite3.Connection, 
+                       psycopg2.connection, etc.) or a connection string
+            leaf_behavior (str or callable): How to handle duplicate leaf nodes
+                                            (passed to Yggdrasil constructor)
+
+        Returns:
+            Yggdrasil: A new Yggdrasil tree containing the data from the query result
+        """
+        # Handle different types of connections
+        if isinstance(connection, str):
+            # Assume it's a SQLite connection string
+            conn = sqlite3.connect(connection)
+            df = pd.read_sql_query(query, conn)
+            conn.close()
+        else:
+            # Assume it's an existing connection object
+            df = pd.read_sql_query(query, connection)
+
+        # Create a tree from the DataFrame
+        return cls.from_dataframe(df, leaf_behavior=leaf_behavior)
+
+    def print_tree(self, prefix="", is_root=True):
+        """
+        Print the tree structure like a directory tree with lines.
+
+        Args:
+            prefix (str): Prefix to use for the current line (for indentation)
+            is_root (bool): Whether this is the root of the tree
+        """
+        # Get all keys in the current level
+        keys = list(self.keys())
+
+        if is_root and not keys:
+            print("Empty tree")
+            return
+
+        # Process each key in the current level
+        for i, key in enumerate(keys):
+            is_last = i == len(keys) - 1
+            connector = "└── " if is_last else "├── "
+
+            # Print the current key with the appropriate connector
+            print(f"{prefix}{connector}{key}")
+
+            # Get the value for this key
+            value = self[key]
+
+            # Determine the prefix for the next level
+            next_prefix = prefix + ("    " if is_last else "│   ")
+
+            # If the value is another Yggdrasil instance, recursively print it
+            if isinstance(value, Yggdrasil):
+                value.print_tree(prefix=next_prefix, is_root=False)
+            # Otherwise, print the value as a leaf node
+            elif value is not None:
+                print(f"{next_prefix}└── {value}")

cedbox-0.1.0.dist-info/METADATA

@@ -0,0 +1,323 @@
+Metadata-Version: 2.4
+Name: cedbox
+Version: 0.1.0
+Summary: A Python utility package for data handling, input validation, Morse code processing, and audio generation
+Author: CedBox Authors
+License: MIT License
+        
+        Copyright (c) 2025 Cedric Sascha Wagner
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# CedBox
+
+CedBox is a Python utility package that provides various tools for data handling, user input validation, Morse code processing, and audio generation.
+
+## Features
+
+- **Yggdrasil**: A hierarchical tree-like data structure that extends Python's dictionary, with support for:
+  - Automatic node creation
+  - Loading data from DataFrames and SQL queries
+  - Tree visualization
+
+- **Input Utilities**: Functions for handling user input with validation and type conversion:
+  - String input
+  - Integer input with validation
+  - Float input with validation
+  - Choice selection
+  - Boolean (yes/no) input
+  - File path input with validation
+  - Date input with validation
+  - Email input with validation
+
+- **Morse Code Processing**: Tools for working with Morse code:
+  - Convert text to Morse code
+  - Represent Morse code as time units
+  - Generate Morse code sequences
+
+- **Audio Generation**: Utilities for creating WAV audio files:
+  - Generate audio signals from sequences of durations
+  - Create Morse code audio signals
+
+## Installation
+
+```bash
+pip install cedbox
+```
+
+## Usage Examples
+
+### Yggdrasil
+
+Yggdrasil is a hierarchical tree-like data structure that extends Python's dictionary with additional functionality.
+
+```python
+from cedbox import Yggdrasil
+import pandas as pd
+
+# Create a new tree
+tree = Yggdrasil()
+
+# Add data with automatic node creation
+tree['users']['john']['email'] = 'john@example.com'
+tree['users']['john']['age'] = 30
+tree['users']['jane']['email'] = 'jane@example.com'
+tree['users']['jane']['age'] = 28
+
+# Print tree structure
+tree.print_tree()
+```
+
+**Output:**
+```
+Yggdrasil
+├── users
+│   ├── john
+│   │   ├── email: john@example.com
+│   │   └── age: 30
+│   └── jane
+│       ├── email: jane@example.com
+│       └── age: 28
+```
+
+#### Creating from DataFrame
+
+```python
+# Create from DataFrame
+df = pd.DataFrame({
+    'name': ['John', 'Jane'],
+    'email': ['john@example.com', 'jane@example.com'],
+    'age': [30, 28]
+})
+tree_from_df = Yggdrasil.from_dataframe(df)
+tree_from_df.print_tree()
+```
+
+**Output:**
+```
+Yggdrasil
+├── 0
+│   ├── name: John
+│   ├── email: john@example.com
+│   └── age: 30
+└── 1
+    ├── name: Jane
+    ├── email: jane@example.com
+    └── age: 28
+```
+
+#### Creating from SQL Query
+
+```python
+import sqlite3
+
+# Create a sample database
+conn = sqlite3.connect(':memory:')
+cursor = conn.cursor()
+cursor.execute('CREATE TABLE users (name TEXT, email TEXT, age INTEGER)')
+cursor.execute('INSERT INTO users VALUES ("John", "john@example.com", 30)')
+cursor.execute('INSERT INTO users VALUES ("Jane", "jane@example.com", 28)')
+conn.commit()
+
+# Create tree from SQL query
+tree_from_sql = Yggdrasil.from_sql("SELECT * FROM users", conn)
+tree_from_sql.print_tree()
+```
+
+**Output:**
+```
+Yggdrasil
+├── 0
+│   ├── name: John
+│   ├── email: john@example.com
+│   └── age: 30
+└── 1
+    ├── name: Jane
+    ├── email: jane@example.com
+    └── age: 28
+```
+
+### Input Utilities
+
+CedBox provides various functions for handling user input with validation and type conversion.
+
+```python
+from cedbox.inputs import (
+    string_put, int_put, float_put, choice_put, 
+    bool_put, file_put, date_put, mail_put
+)
+
+# String input
+name = string_put("Enter your name: ")
+# User enters: John
+print(f"Hello, {name}!")
+# Output: Hello, John!
+
+# Integer input with validation
+age = int_put(
+    "Enter your age: ", 
+    conditions=[lambda x: x > 0, lambda x: x < 120],
+    max_times=3,
+    default=30
+)
+# User enters: -5
+# Output: -5 is not valid assert lambda x: x > 0
+# User enters: 25
+print(f"You are {age} years old.")
+# Output: You are 25 years old.
+
+# Float input with validation
+height = float_put(
+    "Enter your height in meters: ",
+    conditions=[lambda x: 0.5 < x < 2.5],
+    default=1.75
+)
+# User enters: 1.85
+print(f"Your height is {height} meters.")
+# Output: Your height is 1.85 meters.
+
+# Choice selection
+color = choice_put("Select a color ", choices=['red', 'green', 'blue'])
+# Output: Select a color (red/green/blue): 
+# User enters: yellow
+# Output: yellow is not valid
+# User enters: red
+print(f"You selected {color}.")
+# Output: You selected red.
+
+# Boolean input
+confirm = bool_put("Confirm? ")
+# Output: Confirm? (y/n): 
+# User enters: y
+print(f"Confirmed: {confirm}")
+# Output: Confirmed: True
+```
+
+### Morse Code Processing
+
+The EasyMorse class provides tools for working with Morse code.
+
+```python
+from cedbox import EasyMorse, MORSE_CODE_DICT
+
+# Create Morse code from text
+morse = EasyMorse("SOS")
+print(f"Original text: {morse.raw_text}")
+# Output: Original text: SOS
+
+print(f"Morse code: {morse.morse_code}")
+# Output: Morse code: ._._.____-_-_-___._._._
+
+# View the time sequence (1=dot, 3=dash, -3=pause between symbols)
+print(f"Time sequence: {morse.morse_seq}")
+# Output: Time sequence: [1, 1, 1, -3, 3, 3, 3, -3, 1, 1, 1]
+
+# Create with custom prefix (VVV- is a common Morse prefix)
+morse_with_prefix = EasyMorse("HELLO", prefix=True)
+print(f"With prefix: {morse_with_prefix.morse_message}")
+# Output: With prefix: ._._._-___._._._-___._._._-___-_._._._._-_____._._._.___._____._____._._..___._..___._..___---
+```
+
+### Audio Generation
+
+The EasyWav class allows you to create WAV audio files from sequences of durations.
+
+```python
+from cedbox import EasyMorse, EasyWav
+
+# Create Morse code sequence for "SOS"
+morse = EasyMorse("SOS")
+sequence = morse.morse_seq
+print(f"Morse sequence: {sequence}")
+# Output: Morse sequence: [1, 1, 1, -3, 3, 3, 3, -3, 1, 1, 1]
+
+# Generate WAV file from sequence
+wav = EasyWav(
+    sequence=sequence,
+    frequency=800,  # 800 Hz tone
+    time_unit=100   # 100ms per unit
+)
+wav.save('morse_sos.wav')
+print("Audio file created: morse_sos.wav")
+# Output: Audio file created: morse_sos.wav
+
+# Create a more complex audio pattern
+custom_sequence = [1, -1, 3, -1, 1, -3, 5, -5]  # Custom pattern of tones and pauses
+wav = EasyWav(
+    sequence=custom_sequence,
+    frequency=440,  # A4 note
+    sample_rate=48000  # Higher quality
+)
+wav.save('custom_pattern.wav')
+```
+
+## Complete Example: Morse Code Converter
+
+Here's a complete example that combines multiple components to create a Morse code converter:
+
+```python
+from cedbox import EasyMorse, EasyWav, string_put
+
+def morse_converter():
+    # Get input text from user
+    text = string_put("Enter text to convert to Morse code: ")
+
+    # Convert to Morse code
+    morse = EasyMorse(text, prefix=True)
+
+    print(f"Text: {morse.raw_text}")
+    print(f"Morse code: {morse.morse_code}")
+
+    # Generate audio file
+    wav = EasyWav(
+        sequence=morse.morse_seq,
+        frequency=800,
+        time_unit=80  # Faster speed
+    )
+
+    filename = f"morse_{text.replace(' ', '_')}.wav"
+    wav.save(filename)
+    print(f"Audio saved to {filename}")
+
+    return morse, filename
+
+# Run the converter
+morse_result, audio_file = morse_converter()
+```
+
+## Dependencies
+
+- pandas >= 2.0.0
+- setuptools == 80.9.0
+- pytest (for testing)
+
+## License
+
+See the [LICENSE](LICENSE) file for details.

cedbox-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cedbox/__init__.py,sha256=SO6IsIVwnWzy0Jfd7YKUmFZ7JjH-wlqP9vw5HyNJRAs,400
+cedbox/easymorse.py,sha256=s7L-T-IjCVVNvehusQPJemdoLdLX5XzQyV4AQsz2Tig,2597
+cedbox/easywav.py,sha256=aghh8nxuCIqmOvT57amnV_xBSkC8ifDTv6NbVoNihs4,1534
+cedbox/inputs.py,sha256=1e-fJn6cAEApnaygmkTwFlIyFtm0uGj9jZGNG-IVzEM,4157
+cedbox/yggdrasil.py,sha256=hrIrxefewEZl_ob-NWZrsnEzGiwfmIv3tOtIzuN0Buo,9889
+cedbox-0.1.0.dist-info/licenses/LICENSE,sha256=Oau7wCqSC3IKMHCKRO1vQnkFIfBQV5C8dv3_0cmssRY,1076
+cedbox-0.1.0.dist-info/METADATA,sha256=70FzcHnRt_JrD1sIdEG3DGe5VL30NVY2rC1PSclIn5A,8936
+cedbox-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cedbox-0.1.0.dist-info/top_level.txt,sha256=sldRWrukvac7nL5qTyloLvUUuCQgUyCET8tXq8fKyxo,7
+cedbox-0.1.0.dist-info/RECORD,,

cedbox-0.1.0.dist-info/WHEEL

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

cedbox-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedric Sascha Wagner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cedbox-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cedbox