flatbread 0.1.1__tar.gz → 0.1.3__tar.gz

{flatbread-0.1.1 → flatbread-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flatbread
-Version: 0.1.1
+Version: 0.1.3
 Summary: Pandas extension for aggregation and tabular display
 Project-URL: Homepage, https://github.com/lcvriend/flatbread
 Author-email: "L.C. Vriend" <vanboefer@gmail.com>

{flatbread-0.1.1 → flatbread-0.1.3}/flatbread/config/config.defaults.json

@@ -13,5 +13,14 @@
         "ndigits": -1,
         "base": 1
     },
-    "locale": null
+    "locale": null,
+    "format_presets": {
+        "currency_eur": {
+            "dtypes": ["float", "int"],
+            "options": {
+                "style": "currency",
+                "currency": "EUR"
+            }
+        }
+    }
 }

flatbread-0.1.3/flatbread/config.py

@@ -0,0 +1,133 @@
+import functools
+import json
+from pathlib import Path
+from typing import Callable
+
+
+def deep_merge(base: dict, update: dict) -> dict:
+    """
+    Deep merge two dictionaries, preserving structure from both.
+
+    - When both dicts have a dict at the same key, merge recursively
+    - When update has keys not in base, add them
+    - When types mismatch (e.g., dict in one, value in other), prefer update
+
+    Parameters
+    ----------
+    base : dict
+        Base dictionary to merge into
+    update : dict
+        Dictionary with values to update base with
+
+    Returns
+    -------
+    dict
+        Merged dictionary
+    """
+    merged = base.copy()
+    for key, update_val in update.items():
+        if key not in merged:
+            # Add keys from update that don't exist in base
+            merged[key] = update_val
+        elif isinstance(update_val, dict) and isinstance(merged[key], dict):
+            # Recursively merge nested dictionaries
+            merged[key] = deep_merge(merged[key], update_val)
+        else:
+            # Override base value with update value
+            merged[key] = update_val
+    return merged
+
+
+def find_project_config(max_levels: int = 5) -> Path|None:
+    """
+    Find project-level .flatbread.json, traversing up from current directory.
+
+    Parameters
+    ----------
+    max_levels : int, default 5
+        Maximum number of directory levels to traverse upward
+
+    Returns
+    -------
+    Path or None
+        Path to the config file if found, None otherwise
+    """
+    current_dir = Path.cwd()
+    home_dir = Path.home()
+
+    # Check current directory and up to max_levels parent directories
+    for _ in range(max_levels + 1):
+        config_path = current_dir / ".flatbread.json"
+        if config_path.is_file():
+            return config_path
+
+        # Stop if we've reached the filesystem root or home directory
+        if current_dir == current_dir.parent or current_dir == home_dir:
+            break
+
+        # Move up one directory
+        current_dir = current_dir.parent
+
+    return None
+
+
+def read_config():
+    """
+    Read configuration with priority: project > user > defaults.
+
+    Returns
+    -------
+    dict
+        Merged configuration dictionary
+    """
+    # 1. Look for project config first
+    project_config = None
+    if project_path := find_project_config():
+        project_config = json.loads(project_path.read_text())
+
+    # 2. Look for user config
+    user_config = None
+    user_config_path = Path('~/.flatbread.json').expanduser()
+    if user_config_path.exists():
+        user_config = json.loads(user_config_path.read_text())
+
+    # 3. Get default config
+    package_path = Path(__file__).resolve().parent
+    config = json.loads((package_path / 'config/config.defaults.json').read_text())
+
+    # Merge configs with right precedence
+    if user_config:
+        config = deep_merge(config, user_config)
+    if project_config:
+        config = deep_merge(config, project_config)
+
+    return config
+
+
+def inject_defaults(defaults: dict) -> Callable:
+    """
+    Load defaults if keywords are None or undefined when calling a function.
+
+    Arguments
+    ---------
+    defaults (dict):
+        Dictionary of keywords and default values.
+
+    Return
+    ------
+    func:
+        Function that will load defaults.
+
+    Notes
+    -----
+    This decorator will override any default values set in the function definition.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            for key, val in defaults.items():
+                if kwargs.get(key) is None:
+                    kwargs[key] = val
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

{flatbread-0.1.1 → flatbread-0.1.3}/flatbread/render/constants.py

@@ -2,6 +2,19 @@
 from flatbread import DEFAULTS
 
 
+USER_PRESETS = DEFAULTS.get("format_presets", {})
+USER_PRESETS_BY_DTYPE = {
+    dtype: set()
+    for dtype in ["float", "int", "datetime", "str", "category"]
+}
+
+for preset_name, preset_config in USER_PRESETS.items():
+    preset_dtypes = preset_config.get("dtypes", ["float", "int"])  # Default to numeric
+    for dtype in preset_dtypes:
+        if dtype in USER_PRESETS_BY_DTYPE:
+            USER_PRESETS_BY_DTYPE[dtype].add(preset_name)
+
+
 SMART_FORMATS = {
     'percentages': {
         'labels': [DEFAULTS['percentages']['label_pct']],
@@ -43,7 +56,7 @@ NUMBER_PRESETS = {"default", "currency", "percentage", "compact", "diffs"}
 DATE_PRESETS = {"default", "date", "datetime"}
 
 DTYPE_TO_PRESETS = {
-    "float": NUMBER_PRESETS,
-    "int": NUMBER_PRESETS,
-    "datetime": DATE_PRESETS
+    "float": NUMBER_PRESETS.union(USER_PRESETS_BY_DTYPE["float"]),
+    "int": NUMBER_PRESETS.union(USER_PRESETS_BY_DTYPE["int"]),
+    "datetime": DATE_PRESETS.union(USER_PRESETS_BY_DTYPE["datetime"]),
 }

{flatbread-0.1.1 → flatbread-0.1.3}/flatbread/render/display.py

@@ -147,6 +147,52 @@ class PitaDisplayMixin:
         self._table_spec_builder.set_formats(formats)
         return self
 
+    def list_format_presets(self, dtype: str = None) -> dict[str, dict]:
+        """List available format presets, optionally filtered by data type
+
+        Parameters
+        ----------
+        dtype : str, optional
+            Filter presets by data type compatibility. Options: 'float', 'int',
+            'datetime', 'str', 'category'.
+
+        Returns
+        -------
+        dict
+            Dictionary of preset names and their configurations
+        """
+        from flatbread.render.constants import USER_PRESETS, DTYPE_TO_PRESETS
+
+        # Define built-in presets with their configurations
+        built_in = {
+            "default": {"notation": "standard"},
+            "currency": {"style": "currency", "currency": "USD"},
+            "percentage": {"style": "percent"},
+            "compact": {"notation": "compact"},
+            "date": {"dateStyle": "short"},
+            "datetime": {"dateStyle": "short", "timeStyle": "short"}
+        }
+
+        # Extract user preset options
+        user_options = {
+            name: config.get("options", {})
+            for name, config in USER_PRESETS.items()
+        }
+
+        # Combine built-in and user presets
+        all_presets = {**built_in, **user_options}
+
+        # Filter by dtype if specified
+        if dtype:
+            if dtype not in DTYPE_TO_PRESETS:
+                valid_dtypes = ", ".join(sorted(DTYPE_TO_PRESETS.keys()))
+                raise ValueError(f"Invalid dtype '{dtype}'. Valid options are: {valid_dtypes}")
+
+            valid_presets = DTYPE_TO_PRESETS.get(dtype, set())
+            return {k: v for k, v in all_presets.items() if k in valid_presets}
+
+        return all_presets
+
     def _repr_html_(self) -> str:
         """Generate HTML representation for Jupyter display"""
         spec = self._table_spec_builder.get_spec_as_json()

{flatbread-0.1.1 → flatbread-0.1.3}/flatbread/render/tablespec.py

@@ -94,17 +94,51 @@ class TableSpecBuilder:
                     return format_type['options']
         return None
 
-    def set_format(self, column: str, format_spec: ColumnFormat) -> None:
+    def set_format(self, column: str, format_spec: str | dict[str, Any]) -> None:
+        """Set format options for a column
+
+        Parameters
+        ----------
+        column : str
+            Column to format
+        format_spec : str | dict
+            Either a preset name (e.g. 'currency') or format options dict
+        """
+        from flatbread.render.constants import USER_PRESETS, DTYPE_TO_PRESETS, DEFAULT_DTYPES
+
         if isinstance(format_spec, str):
+            # Check if it's a user-defined preset
+            if format_spec in USER_PRESETS:
+                pandas_dtype = str(self._data[column].dtype)
+                simple_dtype = DEFAULT_DTYPES.get(pandas_dtype, 'str')
+
+                # Get allowed dtypes for this preset
+                preset_config = USER_PRESETS[format_spec]
+                allowed_dtypes = preset_config.get("dtypes", ["float", "int"])
+
+                if simple_dtype in allowed_dtypes:
+                    self._format_options[column] = preset_config.get("options", {})
+                    return
+                else:
+                    raise ValueError(
+                        f"Preset '{format_spec}' is not compatible with column '{column}' "
+                        f"of dtype {pandas_dtype} (mapped to {simple_dtype}). "
+                        f"This preset supports: {', '.join(allowed_dtypes)}"
+                    )
+
+            # Handle built-in presets
             pandas_dtype = str(self._data[column].dtype)
             simple_dtype = DEFAULT_DTYPES.get(pandas_dtype, 'str')
             valid_presets = DTYPE_TO_PRESETS.get(simple_dtype, set())
+
             if format_spec not in valid_presets:
                 valid = ", ".join(sorted(valid_presets))
                 raise ValueError(
                     f"Invalid preset '{format_spec}' for dtype {pandas_dtype} "
                     f"(mapped to {simple_dtype}). Valid presets are: {valid}"
                 )
+
+        # If we reached here, either format_spec is a dict or a valid built-in preset
         self._format_options[column] = format_spec
 
     def set_formats(self, formats: FormatSpec) -> None:
@@ -112,11 +146,15 @@ class TableSpecBuilder:
 
         Parameters
         ----------
-        formats : dict, list or callable
-            Either dict mapping column names to format specs,
-            a list of length columns,
-            or function that takes DataFrame and returns such dict
+        formats : str, dict, list or callable
+            - If string: apply the same format preset to all columns
+            - If dict: mapping column names to format specs
+            - If list: format specs in same order as columns
+            - If callable: function that takes DataFrame and returns a dict
         """
+        if isinstance(formats, str):
+            formats = {column: formats for column in self._data.columns}
+
         if callable(formats):
             formats = formats(self._data)
 

{flatbread-0.1.1 → flatbread-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flatbread"
-version = "0.1.1"
+version = "0.1.3"
 description = "Pandas extension for aggregation and tabular display"
 readme = "readme.md"
 requires-python = ">=3.10"

flatbread-0.1.1/flatbread/config.py

@@ -1,43 +0,0 @@
-import functools
-import json
-from pathlib import Path
-from typing import Callable
-
-
-def read_config():
-    config_path = Path('~/.flatbread/config.json').expanduser()
-    if not config_path.exists():
-        package_path = Path(__file__).resolve().parent
-        config_path = package_path / 'config/config.defaults.json'
-    json_string = config_path.read_text()
-    config = json.loads(json_string)
-    return config
-
-
-def inject_defaults(defaults: dict) -> Callable:
-    """
-    Load defaults if keywords are None or undefined when calling a function.
-
-    Arguments
-    ---------
-    defaults (dict):
-        Dictionary of keywords and default values.
-
-    Return
-    ------
-    func:
-        Function that will load defaults.
-
-    Notes
-    -----
-    This decorator will override any default values set in the function definition.
-    """
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            for key, val in defaults.items():
-                if kwargs.get(key) is None:
-                    kwargs[key] = val
-            return func(*args, **kwargs)
-        return wrapper
-    return decorator