dataframe-textual 1.10.1__py3-none-any.whl → 1.16.2__py3-none-any.whl

dataframe_textual/__main__.py

@@ -37,7 +37,7 @@ def cli() -> argparse.Namespace:
         help="Specify that input files have no header row when reading CSV/TSV",
     )
     parser.add_argument(
-        "-I", "--no-inferrence", action="store_true", help="Do not infer data types when reading CSV/TSV"
+        "-I", "--no-inference", action="store_true", help="Do not infer data types when reading CSV/TSV"
     )
     parser.add_argument("-E", "--ignore-errors", action="store_true", help="Ignore errors when reading CSV/TSV")
     parser.add_argument(
@@ -80,7 +80,7 @@ def main() -> None:
         args.files,
         file_format=args.format,
         has_header=not args.no_header,
-        infer_schema=not args.no_inferrence,
+        infer_schema=not args.no_inference,
         comment_prefix=args.comment_prefix,
         quote_char=args.quote_char,
         skip_lines=args.skip_lines,

dataframe_textual/common.py

@@ -12,7 +12,7 @@ import polars as pl
 from rich.text import Text
 
 # Supported file formats
-SUPPORTED_FORMATS = {"tsv", "csv", "excel", "xlsx", "xls", "parquet", "json", "ndjson"}
+SUPPORTED_FORMATS = {"tsv", "tab", "csv", "excel", "xlsx", "xls", "parquet", "json", "ndjson"}
 
 
 # Boolean string mappings
@@ -34,6 +34,29 @@ NULL = "NULL"
 NULL_DISPLAY = "-"
 
 
+def format_float(value: float, thousand_separator: bool = False, precision: int = 2) -> str:
+    """Format a float value, keeping integers without decimal point.
+
+    Args:
+        val: The float value to format.
+        thousand_separator: Whether to include thousand separators. Defaults to False.
+
+    Returns:
+        The formatted float as a string.
+    """
+
+    if (val := int(value)) == value:
+        if precision > 0:
+            return f"{val:,}" if thousand_separator else str(val)
+        else:
+            return f"{val:,.{-precision}f}" if thousand_separator else f"{val:.{-precision}f}"
+    else:
+        if precision > 0:
+            return f"{value:,.{precision}f}" if thousand_separator else f"{value:.{precision}f}"
+        else:
+            return f"{value:,f}" if thousand_separator else str(value)
+
+
 @dataclass
 class DtypeClass:
     """Data type class configuration.
@@ -52,6 +75,35 @@ class DtypeClass:
     itype: str
     convert: Any
 
+    def format(
+        self, val: Any, style: str | None = None, justify: str | None = None, thousand_separator: bool = False
+    ) -> str:
+        """Format the value according to its data type.
+
+        Args:
+            val: The value to format.
+
+        Returns:
+            The formatted value as a Text.
+        """
+        # Format the value
+        if val is None:
+            text_val = NULL_DISPLAY
+        elif self.gtype == "integer" and thousand_separator:
+            text_val = f"{val:,}"
+        elif self.gtype == "float":
+            text_val = format_float(val, thousand_separator)
+        else:
+            text_val = str(val)
+
+        return Text(
+            text_val,
+            style="" if style == "" else (style or self.style),
+            justify="" if justify == "" else (justify or self.justify),
+            overflow="ellipsis",
+            no_wrap=True,
+        )
+
 
 # itype is used by Input widget for input validation
 # fmt: off
@@ -143,27 +195,7 @@ def DtypeConfig(dtype: pl.DataType) -> DtypeClass:
         return STYLES[pl.Unknown]
 
 
-def format_float(value: float, thousand_separator: bool = False, precision: int = 2) -> str:
-    """Format a float value, keeping integers without decimal point.
-
-    Args:
-        val: The float value to format.
-        thousand_separator: Whether to include thousand separators. Defaults to False.
-
-    Returns:
-        The formatted float as a string.
-    """
-
-    if (val := int(value)) == value:
-        return f"{val:,}" if thousand_separator else str(val)
-    else:
-        if precision > 0:
-            return f"{value:,.{precision}f}" if thousand_separator else f"{value:.{precision}f}"
-        else:
-            return f"{value:,f}" if thousand_separator else str(value)
-
-
-def format_row(vals, dtypes, styles=None, apply_justify=True, thousand_separator=False) -> list[Text]:
+def format_row(vals, dtypes, styles: list[str | None] | None = None, thousand_separator=False) -> list[Text]:
     """Format a single row with proper styling and justification.
 
     Converts raw row values to formatted Rich Text objects with appropriate
@@ -172,7 +204,7 @@ def format_row(vals, dtypes, styles=None, apply_justify=True, thousand_separator
     Args:
         vals: The list of values in the row.
         dtypes: The list of data types corresponding to each value.
-        apply_justify: Whether to apply justification styling. Defaults to True.
+        styles: Optional list of style overrides for each value. Defaults to None.
 
     Returns:
         A list of Rich Text objects with proper formatting applied.
@@ -181,24 +213,11 @@ def format_row(vals, dtypes, styles=None, apply_justify=True, thousand_separator
 
     for idx, (val, dtype) in enumerate(zip(vals, dtypes, strict=True)):
         dc = DtypeConfig(dtype)
-
-        # Format the value
-        if val is None:
-            text_val = NULL_DISPLAY
-        elif dc.gtype == "integer" and thousand_separator:
-            text_val = f"{val:,}"
-        elif dc.gtype == "float":
-            text_val = format_float(val, thousand_separator)
-        else:
-            text_val = str(val)
-
         formatted_row.append(
-            Text(
-                text_val,
-                style=styles[idx] if styles and styles[idx] else dc.style,
-                justify=dc.justify if apply_justify else "",
-                overflow="ellipsis",
-                no_wrap=True,
+            dc.format(
+                val,
+                style=styles[idx] if styles and styles[idx] else None,
+                thousand_separator=thousand_separator,
             )
         )
 
@@ -256,6 +275,7 @@ def parse_placeholders(template: str, columns: list[str], current_cidx: int) ->
     - `$#` - Row index (1-based, requires '^__ridx__^' column to be present)
     - `$1`, `$2`, etc. - Column index (1-based)
     - `$name` - Column name (e.g., `$product_id`)
+    - `` $`col name` `` - Column name with spaces (e.g., `` $`product id` ``)
 
     Args:
         template: The template string containing placeholders and literal text
@@ -271,8 +291,15 @@ def parse_placeholders(template: str, columns: list[str], current_cidx: int) ->
     if "$" not in template or template.endswith("$"):
         return [template]
 
-    # Regex matches: $_ or $\d+ or $\w+ (column names)
-    placeholder_pattern = r"\$(_|#|\d+|[a-zA-Z_]\w*)"
+    # Regex matches: $_ or $# or $\d+ or $`...` (backtick-quoted names with spaces) or $\w+ (column names)
+    # Pattern explanation:
+    # \$(_|#|\d+|`[^`]+`|[a-zA-Z_]\w*)
+    # - $_ : current column
+    # - $# : row index
+    # - $\d+ : column by index (1-based)
+    # - $`[^`]+` : column by name with spaces (backtick quoted)
+    # - $[a-zA-Z_]\w* : column by name without spaces
+    placeholder_pattern = r"\$(_|#|\d+|`[^`]+`|[a-zA-Z_]\w*)"
     placeholders = re.finditer(placeholder_pattern, template)
 
     parts = []
@@ -305,6 +332,13 @@ def parse_placeholders(template: str, columns: list[str], current_cidx: int) ->
                 parts.append(pl.col(col_ref))
             except IndexError:
                 raise ValueError(f"Invalid column index: ${placeholder} (valid range: $1 to ${len(columns)})")
+        elif placeholder.startswith("`") and placeholder.endswith("`"):
+            # $`col name` refers to column by name with spaces
+            col_ref = placeholder[1:-1]  # Remove backticks
+            if col_ref in columns:
+                parts.append(pl.col(col_ref))
+            else:
+                raise ValueError(f"Column not found: ${placeholder} (available columns: {', '.join(columns)})")
         else:
             # $name refers to column by name
             if placeholder in columns:
@@ -333,6 +367,7 @@ def parse_polars_expression(expression: str, columns: list[str], current_cidx: i
     - $# - Row index (1-based, requires '^__ridx__^' column to be present)
     - $1, $2, etc. - Column index (1-based)
     - $col_name - Column name (valid identifier starting with _ or letter)
+    - $`col name` - Column name with spaces (backtick quoted)
 
     Examples:
     - "$_ > 50" -> "pl.col('current_col') > 50"
@@ -340,6 +375,7 @@ def parse_polars_expression(expression: str, columns: list[str], current_cidx: i
     - "$1 > 50" -> "pl.col('col0') > 50"
     - "$name == 'Alex'" -> "pl.col('name') == 'Alex'"
     - "$age < $salary" -> "pl.col('age') < pl.col('salary')"
+    - "$`product id` > 100" -> "pl.col('product id') > 100"
 
     Args:
         expression: The input expression as a string.
@@ -705,3 +741,29 @@ async def sleep_async(seconds: float) -> None:
     import asyncio
 
     await asyncio.sleep(seconds)
+
+
+def round_to_nearest_hundreds(num: int, N: int = 100) -> tuple[int, int]:
+    """Round a number to the nearest hundred boundaries.
+
+    Given a number, return a tuple of the two closest hundreds that bracket it.
+
+    Args:
+        num: The number to round.
+
+    Returns:
+        A tuple (lower_hundred, upper_hundred) where:
+        - lower_hundred is the largest multiple of 100 <= num
+        - upper_hundred is the smallest multiple of 100 > num
+
+    Examples:
+        >>> round_to_nearest_hundreds(0)
+        (0, 100)
+        >>> round_to_nearest_hundreds(150)
+        (100, 200)
+        >>> round_to_nearest_hundreds(200)
+        (200, 300)
+    """
+    lower = (num // N) * N
+    upper = lower + N
+    return (lower, upper)