modular 0.1.0__tar.gz → 0.2.0__tar.gz

{modular-0.1.0 → modular-0.2.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Jeffrey Spies
+Copyright (c) 2011-2025 Jeffrey Spies
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

modular-0.2.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: modular
+Version: 0.2.0
+Summary: A modular package for all sorts of things where you want choices
+Author-email: Jeffrey Spies <code@jeffspies.com>
+Project-URL: Homepage, https://github.com/221b-io/modular
+Project-URL: Bug Tracker, https://github.com/221b-io/modular/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Dynamic: license-file
+
+# Modular
+
+The code you will see here will be a set of two sorts: 
+- utilities to abstract core functionality (e.g., document/object storage) in such a way that said functionality can be referred to in a standardized, serializable way, while handling the implementation-specific stuff (e.g., MongoDB, postgres)--including versioning--as purely config that exists far-removed from the code
+- some handy tools crafted in a standardized, serializable way, like the `tables` module below, that will also serve as examples of the approach
+
+Why modular?
+- It helps devs write clean, readable, configurable code.
+- Actions are easily loggable--something taken for granted in highly asynchronous codebases.
+- Because code is inherently configurable, environment management is much simpler.
+- You can help avoid lock-in, either because you want to choose the best performing tool for the job and easily switch as needed or because e.g., pricing, license, priorities, or principles of a tool changes.
+
+Use this a dependency injection (DI) framework? Yes and no. But yes.
+
+## History
+
+I brought two of these into my dissertation project, which then became the flagship product of the non-profit I co-founded: the Open Science Framework. These were [`modular-odm`](https://github.com/cos-archives/modular-odm) and [`modular-file renderer`](https://github.com/CenterForOpenScience/modular-file-renderer). The latter is still used today; the former, while used heavily at COS, never reached its full potential. That may now change. The goal was to use abstraction to maximize choice and minimize lock-in.
+
+## Installation
+
+```bash
+pip install modular
+```
+
+## Features
+
+### Tables Module
+
+The `tables` module provides a flexible system for normalizing and formatting tabular data. It consists of three main components:
+
+1. **Data Normalization** (`normalize_table`): Converts various input formats into a standardized table structure
+2. **Format Converters**: Built-in formatters for common output formats
+3. **High-level Table Function**: Combines normalization and formatting in one step
+
+#### Supported Formats:
+- Delimited (CSV, TSV, etc.)
+- Markdown
+- reStructuredText
+- Custom formats through formatter functions
+
+## Usage
+
+### Basic Usage
+
+The simplest way to create formatted tables is using the `table` function:
+
+```python
+from modular.tables import table, markdown, delimited, rst
+
+data = [
+    {"name": "Alice", "age": 30, "salary": 50000.123},
+    {"name": "Bob", "age": 25, "salary": 60000.456}
+]
+
+# Convert to Markdown
+md_table = table(data, formatter=markdown)
+
+# Convert to CSV
+csv_table = table(data, formatter=delimited)
+
+# Convert to TSV
+tsv_table = table(data, formatter=lambda t: delimited(t, delimiter='\t'))
+
+# Convert to reStructuredText
+rst_table = table(data, formatter=rst)
+```
+
+### Advanced Features
+
+#### Column Ordering
+
+Control the order of columns in the output:
+
+```python
+md_table = table(
+    data,
+    formatter=markdown,
+    order=['name', 'city', 'age']
+)
+```
+
+#### Value Formatting
+
+Apply format strings to specific columns or set a default format for all numeric values:
+
+```python
+# Format specific columns
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', '{:d}', '${:.2f}']  # string, integer, currency format
+)
+
+# Set default number format for all numeric values
+md_table = table(
+    data,
+    formatter=markdown,
+    default_number_format='{:.3f}'  # 3 decimal places for all numbers
+)
+
+# Combine both
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', None, '${:.2f}'],  # Use default_number_format where None
+    default_number_format='{:.3f}'
+)
+```
+
+#### Custom Headers
+
+Specify custom column headers:
+
+```python
+data = [
+    ['Alice', 30, 50000.123],
+    ['Bob', 25, 60000.456]
+]
+
+md_table = table(
+    data,
+    formatter=markdown,
+    header=['Name', 'Age', 'Salary']
+)
+```
+
+#### Custom Formatters
+
+Create your own formatters for custom output formats:
+
+```python
+def html_formatter(table):
+    if not table['data']:
+        return ""
+    
+    html = "<table>\n"
+    # Header row
+    html += "  <tr>\n"
+    for header in table['header']:
+        html += f"    <th>{header}</th>\n"
+    html += "  </tr>\n"
+    # Data rows
+    for row in table['data']:
+        html += "  <tr>\n"
+        for cell in row:
+            html += f"    <td>{cell}</td>\n"
+        html += "  </tr>\n"
+    html += "</table>"
+    return html
+
+html_table = table(data, formatter=html_formatter)
+```
+
+### Low-level API
+
+If you need more control, you can use the lower-level functions directly:
+
+```python
+from modular.tables import normalize_table, markdown
+
+# First normalize the data
+normalized = normalize_table(
+    data,
+    header=['Name', 'Age', 'Salary'],
+    order=['Name', 'Salary', 'Age'],
+    cell_formats=['{:s}', '{:d}', '{:.2f}']
+)
+
+# Then convert to desired format
+md_table = markdown(normalized)
+```
+
+## Development
+
+To install the package in development mode:
+
+```bash
+git clone https://github.com/yourusername/modular.git
+cd modular
+pip install -e .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest tests/tables/
+
+# Run specific test file
+pytest tests/tables/test_table.py
+
+# Run specific test class
+pytest tests/tables/test_table.py::TestBuiltinFormatters
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

modular-0.2.0/README.md

@@ -0,0 +1,198 @@
+# Modular
+
+The code you will see here will be a set of two sorts: 
+- utilities to abstract core functionality (e.g., document/object storage) in such a way that said functionality can be referred to in a standardized, serializable way, while handling the implementation-specific stuff (e.g., MongoDB, postgres)--including versioning--as purely config that exists far-removed from the code
+- some handy tools crafted in a standardized, serializable way, like the `tables` module below, that will also serve as examples of the approach
+
+Why modular?
+- It helps devs write clean, readable, configurable code.
+- Actions are easily loggable--something taken for granted in highly asynchronous codebases.
+- Because code is inherently configurable, environment management is much simpler.
+- You can help avoid lock-in, either because you want to choose the best performing tool for the job and easily switch as needed or because e.g., pricing, license, priorities, or principles of a tool changes.
+
+Use this a dependency injection (DI) framework? Yes and no. But yes.
+
+## History
+
+I brought two of these into my dissertation project, which then became the flagship product of the non-profit I co-founded: the Open Science Framework. These were [`modular-odm`](https://github.com/cos-archives/modular-odm) and [`modular-file renderer`](https://github.com/CenterForOpenScience/modular-file-renderer). The latter is still used today; the former, while used heavily at COS, never reached its full potential. That may now change. The goal was to use abstraction to maximize choice and minimize lock-in.
+
+## Installation
+
+```bash
+pip install modular
+```
+
+## Features
+
+### Tables Module
+
+The `tables` module provides a flexible system for normalizing and formatting tabular data. It consists of three main components:
+
+1. **Data Normalization** (`normalize_table`): Converts various input formats into a standardized table structure
+2. **Format Converters**: Built-in formatters for common output formats
+3. **High-level Table Function**: Combines normalization and formatting in one step
+
+#### Supported Formats:
+- Delimited (CSV, TSV, etc.)
+- Markdown
+- reStructuredText
+- Custom formats through formatter functions
+
+## Usage
+
+### Basic Usage
+
+The simplest way to create formatted tables is using the `table` function:
+
+```python
+from modular.tables import table, markdown, delimited, rst
+
+data = [
+    {"name": "Alice", "age": 30, "salary": 50000.123},
+    {"name": "Bob", "age": 25, "salary": 60000.456}
+]
+
+# Convert to Markdown
+md_table = table(data, formatter=markdown)
+
+# Convert to CSV
+csv_table = table(data, formatter=delimited)
+
+# Convert to TSV
+tsv_table = table(data, formatter=lambda t: delimited(t, delimiter='\t'))
+
+# Convert to reStructuredText
+rst_table = table(data, formatter=rst)
+```
+
+### Advanced Features
+
+#### Column Ordering
+
+Control the order of columns in the output:
+
+```python
+md_table = table(
+    data,
+    formatter=markdown,
+    order=['name', 'city', 'age']
+)
+```
+
+#### Value Formatting
+
+Apply format strings to specific columns or set a default format for all numeric values:
+
+```python
+# Format specific columns
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', '{:d}', '${:.2f}']  # string, integer, currency format
+)
+
+# Set default number format for all numeric values
+md_table = table(
+    data,
+    formatter=markdown,
+    default_number_format='{:.3f}'  # 3 decimal places for all numbers
+)
+
+# Combine both
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', None, '${:.2f}'],  # Use default_number_format where None
+    default_number_format='{:.3f}'
+)
+```
+
+#### Custom Headers
+
+Specify custom column headers:
+
+```python
+data = [
+    ['Alice', 30, 50000.123],
+    ['Bob', 25, 60000.456]
+]
+
+md_table = table(
+    data,
+    formatter=markdown,
+    header=['Name', 'Age', 'Salary']
+)
+```
+
+#### Custom Formatters
+
+Create your own formatters for custom output formats:
+
+```python
+def html_formatter(table):
+    if not table['data']:
+        return ""
+    
+    html = "<table>\n"
+    # Header row
+    html += "  <tr>\n"
+    for header in table['header']:
+        html += f"    <th>{header}</th>\n"
+    html += "  </tr>\n"
+    # Data rows
+    for row in table['data']:
+        html += "  <tr>\n"
+        for cell in row:
+            html += f"    <td>{cell}</td>\n"
+        html += "  </tr>\n"
+    html += "</table>"
+    return html
+
+html_table = table(data, formatter=html_formatter)
+```
+
+### Low-level API
+
+If you need more control, you can use the lower-level functions directly:
+
+```python
+from modular.tables import normalize_table, markdown
+
+# First normalize the data
+normalized = normalize_table(
+    data,
+    header=['Name', 'Age', 'Salary'],
+    order=['Name', 'Salary', 'Age'],
+    cell_formats=['{:s}', '{:d}', '{:.2f}']
+)
+
+# Then convert to desired format
+md_table = markdown(normalized)
+```
+
+## Development
+
+To install the package in development mode:
+
+```bash
+git clone https://github.com/yourusername/modular.git
+cd modular
+pip install -e .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest tests/tables/
+
+# Run specific test file
+pytest tests/tables/test_table.py
+
+# Run specific test class
+pytest tests/tables/test_table.py::TestBuiltinFormatters
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

modular-0.2.0/modular/__init__.py

@@ -0,0 +1,5 @@
+"""
+Modular package
+"""
+
+__version__ = "0.1.0" 

modular-0.2.0/modular/tables/__init__.py

@@ -0,0 +1,9 @@
+"""
+Table conversion utilities for various formats.
+"""
+
+from .normalize import normalize_table
+from .converters import delimited, markdown, rst
+from .table import table
+
+__all__ = ['table', 'normalize_table', 'delimited', 'markdown', 'rst']  

modular-0.2.0/modular/tables/converters.py

@@ -0,0 +1,82 @@
+"""
+Table conversion functions for various formats.
+"""
+
+from typing import Dict, List, Any
+import csv
+from io import StringIO
+
+def delimited(table: Dict[str, List], delimiter: str = ',') -> str:
+    """
+    Convert normalized table data to a delimited string format.
+    
+    Args:
+        table: Dictionary with 'header' and 'data' keys from normalize_table
+        delimiter: Character to use as delimiter (default: ',')
+        
+    Returns:
+        String containing the delimited data
+    """
+    if not table['data']:
+        return ""
+        
+    output = StringIO(newline='')  # Set newline='' to control line endings
+    writer = csv.writer(output, delimiter=delimiter, lineterminator='\n')  # Explicitly set line endings
+    writer.writerow(table['header'])
+    writer.writerows(table['data'])
+    return output.getvalue()
+
+def markdown(table: Dict[str, List]) -> str:
+    """
+    Convert normalized table data to Markdown table format.
+    
+    Args:
+        table: Dictionary with 'header' and 'data' keys from normalize_table
+        
+    Returns:
+        String containing the Markdown table
+    """
+    if not table['data']:
+        return ""
+        
+    # Create header row
+    markdown = "| " + " | ".join(str(h) for h in table['header']) + " |\n"
+    # Create separator row
+    markdown += "| " + " | ".join(["---"] * len(table['header'])) + " |\n"
+    # Add data rows
+    for row in table['data']:
+        markdown += "| " + " | ".join(str(cell) for cell in row) + " |\n"
+    
+    return markdown
+
+def rst(table: Dict[str, List]) -> str:
+    """
+    Convert normalized table data to reStructuredText table format.
+    
+    Args:
+        table: Dictionary with 'header' and 'data' keys from normalize_table
+        
+    Returns:
+        String containing the reStructuredText table
+    """
+    if not table['data']:
+        return ""
+        
+    # Calculate column widths
+    headers = [str(h) for h in table['header']]
+    data = [[str(cell) for cell in row] for row in table['data']]
+    
+    col_widths = [max(len(str(cell)) for cell in col) 
+                 for col in zip(headers, *data)]
+    
+    # Create header row
+    rst = "+" + "+".join("-" * (width + 2) for width in col_widths) + "+\n"
+    rst += "|" + "|".join(f" {header:<{width}} " for header, width in zip(headers, col_widths)) + "|\n"
+    rst += "+" + "+".join("=" * (width + 2) for width in col_widths) + "+\n"
+    
+    # Add data rows
+    for row in data:
+        rst += "|" + "|".join(f" {cell:<{width}} " for cell, width in zip(row, col_widths)) + "|\n"
+    rst += "+" + "+".join("-" * (width + 2) for width in col_widths) + "+\n"
+    
+    return rst 

modular-0.2.0/modular/tables/normalize.py

@@ -0,0 +1,104 @@
+from typing import List, Dict, Union, Optional, Any
+import numbers
+
+def normalize_table(
+    data: Union[List[Dict[str, Any]], List[List[Any]]],
+    header: Optional[List[str]] = None,
+    order: Optional[List[str]] = None,
+    cell_formats: Optional[List[str]] = None,
+    default_number_format: str = "{:.2f}"
+) -> Dict[str, List]:
+    """
+    Normalize different data formats into a consistent table structure with formatting options.
+    
+    Args:
+        data: List of dictionaries or list of lists containing the table data
+        header: Optional list of column names. If None and data is list of dicts,
+               will use dict keys as header
+        order: Optional list of column names/keys to specify column order
+        cell_formats: Optional list of format strings to apply to each column
+        default_number_format: Format string to apply to numeric values when no
+                             cell_formats specified
+    
+    Returns:
+        Dictionary with keys:
+            'data': List of lists containing the normalized table data
+            'header': List of column names
+    """
+    if not data:
+        return {'data': [], 'header': []}
+        
+    # Handle list of dictionaries
+    if isinstance(data[0], dict):
+        if header is None:
+            # Use keys from first dictionary to establish initial order
+            header = list(data[0].keys())
+            # Add any additional keys from other dictionaries
+            for d in data[1:]:
+                for key in d.keys():
+                    if key not in header:
+                        header.append(key)
+        
+        # Convert dicts to lists based on header order
+        table_data = [
+            [row.get(col, '') for col in header]
+            for row in data
+        ]
+            
+    # Handle list of lists
+    else:
+        if header is None:
+            # Generate numeric headers
+            header = [str(i) for i in range(len(data[0]))]
+        table_data = list(data)  # Make a copy to avoid modifying input
+
+    # Apply ordering if specified
+    if order:
+        # Create mapping of current positions
+        current_positions = {h: i for i, h in enumerate(header)}
+        
+        # Create new header order
+        new_header = []
+        # First add specified columns in order
+        for h in order:
+            if h in header:
+                new_header.append(h)
+        # Then add any remaining columns
+        new_header.extend(h for h in header if h not in new_header)
+        
+        # Create mapping for reordering data
+        reorder_indices = [current_positions[h] for h in new_header]
+        
+        # Reorder the data
+        table_data = [
+            [row[i] for i in reorder_indices]
+            for row in table_data
+        ]
+        
+        header = new_header
+            
+    # Apply formatting
+    if cell_formats or default_number_format != "{:.2f}":  # Apply if cell_formats provided or custom default_number_format
+        # Use cell_formats if provided, otherwise use default_number_format for all columns
+        formats = cell_formats if cell_formats else [default_number_format] * len(header)
+        # Ensure formats matches number of columns
+        formats = (formats + [default_number_format] * len(header))[:len(header)]
+        
+        formatted_data = []
+        for row in table_data:
+            formatted_row = []
+            for value, fmt in zip(row, formats):
+                if isinstance(value, numbers.Number):
+                    try:
+                        formatted_row.append(fmt.format(value))
+                    except ValueError:
+                        formatted_row.append(default_number_format.format(value))
+                else:
+                    formatted_row.append(str(value))
+            formatted_data.append(formatted_row)
+        table_data = formatted_data
+            
+    return {
+        'data': table_data,
+        'header': header
+    } 

modular-0.2.0/modular/tables/table.py

@@ -0,0 +1,37 @@
+from typing import List, Dict, Union, Optional, Any, Callable
+import numbers
+from .normalize import normalize_table
+
+def table(
+    data: Union[List[Dict[str, Any]], List[List[Any]]],
+    formatter: Callable[[Dict[str, List]], str],
+    header: Optional[List[str]] = None,
+    order: Optional[List[str]] = None,
+    cell_formats: Optional[List[str]] = None,
+    default_number_format: str = "{:.2f}"
+) -> str:
+    """
+    Create a formatted table from input data.
+    
+    Args:
+        data: List of dictionaries or list of lists containing the table data
+        formatter: Function that takes a normalized table dict and returns formatted string
+        header: Optional list of column names. If None and data is list of dicts,
+               will use dict keys as header
+        order: Optional list of column names/keys to specify column order
+        cell_formats: Optional list of format strings to apply to each column
+        default_number_format: Format string to apply to numeric values when no
+                             cell_formats specified
+    
+    Returns:
+        String containing the formatted table
+    """
+    normalized = normalize_table(
+        data=data,
+        header=header,
+        order=order,
+        cell_formats=cell_formats,
+        default_number_format=default_number_format
+    )
+    
+    return formatter(normalized) 

modular-0.2.0/modular.egg-info/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: modular
+Version: 0.2.0
+Summary: A modular package for all sorts of things where you want choices
+Author-email: Jeffrey Spies <code@jeffspies.com>
+Project-URL: Homepage, https://github.com/221b-io/modular
+Project-URL: Bug Tracker, https://github.com/221b-io/modular/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0; extra == "test"
+Dynamic: license-file
+
+# Modular
+
+The code you will see here will be a set of two sorts: 
+- utilities to abstract core functionality (e.g., document/object storage) in such a way that said functionality can be referred to in a standardized, serializable way, while handling the implementation-specific stuff (e.g., MongoDB, postgres)--including versioning--as purely config that exists far-removed from the code
+- some handy tools crafted in a standardized, serializable way, like the `tables` module below, that will also serve as examples of the approach
+
+Why modular?
+- It helps devs write clean, readable, configurable code.
+- Actions are easily loggable--something taken for granted in highly asynchronous codebases.
+- Because code is inherently configurable, environment management is much simpler.
+- You can help avoid lock-in, either because you want to choose the best performing tool for the job and easily switch as needed or because e.g., pricing, license, priorities, or principles of a tool changes.
+
+Use this a dependency injection (DI) framework? Yes and no. But yes.
+
+## History
+
+I brought two of these into my dissertation project, which then became the flagship product of the non-profit I co-founded: the Open Science Framework. These were [`modular-odm`](https://github.com/cos-archives/modular-odm) and [`modular-file renderer`](https://github.com/CenterForOpenScience/modular-file-renderer). The latter is still used today; the former, while used heavily at COS, never reached its full potential. That may now change. The goal was to use abstraction to maximize choice and minimize lock-in.
+
+## Installation
+
+```bash
+pip install modular
+```
+
+## Features
+
+### Tables Module
+
+The `tables` module provides a flexible system for normalizing and formatting tabular data. It consists of three main components:
+
+1. **Data Normalization** (`normalize_table`): Converts various input formats into a standardized table structure
+2. **Format Converters**: Built-in formatters for common output formats
+3. **High-level Table Function**: Combines normalization and formatting in one step
+
+#### Supported Formats:
+- Delimited (CSV, TSV, etc.)
+- Markdown
+- reStructuredText
+- Custom formats through formatter functions
+
+## Usage
+
+### Basic Usage
+
+The simplest way to create formatted tables is using the `table` function:
+
+```python
+from modular.tables import table, markdown, delimited, rst
+
+data = [
+    {"name": "Alice", "age": 30, "salary": 50000.123},
+    {"name": "Bob", "age": 25, "salary": 60000.456}
+]
+
+# Convert to Markdown
+md_table = table(data, formatter=markdown)
+
+# Convert to CSV
+csv_table = table(data, formatter=delimited)
+
+# Convert to TSV
+tsv_table = table(data, formatter=lambda t: delimited(t, delimiter='\t'))
+
+# Convert to reStructuredText
+rst_table = table(data, formatter=rst)
+```
+
+### Advanced Features
+
+#### Column Ordering
+
+Control the order of columns in the output:
+
+```python
+md_table = table(
+    data,
+    formatter=markdown,
+    order=['name', 'city', 'age']
+)
+```
+
+#### Value Formatting
+
+Apply format strings to specific columns or set a default format for all numeric values:
+
+```python
+# Format specific columns
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', '{:d}', '${:.2f}']  # string, integer, currency format
+)
+
+# Set default number format for all numeric values
+md_table = table(
+    data,
+    formatter=markdown,
+    default_number_format='{:.3f}'  # 3 decimal places for all numbers
+)
+
+# Combine both
+md_table = table(
+    data,
+    formatter=markdown,
+    cell_formats=['{:s}', None, '${:.2f}'],  # Use default_number_format where None
+    default_number_format='{:.3f}'
+)
+```
+
+#### Custom Headers
+
+Specify custom column headers:
+
+```python
+data = [
+    ['Alice', 30, 50000.123],
+    ['Bob', 25, 60000.456]
+]
+
+md_table = table(
+    data,
+    formatter=markdown,
+    header=['Name', 'Age', 'Salary']
+)
+```
+
+#### Custom Formatters
+
+Create your own formatters for custom output formats:
+
+```python
+def html_formatter(table):
+    if not table['data']:
+        return ""
+    
+    html = "<table>\n"
+    # Header row
+    html += "  <tr>\n"
+    for header in table['header']:
+        html += f"    <th>{header}</th>\n"
+    html += "  </tr>\n"
+    # Data rows
+    for row in table['data']:
+        html += "  <tr>\n"
+        for cell in row:
+            html += f"    <td>{cell}</td>\n"
+        html += "  </tr>\n"
+    html += "</table>"
+    return html
+
+html_table = table(data, formatter=html_formatter)
+```
+
+### Low-level API
+
+If you need more control, you can use the lower-level functions directly:
+
+```python
+from modular.tables import normalize_table, markdown
+
+# First normalize the data
+normalized = normalize_table(
+    data,
+    header=['Name', 'Age', 'Salary'],
+    order=['Name', 'Salary', 'Age'],
+    cell_formats=['{:s}', '{:d}', '{:.2f}']
+)
+
+# Then convert to desired format
+md_table = markdown(normalized)
+```
+
+## Development
+
+To install the package in development mode:
+
+```bash
+git clone https://github.com/yourusername/modular.git
+cd modular
+pip install -e .
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pytest tests/tables/
+
+# Run specific test file
+pytest tests/tables/test_table.py
+
+# Run specific test class
+pytest tests/tables/test_table.py::TestBuiltinFormatters
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

{modular-0.1.0 → modular-0.2.0}/modular.egg-info/SOURCES.txt

@@ -5,6 +5,9 @@ modular/__init__.py
 modular.egg-info/PKG-INFO
 modular.egg-info/SOURCES.txt
 modular.egg-info/dependency_links.txt
+modular.egg-info/requires.txt
 modular.egg-info/top_level.txt
 modular/tables/__init__.py
-modular/tables/converters.py
+modular/tables/converters.py
+modular/tables/normalize.py
+modular/tables/table.py

modular-0.2.0/modular.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[test]
+pytest>=7.0
+pytest-cov>=4.0

{modular-0.1.0 → modular-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modular"
-version = "0.1.0"
+version = "0.2.0"
 authors = [
     { name = "Jeffrey Spies", email = "code@jeffspies.com" },
 ]
@@ -18,5 +18,11 @@ classifiers = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/yourusername/modular"
-"Bug Tracker" = "https://github.com/yourusername/modular/issues" 
+"Homepage" = "https://github.com/221b-io/modular"
+"Bug Tracker" = "https://github.com/221b-io/modular/issues"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+] 

modular-0.1.0/PKG-INFO

@@ -1,92 +0,0 @@
-Metadata-Version: 2.4
-Name: modular
-Version: 0.1.0
-Summary: A modular package for all sorts of things where you want choices
-Author-email: Jeffrey Spies <code@jeffspies.com>
-Project-URL: Homepage, https://github.com/yourusername/modular
-Project-URL: Bug Tracker, https://github.com/yourusername/modular/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Modular
-
-A Python package for various data processing utilities with a focus on modularity and choice.
-
-## Installation
-
-```bash
-pip install modular
-```
-
-## Features
-
-### Tables Module
-
-The `tables` module provides functions to convert data into various table formats.
-
-#### Supported Formats:
-- Delimited (CSV, TSV, etc.)
-- Markdown
-- reStructuredText
-
-## Usage
-
-### Converting Data to Different Formats
-
-```python
-from modular.tables import to_delimited, to_markdown, to_rst
-
-# Example data as a list of dictionaries
-data_dict = [
-    {"name": "Alice", "age": 30, "city": "New York"},
-    {"name": "Bob", "age": 25, "city": "Los Angeles"},
-    {"name": "Charlie", "age": 35, "city": "Chicago"}
-]
-
-# Convert to CSV
-csv_output = to_delimited(data_dict)
-print(csv_output)
-
-# Convert to TSV
-tsv_output = to_delimited(data_dict, delimiter='\t')
-print(tsv_output)
-
-# Convert to Markdown
-md_output = to_markdown(data_dict)
-print(md_output)
-
-# Convert to reStructuredText
-rst_output = to_rst(data_dict)
-print(rst_output)
-```
-
-You can also use lists of lists:
-
-```python
-data_list = [
-    ["Alice", 30, "New York"],
-    ["Bob", 25, "Los Angeles"],
-    ["Charlie", 35, "Chicago"]
-]
-
-# Convert to any format as shown above
-```
-
-## Development
-
-To install the package in development mode:
-
-```bash
-git clone https://github.com/yourusername/modular.git
-cd modular
-pip install -e .
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

modular-0.1.0/README.md

@@ -1,77 +0,0 @@
-# Modular
-
-A Python package for various data processing utilities with a focus on modularity and choice.
-
-## Installation
-
-```bash
-pip install modular
-```
-
-## Features
-
-### Tables Module
-
-The `tables` module provides functions to convert data into various table formats.
-
-#### Supported Formats:
-- Delimited (CSV, TSV, etc.)
-- Markdown
-- reStructuredText
-
-## Usage
-
-### Converting Data to Different Formats
-
-```python
-from modular.tables import to_delimited, to_markdown, to_rst
-
-# Example data as a list of dictionaries
-data_dict = [
-    {"name": "Alice", "age": 30, "city": "New York"},
-    {"name": "Bob", "age": 25, "city": "Los Angeles"},
-    {"name": "Charlie", "age": 35, "city": "Chicago"}
-]
-
-# Convert to CSV
-csv_output = to_delimited(data_dict)
-print(csv_output)
-
-# Convert to TSV
-tsv_output = to_delimited(data_dict, delimiter='\t')
-print(tsv_output)
-
-# Convert to Markdown
-md_output = to_markdown(data_dict)
-print(md_output)
-
-# Convert to reStructuredText
-rst_output = to_rst(data_dict)
-print(rst_output)
-```
-
-You can also use lists of lists:
-
-```python
-data_list = [
-    ["Alice", 30, "New York"],
-    ["Bob", 25, "Los Angeles"],
-    ["Charlie", 35, "Chicago"]
-]
-
-# Convert to any format as shown above
-```
-
-## Development
-
-To install the package in development mode:
-
-```bash
-git clone https://github.com/yourusername/modular.git
-cd modular
-pip install -e .
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

modular-0.1.0/modular/__init__.py

@@ -1,5 +0,0 @@
-"""
-Modular package for various data processing utilities.
-"""
-
-__version__ = "0.1.0" 

modular-0.1.0/modular/tables/__init__.py

@@ -1,7 +0,0 @@
-"""
-Table conversion utilities for various formats.
-"""
-
-from .converters import to_delimited, to_markdown, to_rst
-
-__all__ = ['to_delimited', 'to_markdown', 'to_rst'] 

modular-0.1.0/modular/tables/converters.py

@@ -1,102 +0,0 @@
-"""
-Table conversion functions for various formats.
-"""
-
-from typing import Union, List, Dict, Any
-import csv
-from io import StringIO
-
-def _normalize_data(data: Union[List[List[Any]], List[Dict[str, Any]]]) -> tuple[List[List[str]], List[str]]:
-    """
-    Normalize input data to a consistent format.
-    
-    Args:
-        data: List of lists or list of dictionaries
-        
-    Returns:
-        Tuple of (rows, headers)
-    """
-    if not data:
-        return [], []
-        
-    if isinstance(data[0], dict):
-        headers = list(data[0].keys())
-        rows = [[str(row.get(header, '')) for header in headers] for row in data]
-    else:
-        rows = [[str(cell) for cell in row] for row in data]
-        headers = [f"Column {i+1}" for i in range(len(rows[0]))] if rows else []
-    
-    return rows, headers
-
-def to_delimited(data: Union[List[List[Any]], List[Dict[str, Any]]], 
-                delimiter: str = ',') -> str:
-    """
-    Convert data to a delimited string format.
-    
-    Args:
-        data: List of lists or list of dictionaries
-        delimiter: Character to use as delimiter (default: ',')
-        
-    Returns:
-        String containing the delimited data
-    """
-    rows, headers = _normalize_data(data)
-    output = StringIO()
-    writer = csv.writer(output, delimiter=delimiter)
-    writer.writerow(headers)
-    writer.writerows(rows)
-    return output.getvalue()
-
-def to_markdown(data: Union[List[List[Any]], List[Dict[str, Any]]]) -> str:
-    """
-    Convert data to Markdown table format.
-    
-    Args:
-        data: List of lists or list of dictionaries
-        
-    Returns:
-        String containing the Markdown table
-    """
-    rows, headers = _normalize_data(data)
-    if not rows:
-        return ""
-        
-    # Create header row
-    markdown = "| " + " | ".join(headers) + " |\n"
-    # Create separator row
-    markdown += "| " + " | ".join(["---"] * len(headers)) + " |\n"
-    # Add data rows
-    for row in rows:
-        markdown += "| " + " | ".join(row) + " |\n"
-    
-    return markdown
-
-def to_rst(data: Union[List[List[Any]], List[Dict[str, Any]]]) -> str:
-    """
-    Convert data to reStructuredText table format.
-    
-    Args:
-        data: List of lists or list of dictionaries
-        
-    Returns:
-        String containing the reStructuredText table
-    """
-    rows, headers = _normalize_data(data)
-    if not rows:
-        return ""
-        
-    # Calculate column widths
-    col_widths = [max(len(str(cell)) for cell in col) 
-                 for col in zip(headers, *rows)]
-    
-    # Create header row
-    rst = "+" + "+".join("-" * (width + 2) for width in col_widths) + "+\n"
-    rst += "|" + "|".join(f" {header:<{width}} " for header, width in zip(headers, col_widths)) + "|\n"
-    rst += "+" + "+".join("=" * (width + 2) for width in col_widths) + "+\n"
-    
-    # Add data rows
-    for row in rows:
-        rst += "|" + "|".join(f" {cell:<{width}} " for cell, width in zip(row, col_widths)) + "|\n"
-    rst += "+" + "+".join("-" * (width + 2) for width in col_widths) + "+\n"
-    
-    return rst 

modular-0.1.0/modular.egg-info/PKG-INFO

@@ -1,92 +0,0 @@
-Metadata-Version: 2.4
-Name: modular
-Version: 0.1.0
-Summary: A modular package for all sorts of things where you want choices
-Author-email: Jeffrey Spies <code@jeffspies.com>
-Project-URL: Homepage, https://github.com/yourusername/modular
-Project-URL: Bug Tracker, https://github.com/yourusername/modular/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# Modular
-
-A Python package for various data processing utilities with a focus on modularity and choice.
-
-## Installation
-
-```bash
-pip install modular
-```
-
-## Features
-
-### Tables Module
-
-The `tables` module provides functions to convert data into various table formats.
-
-#### Supported Formats:
-- Delimited (CSV, TSV, etc.)
-- Markdown
-- reStructuredText
-
-## Usage
-
-### Converting Data to Different Formats
-
-```python
-from modular.tables import to_delimited, to_markdown, to_rst
-
-# Example data as a list of dictionaries
-data_dict = [
-    {"name": "Alice", "age": 30, "city": "New York"},
-    {"name": "Bob", "age": 25, "city": "Los Angeles"},
-    {"name": "Charlie", "age": 35, "city": "Chicago"}
-]
-
-# Convert to CSV
-csv_output = to_delimited(data_dict)
-print(csv_output)
-
-# Convert to TSV
-tsv_output = to_delimited(data_dict, delimiter='\t')
-print(tsv_output)
-
-# Convert to Markdown
-md_output = to_markdown(data_dict)
-print(md_output)
-
-# Convert to reStructuredText
-rst_output = to_rst(data_dict)
-print(rst_output)
-```
-
-You can also use lists of lists:
-
-```python
-data_list = [
-    ["Alice", 30, "New York"],
-    ["Bob", 25, "Los Angeles"],
-    ["Charlie", 35, "Chicago"]
-]
-
-# Convert to any format as shown above
-```
-
-## Development
-
-To install the package in development mode:
-
-```bash
-git clone https://github.com/yourusername/modular.git
-cd modular
-pip install -e .
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.