sumry 0.1.0__tar.gz

sumry-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sparkgeo
+
+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.

sumry-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: sumry
+Version: 0.1.0
+Summary: A data summarization tool for analyzing various file formats
+Author: Sparkgeo
+License: MIT
+Project-URL: Homepage, https://github.com/sparkgeo/sumry
+Project-URL: Repository, https://github.com/sparkgeo/sumry
+Project-URL: Issues, https://github.com/sparkgeo/sumry/issues
+Keywords: data,summary,analysis,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duckdb>=1.1.2
+Requires-Dist: geopandas>=1.0.1
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: python-calamine>=0.2.3
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.5
+Dynamic: license-file
+
+# sumry
+
+A fast and user-friendly CLI tool for summarizing various data file formats with rich terminal output.
+
+## Features
+
+- **Multiple Format Support**: CSV, Excel, GeoJSON, and Shapefiles
+- **Rich Terminal Output**: Beautiful, colorful summaries using Rich library
+- **Quick Insights**: Get file statistics, column types, and sample data
+- **Geospatial Support**: Special handling for GeoJSON and Shapefile formats with geometry information
+
+## Installation
+
+```bash
+pip install sumry
+```
+
+## Usage
+
+### Basic Summary
+
+```bash
+sumry path/to/your/file.csv
+```
+
+### Show Sample Records
+
+```bash
+# Show 5 sample records (default)
+sumry path/to/your/file.xlsx --show-sample
+
+# Show specific number of samples
+sumry path/to/your/file.geojson --sample 10
+```
+
+### Verbose Output
+
+```bash
+sumry path/to/your/file.shp --verbose
+```
+
+## Supported File Types
+
+- **CSV** (`.csv`)
+- **Excel** (`.xlsx`, `.xls`)
+- **GeoJSON** (`.geojson`, `.json`)
+- **Shapefile** (`.shp`)
+
+## Requirements
+
+- Python >= 3.12
+- Dependencies are automatically installed with the package
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/sumry.git
+cd sumry
+
+# Install with development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

sumry-0.1.0/README.md

@@ -0,0 +1,74 @@
+# sumry
+
+A fast and user-friendly CLI tool for summarizing various data file formats with rich terminal output.
+
+## Features
+
+- **Multiple Format Support**: CSV, Excel, GeoJSON, and Shapefiles
+- **Rich Terminal Output**: Beautiful, colorful summaries using Rich library
+- **Quick Insights**: Get file statistics, column types, and sample data
+- **Geospatial Support**: Special handling for GeoJSON and Shapefile formats with geometry information
+
+## Installation
+
+```bash
+pip install sumry
+```
+
+## Usage
+
+### Basic Summary
+
+```bash
+sumry path/to/your/file.csv
+```
+
+### Show Sample Records
+
+```bash
+# Show 5 sample records (default)
+sumry path/to/your/file.xlsx --show-sample
+
+# Show specific number of samples
+sumry path/to/your/file.geojson --sample 10
+```
+
+### Verbose Output
+
+```bash
+sumry path/to/your/file.shp --verbose
+```
+
+## Supported File Types
+
+- **CSV** (`.csv`)
+- **Excel** (`.xlsx`, `.xls`)
+- **GeoJSON** (`.geojson`, `.json`)
+- **Shapefile** (`.shp`)
+
+## Requirements
+
+- Python >= 3.12
+- Dependencies are automatically installed with the package
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/sumry.git
+cd sumry
+
+# Install with development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

sumry-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sumry"
+version = "0.1.0"
+description = "A data summarization tool for analyzing various file formats"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+authors = [
+    {name = "Sparkgeo"}
+]
+keywords = ["data", "summary", "analysis", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "duckdb>=1.1.2",
+    "geopandas>=1.0.1",
+    "openpyxl>=3.1.5",
+    "python-calamine>=0.2.3",
+    "rich>=13.0.0",
+    "typer>=0.12.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/sparkgeo/sumry"
+Repository = "https://github.com/sparkgeo/sumry"
+Issues = "https://github.com/sparkgeo/sumry/issues"
+
+[dependency-groups]
+dev = [
+    "pre-commit>=4.0.1",
+    "pytest>=8.3.3",
+]
+
+[project.scripts]
+sumry = "sumry.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]

sumry-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sumry-0.1.0/src/sumry/__init__.py

@@ -0,0 +1,22 @@
+"""
+sumry - A data summarization tool for analyzing and processing various file formats.
+"""
+
+__version__ = "0.1.0"
+
+from sumry.readers import (
+    read_csv,
+    read_excel,
+    read_geojson,
+    read_shapefile,
+    detect_file_type,
+)
+
+__all__ = [
+    "read_csv",
+    "read_excel",
+    "read_geojson",
+    "read_shapefile",
+    "detect_file_type",
+    "__version__",
+]

sumry-0.1.0/src/sumry/cli.py

@@ -0,0 +1,235 @@
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import print as rprint
+import warnings
+import os
+
+from sumry.readers import (
+    read_csv,
+    read_excel,
+    read_geojson,
+    read_shapefile,
+    detect_file_type
+)
+
+app = typer.Typer(
+    name="sumry",
+    help="Summarize various data sources (CSV, Excel, GeoJSON, Shapefiles)",
+    add_completion=False
+)
+
+console = Console()
+
+
+@app.command()
+def main(
+    file_path: Path = typer.Argument(
+        ...,
+        help="Path to the file to summarize",
+        exists=True
+    ),
+    verbose: bool = typer.Option(
+        False, 
+        "--verbose", 
+        "-v",
+        help="Show detailed information"
+    ),
+    sample: Optional[int] = typer.Option(
+        None,
+        "--sample",
+        "-n",
+        help="Number of sample records to display (default: 5)"
+    ),
+    show_sample: bool = typer.Option(
+        False,
+        "--show-sample",
+        "-s",
+        help="Show sample records (displays 5 records)"
+    )
+):
+    """
+    Summarize a data file (CSV, Excel, GeoJSON, or Shapefile).
+    """
+    
+    # Suppress warnings and verbose output in non-verbose mode
+    if not verbose:
+        warnings.filterwarnings('ignore')
+        os.environ['PYOGRIO_USE_ARROW'] = '0'  # Suppress pyogrio Arrow warnings
+    
+    if not file_path.exists():
+        console.print(f"[bold red]Error:[/bold red] File {file_path} does not exist")
+        raise typer.Exit(1)
+    
+    file_type = detect_file_type(file_path)
+    
+    if not file_type:
+        console.print(f"[bold red]Error:[/bold red] Unsupported file type for {file_path}")
+        raise typer.Exit(1)
+    
+    try:
+        if file_type == "CSV":
+            summary = read_csv(file_path, verbose)
+        elif file_type == "Excel":
+            summary = read_excel(file_path, verbose)
+        elif file_type == "GeoJSON":
+            summary = read_geojson(file_path, verbose)
+        elif file_type == "Shapefile":
+            summary = read_shapefile(file_path, verbose)
+        else:
+            console.print(f"[bold red]Error:[/bold red] Handler not implemented for {file_type}")
+            raise typer.Exit(1)
+            
+        display_summary(summary, file_type, verbose)
+        
+        # Display sample records if requested
+        if sample is not None or show_sample:
+            sample_count = sample if sample and sample > 0 else 5
+            display_sample_records(file_path, file_type, sample_count)
+        
+    except Exception as e:
+        console.print(f"[bold red]Error reading file:[/bold red] {str(e)}")
+        raise typer.Exit(1)
+
+
+def display_sample_records(file_path: Path, file_type: str, sample_count: int):
+    """Display sample records from the file."""
+    import pandas as pd
+    import geopandas as gpd
+    
+    console.print(f"\n[bold cyan]Sample Records (first {sample_count}):[/bold cyan]")
+    
+    try:
+        # Read the data based on file type
+        if file_type == "CSV":
+            df = pd.read_csv(file_path, nrows=sample_count)
+        elif file_type == "Excel":
+            df = pd.read_excel(file_path, nrows=sample_count)
+        elif file_type in ["GeoJSON", "Shapefile"]:
+            # For spatial files, use geopandas
+            if file_type == "GeoJSON":
+                gdf = gpd.read_file(file_path, rows=sample_count)
+            else:  # Shapefile
+                gdf = gpd.read_file(file_path, rows=sample_count)
+            
+            # Replace geometry column with placeholder
+            df = gdf.copy()
+            if 'geometry' in df.columns:
+                df['geometry'] = '<geometry>'
+        else:
+            console.print(f"[yellow]Sample display not supported for {file_type}[/yellow]")
+            return
+        
+        # Create a Rich table for displaying the sample
+        from rich.box import ROUNDED
+        table = Table(show_header=True, box=ROUNDED)
+        
+        # Add columns
+        for col in df.columns:
+            table.add_column(str(col), style="white", overflow="fold")
+        
+        # Add rows
+        for _, row in df.iterrows():
+            row_values = []
+            for val in row.values:
+                if pd.isna(val):
+                    row_values.append("N/A")
+                elif isinstance(val, (int, float)):
+                    if pd.isna(val):
+                        row_values.append("N/A")
+                    elif isinstance(val, float):
+                        row_values.append(f"{val:.2f}" if val != int(val) else str(int(val)))
+                    else:
+                        row_values.append(str(val))
+                else:
+                    # Truncate long strings
+                    str_val = str(val)
+                    if len(str_val) > 50:
+                        str_val = str_val[:47] + "..."
+                    row_values.append(str_val)
+            table.add_row(*row_values)
+        
+        console.print(table)
+        
+    except Exception as e:
+        console.print(f"[red]Error displaying sample records: {str(e)}[/red]")
+
+
+def display_summary(summary: dict, file_type: str, verbose: bool):
+    """Display the file summary using Rich formatting."""
+    
+    panel = Panel.fit(
+        f"[bold green]{file_type} File Summary[/bold green]",
+        border_style="cyan"
+    )
+    console.print(panel)
+    
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Property", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    
+    for key, value in summary.get("basic_info", {}).items():
+        if isinstance(value, (list, dict)):
+            value_str = str(value)
+        else:
+            value_str = str(value)
+        table.add_row(key, value_str)
+    
+    console.print(table)
+    
+    if "columns" in summary and summary["columns"]:
+        console.print("\n[bold cyan]Columns/Fields:[/bold cyan]")
+        col_table = Table(show_header=True, box=None)
+        col_table.add_column("Name", style="green")
+        col_table.add_column("Type", style="yellow")
+        
+        if verbose and "sample_values" in summary:
+            col_table.add_column("Sample Values", style="white")
+            
+        for col_info in summary["columns"]:
+            if verbose and "sample_values" in summary:
+                sample = summary["sample_values"].get(col_info["name"], [])
+                sample_str = ", ".join(str(v) for v in sample[:3])
+                col_table.add_row(col_info["name"], col_info["type"], sample_str)
+            else:
+                col_table.add_row(col_info["name"], col_info["type"])
+        
+        console.print(col_table)
+    
+    if verbose and "statistics" in summary:
+        console.print("\n[bold cyan]Statistics:[/bold cyan]")
+        stats_table = Table(show_header=True, box=None)
+        stats_table.add_column("Column", style="green")
+        stats_table.add_column("Min", style="yellow")
+        stats_table.add_column("Max", style="yellow")
+        stats_table.add_column("Mean", style="yellow")
+        stats_table.add_column("Unique", style="yellow")
+        
+        for col_name, stats in summary["statistics"].items():
+            stats_table.add_row(
+                col_name,
+                str(stats.get("min", "N/A")),
+                str(stats.get("max", "N/A")),
+                str(stats.get("mean", "N/A")),
+                str(stats.get("unique", "N/A"))
+            )
+        
+        console.print(stats_table)
+    
+    if "geometry_info" in summary:
+        console.print("\n[bold cyan]Geometry Information:[/bold cyan]")
+        geo_table = Table(show_header=False, box=None, padding=(0, 2))
+        geo_table.add_column("Property", style="cyan", no_wrap=True)
+        geo_table.add_column("Value", style="white")
+        
+        for key, value in summary["geometry_info"].items():
+            geo_table.add_row(key, str(value))
+        
+        console.print(geo_table)
+
+
+if __name__ == "__main__":
+    app()

sumry-0.1.0/src/sumry/formats/__init__.py

@@ -0,0 +1 @@
+from .xlsx import XLSX

sumry-0.1.0/src/sumry/formats/base.py

@@ -0,0 +1,20 @@
+
+from typing import Final
+
+
+class BaseFormat:
+    format: Final = None
+
+    @property
+    def name(self):
+        raise NotImplementedError("Method not implemented")
+    
+    @property
+    def size(self):
+        raise NotImplementedError("Method not implemented")
+
+    def metadata(self, *args, **kwargs):
+        return {}
+
+    def sample_data(self, sample_size: int = 20, *args, **kwargs):
+        raise NotImplementedError("Method not implemented")

sumry-0.1.0/src/sumry/formats/xlsx.py

@@ -0,0 +1,149 @@
+import os
+from typing import Final
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+
+import duckdb
+
+from .base import BaseFormat
+# from ..timing import timing, Timer
+
+
+class XLSX(BaseFormat):
+    verbose_name: Final = "Excel Open XML Spreadsheet"
+    format: Final = "xlsx"
+    _wb = None
+
+
+    def __init__(self, file, layer=None, *args, **kwargs):
+        self.file = Path(file)
+        self.layer = layer
+
+    # def _load(self, sheet_name, nrows=None):
+    #     if not self._wb:
+    #         self._wb =  CalamineWorkbook.from_path(self.file)
+
+    #     return self._wb
+
+    def _sheet_names(self):
+        return self._wb.sheet_names
+
+    def _get_fields(self, sheet_name: str):
+        df = self._read_xlsx(self.file, num_rows=0, sheet_name=sheet_name)
+        return df.dtypes
+
+    @property
+    def name(self):
+        return self.file.name
+    
+    @property
+    def size(self):
+        return os.path.getsize(self.file)
+    
+    # def record_count(self, sheet):
+    #     workbook = load_workbook(filename=self.file, read_only=True)
+    #     sheet = workbook[sheet] if sheet else workbook.active
+    #     return sheet.max_row
+
+    def info(self, *args, **kwargs):
+        # meta = super().metadata(*args, **kwargs)
+
+        duckdb.install_extension('spatial')
+        duckdb.load_extension('spatial')
+        
+        sheet_names_query = f"""
+            SELECT * FROM st_read('{self.file}', layer='')
+        """
+
+        # Execute the query
+        result = duckdb.sql(sheet_names_query).df()
+
+        # Display sheet names
+        print(result)
+    
+    def sample(self, count: int = 5, *args, **kwargs):
+        duckdb.install_extension('spatial')
+        duckdb.load_extension('spatial')
+        
+        console = Console()
+        
+        # If no layer specified, list available layers
+        if not self.layer:
+            sheet_names_query = f"""
+                SELECT * FROM st_read('{self.file}', layer='')
+            """
+            result = duckdb.sql(sheet_names_query).df()
+            console.print("\n[bold]Available layers:[/bold]")
+            for idx, row in result.iterrows():
+                console.print(f"  {idx}: {row['layer_name']}")
+            console.print("\n[yellow]Please specify a layer using the layer argument[/yellow]")
+            return
+        
+        # Read sample data from the specified layer
+        try:
+            sample_query = f"""
+                SELECT * FROM st_read('{self.file}', layer='{self.layer}')
+                LIMIT {count}
+            """
+            df = duckdb.sql(sample_query).df()
+            
+            if df.empty:
+                console.print(f"[yellow]No data found in layer '{self.layer}'[/yellow]")
+                return
+            
+            # Create a Rich table
+            table = Table(title=f"Sample data from '{self.layer}' (showing {min(count, len(df))} of {count} requested records)")
+            
+            # Add columns to the table
+            for col in df.columns:
+                table.add_column(col, style="cyan", no_wrap=False)
+            
+            # Add rows to the table
+            for _, row in df.iterrows():
+                row_data = []
+                for col in df.columns:
+                    value = row[col]
+                    # Check if column name suggests geometry or if value looks like geometry
+                    if 'geom' in col.lower() or 'geometry' in col.lower():
+                        row_data.append("<geometry>")
+                    elif isinstance(value, (bytes, str)) and (
+                        (isinstance(value, str) and (value.startswith('POLYGON') or value.startswith('POINT') or 
+                         value.startswith('LINE') or value.startswith('MULTI'))) or
+                        (isinstance(value, bytes))
+                    ):
+                        row_data.append("<geometry>")
+                    else:
+                        row_data.append(str(value) if value is not None else "")
+                table.add_row(*row_data)
+            
+            console.print()
+            console.print(table)
+            console.print()
+            
+        except Exception as e:
+            console.print(f"[red]Error reading data from layer '{self.layer}': {e}[/red]")
+
+
+
+
+    #     if not self.layer:
+    #         print("Layers available:")
+    #         for n, sheet_name in  enumerate(self._sheet_names()):
+    #             print(f"{n}: {sheet_name}")
+            
+    #         return
+
+    #     print()
+    #     print(f"Name: {self.file.name}")
+    #     print(f"Size: {self.size}")
+    #     print(f"\tSheet Name: {self.layer}")
+
+    #     df = self._load(self.layer)
+
+    #     print(f"\tRecord Count: {len(df.index)}")
+    
+
+    # def sample_data(self, sample_size: int = 20, *args, **kwargs):
+    #     self._load(nrows=sample_size)
+    #     return self._pd

sumry-0.1.0/src/sumry/main.py

@@ -0,0 +1,28 @@
+from typing import Optional
+import typer
+from sumry.formats import XLSX
+
+app = typer.Typer(help="A CLI tool for XLSX files.")
+
+
+@app.command()
+def info(
+    file: str = typer.Argument(..., help="Source file."),
+    layer: str = typer.Argument(None, help="Layer name."),
+):
+    xlsx = XLSX(file, layer=layer)
+    xlsx.info()
+
+
+@app.command()
+def sample(
+    file: str = typer.Argument(..., help="Source file."),
+    layer: str = typer.Argument(None, help="Layer name."),
+    count: int = typer.Option(5, "--count", "-n", help="Number of sample records to display."),
+):
+    xlsx = XLSX(file, layer=layer)
+    xlsx.sample(count=count)
+
+
+if __name__ == "__main__":
+    app()

sumry-0.1.0/src/sumry/readers.py

@@ -0,0 +1,256 @@
+from pathlib import Path
+import pandas as pd
+import geopandas as gpd
+import json
+import warnings
+from typing import Dict, Any, Optional, List
+
+
+def detect_file_type(file_path: Path) -> Optional[str]:
+    """Detect the type of file based on its extension."""
+    suffix = file_path.suffix.lower()
+    
+    if suffix in ['.csv', '.tsv']:
+        return "CSV"
+    elif suffix in ['.xlsx', '.xls', '.xlsm']:
+        return "Excel"
+    elif suffix in ['.geojson', '.json']:
+        if suffix == '.json':
+            try:
+                with open(file_path, 'r') as f:
+                    data = json.load(f)
+                    if isinstance(data, dict) and data.get('type') in ['Feature', 'FeatureCollection']:
+                        return "GeoJSON"
+            except:
+                pass
+        else:
+            return "GeoJSON"
+    elif suffix in ['.shp']:
+        return "Shapefile"
+    
+    return None
+
+
+def read_csv(file_path: Path, verbose: bool = False) -> Dict[str, Any]:
+    """Read and summarize a CSV file."""
+    df = pd.read_csv(file_path)
+    
+    summary = {
+        "basic_info": {
+            "File": file_path.name,
+            "Rows": len(df),
+            "Columns": len(df.columns),
+            "Memory Usage": f"{df.memory_usage(deep=True).sum() / 1024:.2f} KB"
+        },
+        "columns": []
+    }
+    
+    for col in df.columns:
+        col_info = {
+            "name": col,
+            "type": str(df[col].dtype)
+        }
+        summary["columns"].append(col_info)
+    
+    if verbose:
+        summary["sample_values"] = {}
+        summary["statistics"] = {}
+        
+        for col in df.columns:
+            summary["sample_values"][col] = df[col].dropna().head(5).tolist()
+            
+            if pd.api.types.is_numeric_dtype(df[col]):
+                summary["statistics"][col] = {
+                    "min": float(df[col].min()) if not pd.isna(df[col].min()) else None,
+                    "max": float(df[col].max()) if not pd.isna(df[col].max()) else None,
+                    "mean": float(df[col].mean()) if not pd.isna(df[col].mean()) else None,
+                    "unique": df[col].nunique()
+                }
+            else:
+                summary["statistics"][col] = {
+                    "unique": df[col].nunique(),
+                    "most_common": df[col].value_counts().head(1).index[0] if not df[col].empty else None
+                }
+    
+    return summary
+
+
+def read_excel(file_path: Path, verbose: bool = False) -> Dict[str, Any]:
+    """Read and summarize an Excel file."""
+    xl_file = pd.ExcelFile(file_path)
+    
+    summary = {
+        "basic_info": {
+            "File": file_path.name,
+            "Sheets": len(xl_file.sheet_names),
+            "Sheet Names": ", ".join(xl_file.sheet_names)
+        }
+    }
+    
+    if xl_file.sheet_names:
+        df = pd.read_excel(file_path, sheet_name=xl_file.sheet_names[0])
+        
+        summary["basic_info"]["Active Sheet"] = xl_file.sheet_names[0]
+        summary["basic_info"]["Rows"] = len(df)
+        summary["basic_info"]["Columns"] = len(df.columns)
+        summary["basic_info"]["Memory Usage"] = f"{df.memory_usage(deep=True).sum() / 1024:.2f} KB"
+        
+        summary["columns"] = []
+        for col in df.columns:
+            col_info = {
+                "name": col,
+                "type": str(df[col].dtype)
+            }
+            summary["columns"].append(col_info)
+        
+        if verbose:
+            summary["sample_values"] = {}
+            summary["statistics"] = {}
+            
+            for col in df.columns:
+                summary["sample_values"][col] = df[col].dropna().head(5).tolist()
+                
+                if pd.api.types.is_numeric_dtype(df[col]):
+                    summary["statistics"][col] = {
+                        "min": float(df[col].min()) if not pd.isna(df[col].min()) else None,
+                        "max": float(df[col].max()) if not pd.isna(df[col].max()) else None,
+                        "mean": float(df[col].mean()) if not pd.isna(df[col].mean()) else None,
+                        "unique": df[col].nunique()
+                    }
+                else:
+                    summary["statistics"][col] = {
+                        "unique": df[col].nunique(),
+                        "most_common": df[col].value_counts().head(1).index[0] if not df[col].empty else None
+                    }
+    
+    return summary
+
+
+def read_geojson(file_path: Path, verbose: bool = False) -> Dict[str, Any]:
+    """Read and summarize a GeoJSON file."""
+    if not verbose:
+        warnings.filterwarnings('ignore')
+    
+    gdf = gpd.read_file(file_path)
+    
+    summary = {
+        "basic_info": {
+            "File": file_path.name,
+            "Features": len(gdf),
+            "CRS": str(gdf.crs) if gdf.crs else "None",
+            "Memory Usage": f"{gdf.memory_usage(deep=True).sum() / 1024:.2f} KB"
+        },
+        "columns": [],
+        "geometry_info": {}
+    }
+    
+    for col in gdf.columns:
+        if col != 'geometry':
+            col_info = {
+                "name": col,
+                "type": str(gdf[col].dtype)
+            }
+            summary["columns"].append(col_info)
+    
+    if 'geometry' in gdf.columns:
+        geom_types = gdf.geometry.geom_type.value_counts()
+        bounds = gdf.total_bounds
+        
+        # Calculate area and length with warning suppression
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            area_sum = gdf.geometry.area.sum() if gdf.geometry.geom_type.iloc[0] in ['Polygon', 'MultiPolygon'] else None
+            length_sum = gdf.geometry.length.sum() if gdf.geometry.geom_type.iloc[0] in ['LineString', 'MultiLineString'] else None
+        
+        summary["geometry_info"] = {
+            "Geometry Types": ", ".join(f"{t}: {c}" for t, c in geom_types.items()),
+            "Bounds (minx, miny, maxx, maxy)": f"[{bounds[0]:.6f}, {bounds[1]:.6f}, {bounds[2]:.6f}, {bounds[3]:.6f}]",
+            "Total Area": f"{area_sum:.6f}" if area_sum is not None else "N/A",
+            "Total Length": f"{length_sum:.6f}" if length_sum is not None else "N/A"
+        }
+    
+    if verbose:
+        summary["sample_values"] = {}
+        summary["statistics"] = {}
+        
+        for col in gdf.columns:
+            if col != 'geometry':
+                summary["sample_values"][col] = gdf[col].dropna().head(5).tolist()
+                
+                if pd.api.types.is_numeric_dtype(gdf[col]):
+                    summary["statistics"][col] = {
+                        "min": float(gdf[col].min()) if not pd.isna(gdf[col].min()) else None,
+                        "max": float(gdf[col].max()) if not pd.isna(gdf[col].max()) else None,
+                        "mean": float(gdf[col].mean()) if not pd.isna(gdf[col].mean()) else None,
+                        "unique": gdf[col].nunique()
+                    }
+                else:
+                    summary["statistics"][col] = {
+                        "unique": gdf[col].nunique()
+                    }
+    
+    return summary
+
+
+def read_shapefile(file_path: Path, verbose: bool = False) -> Dict[str, Any]:
+    """Read and summarize a Shapefile."""
+    if not verbose:
+        warnings.filterwarnings('ignore')
+    
+    gdf = gpd.read_file(file_path)
+    
+    summary = {
+        "basic_info": {
+            "File": file_path.name,
+            "Features": len(gdf),
+            "CRS": str(gdf.crs) if gdf.crs else "None",
+            "Memory Usage": f"{gdf.memory_usage(deep=True).sum() / 1024:.2f} KB"
+        },
+        "columns": [],
+        "geometry_info": {}
+    }
+    
+    for col in gdf.columns:
+        if col != 'geometry':
+            col_info = {
+                "name": col,
+                "type": str(gdf[col].dtype)
+            }
+            summary["columns"].append(col_info)
+    
+    if 'geometry' in gdf.columns:
+        geom_types = gdf.geometry.geom_type.value_counts()
+        bounds = gdf.total_bounds
+        
+        # Calculate area and length with warning suppression
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            area_sum = gdf.geometry.area.sum() if gdf.geometry.geom_type.iloc[0] in ['Polygon', 'MultiPolygon'] else None
+            length_sum = gdf.geometry.length.sum() if gdf.geometry.geom_type.iloc[0] in ['LineString', 'MultiLineString'] else None
+        
+        summary["geometry_info"] = {
+            "Geometry Types": ", ".join(f"{t}: {c}" for t, c in geom_types.items()),
+            "Bounds (minx, miny, maxx, maxy)": f"[{bounds[0]:.6f}, {bounds[1]:.6f}, {bounds[2]:.6f}, {bounds[3]:.6f}]",
+            "Total Area": f"{area_sum:.6f}" if area_sum is not None else "N/A",
+            "Total Length": f"{length_sum:.6f}" if length_sum is not None else "N/A"
+        }
+    
+    if verbose:
+        summary["sample_values"] = {}
+        summary["statistics"] = {}
+        
+        for col in gdf.columns:
+            if col != 'geometry':
+                summary["sample_values"][col] = gdf[col].dropna().head(5).tolist()
+                
+                if pd.api.types.is_numeric_dtype(gdf[col]):
+                    summary["statistics"][col] = {
+                        "min": float(gdf[col].min()) if not pd.isna(gdf[col].min()) else None,
+                        "max": float(gdf[col].max()) if not pd.isna(gdf[col].max()) else None,
+                        "mean": float(gdf[col].mean()) if not pd.isna(gdf[col].mean()) else None,
+                        "unique": gdf[col].nunique()
+                    }
+                else:
+                    summary["statistics"][col] = {
+                        "unique": gdf[col].nunique()
+                    }

sumry-0.1.0/src/sumry/timing.py

@@ -0,0 +1,35 @@
+from functools import wraps
+from time import time
+
+class Timer:
+    def __init__(self, name):
+        self.name = name
+
+    def __enter__(self):
+        self.start_time = time()
+
+    def __exit__(self, type, value, traceback):
+        delta = time() - self.start_time
+        self.delta = delta
+        self.start_time = None
+
+        msg = f"{self.name}: {delta:.3f}s"
+        if traceback:
+            msg += " (with error)"
+        print(msg)
+
+
+def timing(name=None):
+    def decorator(f):
+        @wraps(f)
+        def wrap(*args, **kw):
+            ts = time()
+            result = f(*args, **kw)
+            te = time()
+            func_name = name if name else f.__name__
+            print("func:%r took: %2.4f sec" % (func_name, te - ts))
+            return result
+
+        return wrap
+
+    return decorator

sumry-0.1.0/src/sumry.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: sumry
+Version: 0.1.0
+Summary: A data summarization tool for analyzing various file formats
+Author: Sparkgeo
+License: MIT
+Project-URL: Homepage, https://github.com/sparkgeo/sumry
+Project-URL: Repository, https://github.com/sparkgeo/sumry
+Project-URL: Issues, https://github.com/sparkgeo/sumry/issues
+Keywords: data,summary,analysis,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: duckdb>=1.1.2
+Requires-Dist: geopandas>=1.0.1
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: python-calamine>=0.2.3
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.5
+Dynamic: license-file
+
+# sumry
+
+A fast and user-friendly CLI tool for summarizing various data file formats with rich terminal output.
+
+## Features
+
+- **Multiple Format Support**: CSV, Excel, GeoJSON, and Shapefiles
+- **Rich Terminal Output**: Beautiful, colorful summaries using Rich library
+- **Quick Insights**: Get file statistics, column types, and sample data
+- **Geospatial Support**: Special handling for GeoJSON and Shapefile formats with geometry information
+
+## Installation
+
+```bash
+pip install sumry
+```
+
+## Usage
+
+### Basic Summary
+
+```bash
+sumry path/to/your/file.csv
+```
+
+### Show Sample Records
+
+```bash
+# Show 5 sample records (default)
+sumry path/to/your/file.xlsx --show-sample
+
+# Show specific number of samples
+sumry path/to/your/file.geojson --sample 10
+```
+
+### Verbose Output
+
+```bash
+sumry path/to/your/file.shp --verbose
+```
+
+## Supported File Types
+
+- **CSV** (`.csv`)
+- **Excel** (`.xlsx`, `.xls`)
+- **GeoJSON** (`.geojson`, `.json`)
+- **Shapefile** (`.shp`)
+
+## Requirements
+
+- Python >= 3.12
+- Dependencies are automatically installed with the package
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/sumry.git
+cd sumry
+
+# Install with development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

sumry-0.1.0/src/sumry.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/sumry/__init__.py
+src/sumry/cli.py
+src/sumry/main.py
+src/sumry/readers.py
+src/sumry/timing.py
+src/sumry.egg-info/PKG-INFO
+src/sumry.egg-info/SOURCES.txt
+src/sumry.egg-info/dependency_links.txt
+src/sumry.egg-info/entry_points.txt
+src/sumry.egg-info/requires.txt
+src/sumry.egg-info/top_level.txt
+src/sumry/formats/__init__.py
+src/sumry/formats/base.py
+src/sumry/formats/xlsx.py

sumry-0.1.0/src/sumry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sumry-0.1.0/src/sumry.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sumry = sumry.cli:app

sumry-0.1.0/src/sumry.egg-info/requires.txt

@@ -0,0 +1,6 @@
+duckdb>=1.1.2
+geopandas>=1.0.1
+openpyxl>=3.1.5
+python-calamine>=0.2.3
+rich>=13.0.0
+typer>=0.12.5

sumry-0.1.0/src/sumry.egg-info/top_level.txt

@@ -0,0 +1 @@
+sumry