azure77 0.1.0__tar.gz

azure77-0.1.0/LICENSE

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

azure77-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: azure77
+Version: 0.1.0
+Summary: Upload, query and manage data on Azure SQL Server from Python
+Author: 77 Indicadores
+License-Expression: MIT
+Keywords: azure,sql,database,upload,data
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyodbc>=4.0.30
+Requires-Dist: python-dotenv>=0.19
+Requires-Dist: unidecode>=1.3
+Requires-Dist: chardet>=5.0
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: xlrd>=2.0
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=12.0
+Dynamic: license-file
+
+# azure77
+
+Upload, query and manage data on Azure SQL Server from Python.
+
+## Installation
+
+```bash
+pip install azure77
+```
+
+## Quick Start
+
+```python
+from azure77 import ConnectionManager
+
+# Connect to Azure SQL
+cm = ConnectionManager(
+    server="your-server.database.windows.net",
+    database="your-db",
+    user="your-user",
+    password="your-pass",
+)
+
+# Test connection
+result = cm.test_connection()
+print(result.success, result.message)
+```
+
+## Features
+
+- **Connection management** — Azure SQL via pyodbc or pymssql
+- **Client/schema organization** — each client maps to a SQL schema
+- **File upload** — CSV, XLSX, XLS with auto encoding/detection
+- **Column normalization** — lowercase, accent-free, SQL-safe names
+- **Type inference** — automatic INTEGER, DECIMAL, DATE, NVARCHAR
+- **SQL query execution** — with safety validation (blocks DROP, DELETE, etc.)
+- **Query history** — stored in local SQLite
+- **Dataset browsing** — metadata, import logs, schema diff
+- **Benchmark** — measure upload performance across strategies
+
+## CLI
+
+```bash
+azure77 connection test          # Test Azure SQL connection
+azure77 connection status        # Show config status
+azure77 client list              # List clients
+azure77 client create "Nome"     # Create client
+azure77 upload preview file.csv  # Preview file
+azure77 upload import file.csv --client adl --table vendas
+azure77 datasets list adl        # List datasets
+azure77 benchmark run file.csv   # Run benchmark
+```
+
+## Configuration
+
+Create a `.env` file:
+
+```
+AZURE77_SERVER=server.database.windows.net
+AZURE77_DATABASE=dbname
+AZURE77_USER=username
+AZURE77_PASSWORD=password
+```
+
+Or pass directly:
+
+```python
+cm = ConnectionManager(
+    server="...",
+    database="...",
+    user="...",
+    password="...",
+    driver="pymssql",  # or "pyodbc"
+)
+```
+
+## License
+
+MIT

azure77-0.1.0/README.md

@@ -0,0 +1,79 @@
+# azure77
+
+Upload, query and manage data on Azure SQL Server from Python.
+
+## Installation
+
+```bash
+pip install azure77
+```
+
+## Quick Start
+
+```python
+from azure77 import ConnectionManager
+
+# Connect to Azure SQL
+cm = ConnectionManager(
+    server="your-server.database.windows.net",
+    database="your-db",
+    user="your-user",
+    password="your-pass",
+)
+
+# Test connection
+result = cm.test_connection()
+print(result.success, result.message)
+```
+
+## Features
+
+- **Connection management** — Azure SQL via pyodbc or pymssql
+- **Client/schema organization** — each client maps to a SQL schema
+- **File upload** — CSV, XLSX, XLS with auto encoding/detection
+- **Column normalization** — lowercase, accent-free, SQL-safe names
+- **Type inference** — automatic INTEGER, DECIMAL, DATE, NVARCHAR
+- **SQL query execution** — with safety validation (blocks DROP, DELETE, etc.)
+- **Query history** — stored in local SQLite
+- **Dataset browsing** — metadata, import logs, schema diff
+- **Benchmark** — measure upload performance across strategies
+
+## CLI
+
+```bash
+azure77 connection test          # Test Azure SQL connection
+azure77 connection status        # Show config status
+azure77 client list              # List clients
+azure77 client create "Nome"     # Create client
+azure77 upload preview file.csv  # Preview file
+azure77 upload import file.csv --client adl --table vendas
+azure77 datasets list adl        # List datasets
+azure77 benchmark run file.csv   # Run benchmark
+```
+
+## Configuration
+
+Create a `.env` file:
+
+```
+AZURE77_SERVER=server.database.windows.net
+AZURE77_DATABASE=dbname
+AZURE77_USER=username
+AZURE77_PASSWORD=password
+```
+
+Or pass directly:
+
+```python
+cm = ConnectionManager(
+    server="...",
+    database="...",
+    user="...",
+    password="...",
+    driver="pymssql",  # or "pyodbc"
+)
+```
+
+## License
+
+MIT

azure77-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "azure77"
+version = "0.1.0"
+description = "Upload, query and manage data on Azure SQL Server from Python"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "77 Indicadores" },
+]
+keywords = ["azure", "sql", "database", "upload", "data"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "pyodbc>=4.0.30",
+    "python-dotenv>=0.19",
+    "unidecode>=1.3",
+    "chardet>=5.0",
+    "openpyxl>=3.1",
+    "xlrd>=2.0",
+    "click>=8.0",
+    "rich>=12.0",
+]
+
+[project.scripts]
+azure77 = "azure77.cli:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]

azure77-0.1.0/setup.cfg

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

azure77-0.1.0/src/azure77/__init__.py

@@ -0,0 +1,86 @@
+"""azure77 -- Azure SQL Connection Management for Python."""
+
+from azure77.connection_manager import ConnectionManager
+from azure77.datasets.exceptions import (
+    ClientNotFoundError as DatasetsClientNotFoundError,
+    DatasetServiceError,
+    MetadataQueryError,
+    TableNotFoundError,
+)
+from azure77.datasets.models import (
+    ClientSummary,
+    ColumnMetadata,
+    DatasetMetadata,
+    DatasetSummary,
+    SchemaDiff,
+    VersionEvent,
+)
+from azure77.datasets.service import DatasetService
+from azure77.exceptions import ConfigError, ConnectionTestError
+from azure77.models import (
+    ConfigStatus,
+    ConfigTestResult,
+    QueryHistoryEntry,
+    QueryResult,
+    SavedQuery,
+)
+from azure77.query_service import QueryService
+from azure77.safety import SafetyValidator
+from azure77.sql_parser import extract_command_tokens
+
+from azure77.client_service import ClientService
+from azure77.client_models import client_record, schema_validation_result
+from azure77.client_exceptions import (
+    Azure77Error,
+    ClientNotFoundError,
+    ClientValidationError,
+    DuplicateSlugError,
+    SchemaOperationError,
+    SlugValidationError,
+)
+
+__all__ = [
+    # connection_manager
+    "ConnectionManager",
+    # exceptions
+    "ConfigError",
+    "ConnectionTestError",
+    # models
+    "ConfigTestResult",
+    "ConfigStatus",
+    "QueryHistoryEntry",
+    "QueryResult",
+    "SavedQuery",
+    # query_service
+    "QueryService",
+    # safety
+    "SafetyValidator",
+    # sql_parser
+    "extract_command_tokens",
+    # datasets.service
+    "DatasetService",
+    # datasets.models
+    "DatasetSummary",
+    "ColumnMetadata",
+    "DatasetMetadata",
+    "ClientSummary",
+    "VersionEvent",
+    "SchemaDiff",
+    # datasets.exceptions
+    "DatasetServiceError",
+    "DatasetsClientNotFoundError",
+    "TableNotFoundError",
+    "MetadataQueryError",
+    # client_service
+    "ClientService",
+    # client_models
+    "client_record",
+    "schema_validation_result",
+    # client_exceptions
+    "Azure77Error",
+    "ClientNotFoundError",
+    "ClientValidationError",
+    "DuplicateSlugError",
+    "SchemaOperationError",
+    "SlugValidationError",
+]

azure77-0.1.0/src/azure77/benchmark/__init__.py

@@ -0,0 +1,25 @@
+"""azure77.benchmark -- Performance benchmarking for upload strategies."""
+
+from azure77.benchmark.models import (
+    AggregateResult,
+    BenchmarkConfig,
+    BenchmarkReport,
+    CategorySuggestion,
+    EnvironmentInfo,
+    OptimizationSuggestions,
+    StrategyResult,
+    TimingSample,
+    VarianceWarning,
+)
+
+__all__ = [
+    "AggregateResult",
+    "BenchmarkConfig",
+    "BenchmarkReport",
+    "CategorySuggestion",
+    "EnvironmentInfo",
+    "OptimizationSuggestions",
+    "StrategyResult",
+    "TimingSample",
+    "VarianceWarning",
+]

azure77-0.1.0/src/azure77/benchmark/advisor.py

@@ -0,0 +1,128 @@
+"""Rule-based optimization advisor for benchmark reports."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from azure77.benchmark.models import (
+    BenchmarkReport,
+    CategorySuggestion,
+    OptimizationSuggestions,
+    VarianceWarning,
+)
+
+# ---------------------------------------------------------------------------
+# Thresholds
+# ---------------------------------------------------------------------------
+
+SMALL_MAX_BYTES = 1_000_000        # < 1 MB
+LARGE_MIN_BYTES = 50_000_000       # > 50 MB
+CV_WARNING_THRESHOLD = 0.15        # coefficient of variation
+
+
+def _categorize(file_size_bytes: int) -> str:
+    """Return 'small', 'medium', or 'large' for a given file size."""
+    if file_size_bytes < SMALL_MAX_BYTES:
+        return "small"
+    if file_size_bytes > LARGE_MIN_BYTES:
+        return "large"
+    return "medium"
+
+
+class OptimizationAdvisor:
+    """Analyze a BenchmarkReport and produce OptimizationSuggestions."""
+
+    def analyze(self, report: BenchmarkReport) -> OptimizationSuggestions:
+        """Produce rule-based recommendations from a completed report.
+
+        Steps:
+            1. Categorize StrategyResults by file_size_bytes.
+            2. Recommend the strategy with lowest mean_wall_clock per category.
+            3. Compute estimated_savings per strategy vs the slowest strategy.
+            4. Emit VarianceWarning for any pair with CV > 0.15.
+            5. Determine overall_recommendation as best strategy across all data.
+        """
+
+        # ------------------------------------------------------------------
+        # 1. Categorize StrategyResults
+        # ------------------------------------------------------------------
+        bucketed: dict[str, list] = defaultdict(list)
+        for sr in report.strategy_results:
+            bucketed[_categorize(sr.file_size_bytes)].append(sr)
+
+        # ------------------------------------------------------------------
+        # 2. Per-category recommendations
+        # ------------------------------------------------------------------
+        category_recommendations: dict[str, CategorySuggestion] = {}
+        for cat_name in ("small", "medium", "large"):
+            results = bucketed.get(cat_name)
+            if not results:
+                continue
+
+            # Average mean_wall_clock per strategy within this category
+            strategy_times: dict[str, list[float]] = defaultdict(list)
+            for sr in results:
+                strategy_times[sr.strategy_id].append(sr.aggregate.mean_wall_clock)
+
+            avg_times = {
+                sid: sum(times) / len(times)
+                for sid, times in strategy_times.items()
+            }
+
+            best_strategy = min(avg_times, key=avg_times.get)
+            worst_time = max(avg_times.values())
+            savings = worst_time - avg_times[best_strategy]
+
+            category_recommendations[cat_name] = CategorySuggestion(
+                category=cat_name,
+                recommended_strategy=best_strategy,
+                estimated_savings=savings,
+            )
+
+        # ------------------------------------------------------------------
+        # 3. Overall estimated savings per strategy
+        # ------------------------------------------------------------------
+        all_strategy_times: dict[str, list[float]] = defaultdict(list)
+        for sr in report.strategy_results:
+            all_strategy_times[sr.strategy_id].append(sr.aggregate.mean_wall_clock)
+
+        overall_avg = {
+            sid: sum(times) / len(times)
+            for sid, times in all_strategy_times.items()
+        }
+        overall_worst = max(overall_avg.values()) if overall_avg else 0.0
+        estimated_savings = {
+            sid: overall_worst - avg for sid, avg in overall_avg.items()
+        }
+
+        # ------------------------------------------------------------------
+        # 4. Variance warnings
+        # ------------------------------------------------------------------
+        variance_warnings: list[VarianceWarning] = []
+        for sr in report.strategy_results:
+            cv = sr.aggregate.coefficient_of_variation
+            if cv > CV_WARNING_THRESHOLD:
+                variance_warnings.append(
+                    VarianceWarning(
+                        strategy_id=sr.strategy_id,
+                        file_path=sr.file_path,
+                        coefficient_of_variation=cv,
+                    )
+                )
+
+        # ------------------------------------------------------------------
+        # 5. Overall recommendation
+        # ------------------------------------------------------------------
+        overall_recommendation: str | None = (
+            min(overall_avg, key=overall_avg.get) if overall_avg else None
+        )
+
+        # ------------------------------------------------------------------
+        # 6. Build and return
+        # ------------------------------------------------------------------
+        return OptimizationSuggestions(
+            category_recommendations=category_recommendations,
+            overall_recommendation=overall_recommendation,
+            estimated_savings=estimated_savings,
+            variance_warnings=variance_warnings,
+        )

azure77-0.1.0/src/azure77/benchmark/models.py

@@ -0,0 +1,112 @@
+"""Data models for the benchmark module.
+
+All structures are stdlib dataclasses designed for easy serialization
+via ``dataclasses.asdict()`` and JSON persistence.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class TimingSample:
+    """Raw measurement from a single benchmark iteration."""
+
+    wall_clock_seconds: float
+    peak_memory_bytes: int | None = None
+
+
+@dataclass
+class AggregateResult:
+    """Statistical summary computed across multiple TimingSamples."""
+
+    min_wall_clock: float
+    max_wall_clock: float
+    mean_wall_clock: float
+    median_wall_clock: float
+    std_dev_wall_clock: float
+    coefficient_of_variation: float
+    rows_per_sec: float
+    bytes_per_sec: float
+    failed_iterations: int
+
+
+@dataclass
+class StrategyResult:
+    """Aggregated results for one strategy tested against one file."""
+
+    strategy_id: str
+    file_path: str
+    row_count: int
+    column_count: int
+    file_size_bytes: int
+    iterations: list[TimingSample]
+    aggregate: AggregateResult
+    timed_out: bool = False
+    error_message: str | None = None
+
+
+@dataclass
+class BenchmarkConfig:
+    """Configuration parameters for a benchmark run."""
+
+    iterations: int = 3
+    warmup_iterations: int = 1
+    timeout_seconds: int = 1800
+    memory_tracking: bool = False
+
+
+@dataclass
+class EnvironmentInfo:
+    """Metadata about the runtime environment."""
+
+    python_version: str
+    os_info: str
+    platform_name: str
+    pyodbc_version: str
+    machine: str
+    processor: str
+
+
+@dataclass
+class BenchmarkReport:
+    """Top-level report produced by a completed benchmark run."""
+
+    run_id: str
+    timestamp: str
+    mode: str
+    config: BenchmarkConfig
+    environment: EnvironmentInfo
+    strategy_results: list[StrategyResult]
+    rankings: list[str]
+    aggregate: AggregateResult | None = None
+
+
+@dataclass
+class CategorySuggestion:
+    """Recommended strategy for a file size category."""
+
+    category: str
+    recommended_strategy: str
+    estimated_savings: float
+
+
+@dataclass
+class VarianceWarning:
+    """Warning for a strategy-file pair with high coefficient of variation."""
+
+    strategy_id: str
+    file_path: str
+    coefficient_of_variation: float
+
+
+@dataclass
+class OptimizationSuggestions:
+    """Rule-based recommendations derived from a BenchmarkReport."""
+
+    category_recommendations: dict[str, CategorySuggestion]
+    overall_recommendation: str | None
+    estimated_savings: dict[str, float]
+    variance_warnings: list[VarianceWarning]