datablade 0.0.0__py3-none-any.whl → 0.0.6__py3-none-any.whl

datablade/utils/strings.py

@@ -0,0 +1,249 @@
+"""String and path helpers used across datablade."""
+
+import os
+import pathlib
+from functools import singledispatch
+from typing import Optional, Union
+
+from .logging import log_warning
+from .messages import print_verbose
+
+PathInput = Union[str, pathlib.Path, os.PathLike]
+_PATH_STRICT_DEFAULT = False
+
+
+def configure_paths(*, path_strict: bool = False) -> None:
+    """Configure global path handling behavior."""
+    global _PATH_STRICT_DEFAULT
+    _PATH_STRICT_DEFAULT = bool(path_strict)
+
+
+def _resolve_path_strict(path_strict: Optional[bool]) -> bool:
+    if path_strict is None:
+        return _PATH_STRICT_DEFAULT
+    return bool(path_strict)
+
+
+@singledispatch
+def _coerce_path_input(value: object, type_label: str) -> str:
+    raise TypeError(f"{type_label} must be a string or pathlib.Path")
+
+
+@_coerce_path_input.register
+def _(value: str, type_label: str) -> str:
+    return value
+
+
+@_coerce_path_input.register
+def _(value: pathlib.Path, type_label: str) -> str:
+    return str(value)
+
+
+@_coerce_path_input.register
+def _(value: os.PathLike, type_label: str) -> str:
+    path_value = os.fspath(value)
+    if isinstance(path_value, bytes):
+        raise TypeError(f"{type_label} must be a string or pathlib.Path")
+    return path_value
+
+
+@_coerce_path_input.register
+def _(value: bytes, type_label: str) -> str:
+    raise TypeError(f"{type_label} must be a string or pathlib.Path")
+
+
+def _normalize_path_value(path_value: str) -> str:
+    if os.name == "nt":
+        return path_value.replace("\\", "/")
+    return path_value
+
+
+def _find_case_conflicts(
+    path_obj: pathlib.Path,
+    raw_path: str,
+) -> list[tuple[str, str, str]]:
+    """Return case mismatches as (provided, actual, parent) tuples."""
+    if not raw_path:
+        return []
+
+    try:
+        input_path = pathlib.Path(raw_path)
+    except Exception:
+        input_path = path_obj
+
+    if input_path.is_absolute():
+        anchor = input_path.anchor
+        if anchor:
+            current = pathlib.Path(anchor)
+            anchor_parts = pathlib.Path(anchor).parts
+            remaining_parts = input_path.parts[len(anchor_parts) :]
+        else:
+            current = pathlib.Path(anchor)
+            remaining_parts = input_path.parts
+    else:
+        current = pathlib.Path.cwd()
+        remaining_parts = input_path.parts
+
+    mismatches: list[tuple[str, str, str]] = []
+    for part in remaining_parts:
+        if part in ("", "."):
+            continue
+        if part == "..":
+            current = current.parent
+            continue
+        try:
+            with os.scandir(current) as entries:
+                actual = None
+                for entry in entries:
+                    if entry.name.casefold() == part.casefold():
+                        actual = entry.name
+                        break
+        except OSError:
+            break
+
+        if actual is None:
+            current = current / part
+            continue
+        if actual != part:
+            mismatches.append((part, actual, str(current)))
+        current = current / actual
+
+    return mismatches
+
+
+def coerce_path(
+    input: Optional[PathInput],
+    *,
+    must_exist: bool = False,
+    verbose: bool = False,
+    label: str = "path",
+    path_strict: Optional[bool] = None,
+    type_label: Optional[str] = None,
+) -> pathlib.Path:
+    """Normalize a path-like input and optionally validate existence and case."""
+    if input is None:
+        print_verbose(f"No {label} provided; exiting.", verbose)
+        raise ValueError(f"{label} must be provided")
+
+    type_label = type_label or label
+    path_value = _coerce_path_input(input, type_label)
+
+    if not path_value.strip():
+        print_verbose(f"No {label} provided; exiting.", verbose)
+        raise ValueError(f"{label} must be provided")
+
+    normalized = _normalize_path_value(path_value)
+    path_obj = pathlib.Path(normalized)
+    exists = path_obj.exists()
+
+    if must_exist and not exists:
+        print_verbose(f"Path {path_obj} does not exist; exiting.", verbose)
+        raise ValueError(f"Path does not exist: {path_obj}")
+
+    if exists:
+        strict = _resolve_path_strict(path_strict)
+        conflicts = _find_case_conflicts(path_obj, path_value)
+        if conflicts:
+            details = "; ".join(
+                f"{provided} -> {actual} in {parent}"
+                for provided, actual, parent in conflicts
+            )
+            message = f"Path case mismatch for {label}: {details}"
+            if strict:
+                raise ValueError(message)
+            log_warning(message, verbose)
+
+    return path_obj
+
+
+def ensure_directory(
+    input: Optional[PathInput],
+    *,
+    verbose: bool = False,
+    label: str = "path",
+    path_strict: Optional[bool] = None,
+    type_label: Optional[str] = None,
+) -> pathlib.Path:
+    """Ensure a directory exists and return the resolved path."""
+    path_obj = coerce_path(
+        input,
+        must_exist=False,
+        verbose=verbose,
+        label=label,
+        path_strict=path_strict,
+        type_label=type_label,
+    )
+    path_obj.mkdir(parents=True, exist_ok=True)
+    return path_obj
+
+
+def sql_quotename(
+    name: Optional[str] = None,
+    brackets: bool = True,
+    ticks: bool = False,
+    verbose: bool = False,
+) -> str:
+    """
+    Quote a SQL Server name string with brackets or ticks.
+
+    Args:
+        name: The name to quote. Must be a non-empty string.
+        brackets: If True, wraps the name in square brackets [name].
+        ticks: If True, wraps the name in single quotes 'name'.
+            Takes precedence over brackets if both are True.
+        verbose: If True, prints error messages.
+
+    Returns:
+        The quoted name string.
+
+    Raises:
+        ValueError: If name is None or empty after stripping.
+        TypeError: If name is not a string.
+
+    Examples:
+        >>> sql_quotename('table_name')
+        '[table_name]'
+        >>> sql_quotename('table_name', brackets=False, ticks=True)
+        "'table_name'"
+    """
+    if name is None:
+        print_verbose("No name provided; exiting sql_quotename.", verbose)
+        raise ValueError("name must be provided")
+    if not isinstance(name, str):
+        raise TypeError("name must be a string")
+    cleaned = name.strip()
+    if not cleaned:
+        raise ValueError("name must be a non-empty string")
+
+    return_value = cleaned.replace("[", "").replace("]", "")
+    if brackets:
+        return_value = f"[{return_value}]"
+    if ticks or not brackets:
+        return_value = f"'{return_value}'"
+    return return_value
+
+
+def pathing(
+    input: Optional[Union[str, pathlib.Path]], verbose: bool = False
+) -> pathlib.Path:
+    """
+    Standardize and validate a path string or Path object.
+
+    Args:
+        input: The path to standardize (string or pathlib.Path). Must not be None.
+        verbose: If True, prints error messages.
+
+    Returns:
+        A pathlib.Path object if the path exists.
+
+    Raises:
+        ValueError: If input is None or the path does not exist.
+        TypeError: If input is not a string or pathlib.Path.
+    """
+    return coerce_path(
+        input,
+        must_exist=True,
+        verbose=verbose,
+        label="path input",
+        type_label="input",
+    )

datablade-0.0.6.dist-info/METADATA

@@ -0,0 +1,406 @@
+Metadata-Version: 2.4
+Name: datablade
+Version: 0.0.6
+Summary: datablade is a suite of functions to provide standard syntax across data engineering projects.
+Author-email: Brent Carpenetti <brentwc.git@pm.me>
+License: MIT License
+        
+        Copyright (c) 2024 Brent Carpenetti
+        
+        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.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: numpy
+Requires-Dist: openpyxl
+Requires-Dist: requests
+Provides-Extra: performance
+Requires-Dist: polars; extra == "performance"
+Requires-Dist: psutil; extra == "performance"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-mock>=3.10.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: polars; extra == "dev"
+Requires-Dist: psutil; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: all
+Requires-Dist: polars; extra == "all"
+Requires-Dist: psutil; extra == "all"
+Requires-Dist: pytest>=7.0.0; extra == "all"
+Requires-Dist: pytest-cov>=4.0.0; extra == "all"
+Requires-Dist: pytest-mock>=3.10.0; extra == "all"
+Requires-Dist: black; extra == "all"
+Requires-Dist: flake8; extra == "all"
+Requires-Dist: mypy; extra == "all"
+Requires-Dist: isort; extra == "all"
+Dynamic: license-file
+
+# datablade
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**datablade** is a small, single-machine Python toolkit for data engineers who need reliable “file → DataFrame/Parquet → SQL DDL” workflows.
+
+It focuses on:
+
+- Reading common file formats with memory-aware heuristics
+- Streaming large files in chunks (without concatenating)
+- Normalizing DataFrame columns for downstream systems
+- Generating `CREATE TABLE` DDL across a small set of SQL dialects
+- Producing bulk-load commands (and executing BCP for SQL Server)
+
+## What datablade Does
+
+datablade helps data engineers:
+
+- **Load data efficiently** from common file formats with automatic memory heuristics
+- **Standardize data cleaning** with consistent column naming and type inference
+- **Generate database schemas** for multiple SQL dialects from DataFrames or Parquet schemas
+- **Handle datasets that don't fit in memory** using chunked iteration and optional Polars acceleration
+- **Work across databases** with cross-dialect DDL and bulk-load command generation
+- **Maintain data quality** with built-in validation and logging
+
+## When to Use datablade
+
+datablade is ideal for:
+
+✅ **ETL/ELT Pipelines** - Building reproducible data ingestion workflows across multiple source formats
+
+✅ **Multi-Database Projects** - Deploying the same schema to SQL Server, PostgreSQL, MySQL, or DuckDB
+
+✅ **Large File Processing** - Streaming CSV/TSV/TXT/Parquet without concatenating
+
+✅ **Data Lake to Warehouse** - Converting raw files to Parquet with optimized schemas
+
+✅ **Ad-hoc Data Analysis** - Quickly exploring and preparing datasets with consistent patterns
+
+✅ **Legacy System Integration** - Standardizing messy column names and data types from external sources
+
+## When datablade is not the right tool
+
+- Real-time streaming ingestion (Kafka, Spark Structured Streaming)
+- Distributed compute / cluster execution (Spark, Dask)
+- Warehouse-native transformations and modeling (dbt)
+- A full-featured schema migration tool (Alembic, Flyway)
+- Direct database connectivity/transactions (datablade generates SQL; it does not manage connections)
+
+## Installation
+
+```bash
+pip install datablade
+```
+
+**Optional dependencies:**
+
+```bash
+# For high-performance file reading with Polars
+pip install "datablade[performance]"
+
+# For testing
+pip install "datablade[test]"
+
+# For development (includes testing + lint/format tooling)
+pip install "datablade[dev]"
+
+# All optional dependencies
+pip install "datablade[all]"
+```
+
+## Features
+
+datablade provides four main modules:
+
+### 📊 `datablade.dataframes`
+
+DataFrame operations and transformations:
+
+- Clean and normalize DataFrame columns
+- Auto-detect and convert data types
+- Generate optimized Parquet schemas
+- Convert pandas DataFrames to PyArrow tables
+- Generate multi-dialect SQL DDL statements
+- **Memory-aware file reading** with automatic chunking
+- **Polars integration** for high-performance large file processing
+- Partitioned Parquet writing for datasets that don't fit in memory
+
+### 🌐 `datablade.io`
+
+Input/output operations for external data:
+
+- Fetch JSON data from URLs
+- Download and extract ZIP files
+
+### 🛠️ `datablade.utils`
+
+General utility functions:
+
+- SQL name quoting
+- Path standardization
+- List flattening
+- **Configurable logging** with Python logging module
+
+### 🗄️ `datablade.sql`
+
+Multi-dialect SQL utilities:
+
+- **Multi-dialect support**: SQL Server, PostgreSQL, MySQL, DuckDB
+- Dialect-aware identifier quoting
+- CREATE TABLE generation for all dialects (from pandas DataFrames)
+- CREATE TABLE generation from Parquet schemas (schema-only, via PyArrow)
+- Optional `schema_spec` overrides for column types, nullability, and string sizing
+- Bulk loading helpers:
+    - SQL Server: executes `bcp` via subprocess
+    - PostgreSQL/MySQL/DuckDB: returns command strings you can run in your environment
+
+## Quick Start
+
+```python
+import pandas as pd
+from datablade import configure_logging, read_file_smart
+from datablade.dataframes import clean_dataframe_columns, pandas_to_parquet_table
+from datablade.io import get_json
+from datablade.utils import sql_quotename
+from datablade.sql import Dialect, generate_create_table, generate_create_table_from_parquet
+
+# Configure logging
+import logging
+configure_logging(level=logging.INFO, log_file="datablade.log")
+
+# Read a file into a single DataFrame (materializes)
+df = read_file_smart('large_dataset.csv', verbose=True)
+
+# Clean DataFrame
+df = clean_dataframe_columns(df, verbose=True)
+
+# Convert to Parquet
+table = pandas_to_parquet_table(df, convert=True)
+
+# Generate SQL DDL for multiple dialects
+sql_sqlserver = generate_create_table(df, table='my_table', dialect=Dialect.SQLSERVER)
+sql_postgres = generate_create_table(df, table='my_table', dialect=Dialect.POSTGRES)
+
+# Generate SQL DDL directly from an existing Parquet schema (no data materialization)
+# Note: nested Parquet types (struct/list/map/union) are dropped with a warning.
+ddl_from_parquet = generate_create_table_from_parquet(
+    "events.parquet",
+    table="events",
+    dialect=Dialect.POSTGRES,
+)
+
+# Fetch JSON data
+data = get_json('https://api.example.com/data.json')
+```
+
+Most file path parameters accept `str` or `pathlib.Path`. To treat case mismatches
+as errors on case-insensitive filesystems, use `configure_paths(path_strict=True)`.
+
+### Memory-Aware File Reading
+
+See the file format support matrix in the bundled USAGE doc:
+
+```bash
+python -m datablade.docs --show USAGE
+```
+
+```python
+from datablade.dataframes import (
+    excel_to_parquets,
+    read_file_chunked,
+    read_file_iter,
+    read_file_to_parquets,
+    stream_to_parquets,
+)
+
+# Read large files in chunks
+for chunk in read_file_chunked('huge_file.csv', memory_fraction=0.5):
+    process(chunk)
+
+# Stream without ever concatenating/materializing
+for chunk in read_file_iter('huge_file.csv', memory_fraction=0.3, verbose=True):
+    process(chunk)
+
+# Parquet is also supported for streaming (single .parquet files)
+for chunk in read_file_iter('huge_file.parquet', memory_fraction=0.3, verbose=True):
+    process(chunk)
+
+# Excel streaming is available with openpyxl installed (read-only mode)
+for chunk in read_file_iter('large.xlsx', chunksize=25_000, verbose=True):
+    process(chunk)
+
+# Partition large files to multiple Parquets
+files = read_file_to_parquets(
+    'large_file.csv',
+    output_dir='partitioned/',
+    convert_types=True,
+    verbose=True
+)
+
+# Stream to Parquet partitions without materializing
+files = stream_to_parquets(
+    'large_file.csv',
+    output_dir='partitioned_streamed/',
+    rows_per_file=200_000,
+    convert_types=True,
+    verbose=True,
+)
+
+# Excel streaming to Parquet partitions
+files = excel_to_parquets(
+    'large.xlsx',
+    output_dir='partitioned_excel/',
+    rows_per_file=200_000,
+    convert_types=True,
+    verbose=True,
+)
+```
+
+## Blade (Optional Facade)
+
+The canonical API is module-level functions (for example, `datablade.dataframes.read_file_iter`).
+
+If you prefer an object-style entrypoint with shared defaults, you can use the optional `Blade` facade:
+
+```python
+from datablade import Blade
+from datablade.sql import Dialect
+
+blade = Blade(memory_fraction=0.3, verbose=True, convert_types=True)
+
+for chunk in blade.iter("huge.csv"):
+    process(chunk)
+
+files = blade.stream_to_parquets("huge.csv", output_dir="partitioned/")
+
+# Generate DDL (CREATE TABLE)
+ddl = blade.create_table_sql(
+    df,
+    table="my_table",
+    dialect=Dialect.POSTGRES,
+)
+
+# Generate DDL from an existing Parquet file (schema-only)
+ddl2 = blade.create_table_sql_from_parquet(
+    "events.parquet",
+    table="events",
+    dialect=Dialect.POSTGRES,
+)
+```
+
+## Documentation
+
+Docs are bundled with the installed package:
+
+```bash
+python -m datablade.docs --list
+python -m datablade.docs --show USAGE
+python -m datablade.docs --write-dir .\datablade-docs
+```
+
+After writing docs to disk, open the markdown files locally:
+
+- README (docs landing page)
+- USAGE (file reading, streaming, SQL, IO, logging)
+- TESTING (how to run tests locally)
+- ARCHITECTURE (pipeline overview)
+- OBJECT_REGISTRY (registry reference)
+
+## Testing
+
+Run the test suite:
+
+```bash
+# Install with test dependencies
+pip install -e ".[test]"
+
+# Run all tests
+pytest
+
+# Run with coverage report
+pytest --cov=datablade --cov-report=html
+```
+
+For detailed testing documentation, use the bundled TESTING doc:
+
+```bash
+python -m datablade.docs --show TESTING
+```
+
+## Backward Compatibility
+
+All functions are available through the legacy `datablade.core` module for backward compatibility:
+
+```python
+# Legacy imports (still supported)
+from datablade.core.frames import clean_dataframe_columns
+from datablade.core.json import get
+```
+
+## Requirements
+
+**Core dependencies:**
+
+- pandas
+- pyarrow
+- numpy
+- openpyxl
+- requests
+
+## Design choices and limitations
+
+- **Single-machine focus**: datablade is designed for laptop/VM/server execution, not clusters.
+- **Streaming vs materializing**:
+    - Use `read_file_iter()` to process arbitrarily large files chunk-by-chunk.
+    - `read_file_smart()` returns a single DataFrame and may still be memory-intensive.
+- **Chunk concatenation**: the large-file pandas fallback in `read_file_smart()` can
+  temporarily spike memory usage during concat. Use `read_file_iter()` or
+  `return_type="iterator"` to avoid concatenation.
+- **Polars materialization**: when returning a pandas DataFrame, Polars still
+  collects into memory; use `return_type="polars"` or `"polars_lazy"` to keep
+  Polars frames.
+- **Parquet support**:
+    - Streaming reads support single `.parquet` files.
+    - Parquet “dataset directories” (Hive partitions / directory-of-parquets) are not a primary target API.
+- **Parquet → SQL DDL**:
+    - Uses the Parquet schema (PyArrow) without scanning data.
+    - Complex/nested columns (struct/list/map/union) are dropped and logged as warnings.
+- **DDL scope**: `CREATE TABLE` generation is column/type oriented (no indexes/constraints).
+- **SQL Server bulk load**: the SQL Server helpers use the `bcp` CLI and require it
+  to be installed and available on PATH. When using `-U`/`-P`, credentials are
+  passed via process args (logs are redacted); prefer `-T` or `-G` where possible.
+
+**Optional dependencies:**
+
+- polars (for high-performance file reading)
+- psutil (for memory-aware operations)
+- pytest (for testing)
+
+## License
+
+MIT

datablade-0.0.6.dist-info/RECORD

@@ -0,0 +1,41 @@
+datablade/__init__.py,sha256=T1FBNEZfjdIFwyfRLNCQBroMXDfaYai1sQTaRzhA1Qg,1487
+datablade/blade.py,sha256=iKQtHhH-xs3EDH9ZNryheRGzE2OBkaxjZsA99iAG-p0,10330
+datablade/registry.py,sha256=zmfbt3-LthxV2lmwNAmt4KN-EnLRKAguMnYnk5xxzjg,20323
+datablade/core/__init__.py,sha256=VJ2lFumv-7CFKjIN_i4wPEaAGFEb-UhHPzsM2IyTUUM,871
+datablade/core/frames.py,sha256=iiTQPkWKQHslwkz_pu6bHVvbnisWSZF_b3Hgy1SvE-Q,662
+datablade/core/json.py,sha256=_0RoK_OXkOpwNG5Y7vdORQOCfs0ZVJAO0qeQqjxzpyE,121
+datablade/core/lists.py,sha256=OVj-KLyeOlbOxALyxvBLQpB0s78RO2QxmM4OxbI70Cc,132
+datablade/core/messages.py,sha256=_2CpeaDJIwmRlTm4UMrDTKnew1wZdyai6QeKFjN3rno,404
+datablade/core/strings.py,sha256=vwx0NW-m-2nOYW1aisRXUjrd4wERe2Y5Ka64wAyF0Mo,173
+datablade/core/zip.py,sha256=fmp6VTKH3JAaRWTKhWGHN-frO7Vr4EHlEYtUOlomNuc,119
+datablade/dataframes/__init__.py,sha256=blPM2EkNI6FA8unnsGpTDP4A12G23ChXy4djyhpgHMk,1316
+datablade/dataframes/frames.py,sha256=VaMgrY5F8uuWw6adx9g10sBlkW4TfZhH5AEo2TgD5N4,20993
+datablade/dataframes/readers.py,sha256=1RFW0J1iKGvmgrRjDMB8PoHcMhQhyfAlUh1h6_aF_2E,47469
+datablade/docs/ARCHITECTURE.md,sha256=ON65KUk3-EdwfnMglOT1CVZqyJNUXVbAUff803d7XDU,3290
+datablade/docs/OBJECT_REGISTRY.md,sha256=00wkTuo6Pnhl9kgRDu7mJFO3yxSBedQQS7r-ktnsqSs,5386
+datablade/docs/README.md,sha256=2uH6siz5ABEd6ZDjPYbXpH-zaOgyHzB3ik2e2eUj8Ks,1587
+datablade/docs/TESTING.md,sha256=zc1Qz3ZRGH9CZqWfzArDmv3wRfS8-346EiXhE_fO0co,463
+datablade/docs/USAGE.md,sha256=vJRmCF-dUeXAiWvvgUwc6fO3gpYNBZtwV-v2gmfoeeY,11866
+datablade/docs/__init__.py,sha256=t4KRQOU653CVdkFD00Aj0hdjrlcmx70D2W2QnybJDnc,2388
+datablade/docs/__main__.py,sha256=V-GK7vuR1aEvT_TgJPAZnapjLhwDXGOCSEseX4R6fts,112
+datablade/io/__init__.py,sha256=jDenqP4biI1gnRdoO9X5C489cBlHrLuR3xp_TIOljp8,295
+datablade/io/json.py,sha256=3Oao1lP8Dat3DT7MYyCes7feqPVFDHAPpFDemHuKVVw,2384
+datablade/io/zip.py,sha256=Ppl8CvGhWIYFcBelpSkinmT_oFDmQmqNiHuFHicSoQI,4268
+datablade/sql/__init__.py,sha256=Fs77XFT_hJcdxBZxLD9-6fgD2QEVtfp58LlZaEMFEJA,1466
+datablade/sql/bulk_load.py,sha256=7SniXGHMIvwg9P_r95Nt7Z72jkQnu-LuQtPvv_Wmq2I,19992
+datablade/sql/ddl.py,sha256=4xJ98LJmnD7PqloU8Ewa7J9iy2L6n9iPRsM5WtBKA0U,14958
+datablade/sql/ddl_pyarrow.py,sha256=yBfTbDAA7dE3BXrCSPqEFogOYohAb3p0v3AIgBRxNqc,15344
+datablade/sql/dialects.py,sha256=rM5qw6xdIuCSx81b6_TKYnsDhKeVpTdMDb_62HhtksA,266
+datablade/sql/quoting.py,sha256=Y8yn1GAsaWSIenQDidwU4j2YsZmYE9ppOifAPiTbStk,1345
+datablade/sql/schema_spec.py,sha256=HdEA5RS_yj8WNVH8wroWDyIK-8K4_fgMZC7rZBswkcs,2067
+datablade/sql/sqlserver.py,sha256=ASLhtHIslMePRi9pUY6vWTaebQ7TM4kO60N9QsXwhok,13726
+datablade/utils/__init__.py,sha256=KbvUZVWg2u53oUlfEIbDndwgz6f_j7N23Dl8Oz-vWXk,746
+datablade/utils/lists.py,sha256=h3AXo2SSE2iaR_rJfoCgfNRFV9AOWerL-hHFYo6S4n8,798
+datablade/utils/logging.py,sha256=kqM1389Wgzml69aja6g7yj8biNSi9AOPZlxr3YTnyp0,5491
+datablade/utils/messages.py,sha256=yZZTGTS_eD0PBZFCdzz51fqBFWgq9Sdq-GMR1a0FclY,537
+datablade/utils/strings.py,sha256=GLvYi7FPUHZ2nqNsZ0-mGbc3gu70UvVzrIy4bQWRHOo,7196
+datablade-0.0.6.dist-info/licenses/LICENSE,sha256=QyU-OkETSZ-L0Rltu-SAMQtQU_UXjwLnb_QlA_AXm0U,1072
+datablade-0.0.6.dist-info/METADATA,sha256=ou_j_HZwHrdNaZb26JhW_m3oRhILZ4tMFIPla9Sm8LM,13261
+datablade-0.0.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+datablade-0.0.6.dist-info/top_level.txt,sha256=AwA5QxmfuaAs9XeXw1tCsboPsoffnMU-6CeLWMMUoUA,10
+datablade-0.0.6.dist-info/RECORD,,

{datablade-0.0.0.dist-info → datablade-0.0.6.dist-info}/WHEEL

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