snowlib 0.4.0__tar.gz → 0.4.2__tar.gz

{snowlib-0.4.0 → snowlib-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowlib
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python-Snowflake utilities
 Author: Rashad Aziz
 Maintainer: Rashad Aziz

{snowlib-0.4.0 → snowlib-0.4.2}/src/snowlib/__init__.py

@@ -35,13 +35,15 @@ from snowlib.models import (
     MaterializedView,
     DynamicTable,
     Column,
+    Stage,
+    StageObject,
     Show,
 )
 
 # Session: Context-bound convenience layer
 from snowlib.session import Session, create_session
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 __all__ = [
     # Layer 1: Configuration & Connection
     "load_profile", 
@@ -65,6 +67,8 @@ __all__ = [
     "MaterializedView",
     "DynamicTable",
     "Column",
+    "Stage",
+    "StageObject",
     "Show",
     # Session
     "Session",

{snowlib-0.4.0 → snowlib-0.4.2}/src/snowlib/context.py

@@ -78,7 +78,9 @@ class SnowflakeContext:
         for config_key, query, friendly_name in validations:
             declared = cfg.get(config_key)
             if declared:
-                result = self._cursor.execute(query).fetchone()
+                assert self._cursor is not None
+                self._cursor.execute(query)
+                result = self._cursor.fetchone()
                 actual = result[0] if result and result[0] else None
                 
                 if actual is None:

{snowlib-0.4.0 → snowlib-0.4.2}/src/snowlib/models/__init__.py

@@ -2,18 +2,22 @@
 
 from .database import Database
 from .schema import Schema
-from .table import Table, View, MaterializedView, DynamicTable, TableLike
+from .table import Table, View, MaterializedView, DynamicTable, TableLike, WriteMethod
 from .column import Column
+from .stage import Stage, StageObject
 from .base.show import Show
 
 __all__ = [
     "Database",
     "Schema",
     "Table",
+    "WriteMethod",
     "View",
     "MaterializedView",
     "DynamicTable",
     "Column",
     "TableLike",
+    "Stage",
+    "StageObject",
     "Show",
 ]

{snowlib-0.4.0 → snowlib-0.4.2}/src/snowlib/models/schema.py

@@ -9,6 +9,7 @@ from .base import Container, FQN
 if TYPE_CHECKING:
     from .database import Database
     from .table import Table, View
+    from .stage import Stage
 
 
 class Schema(Container):
@@ -89,6 +90,11 @@ class Schema(Container):
         from .table import View
         return View(self._database_name, self._schema_name, name, self._context)
     
+    def stage(self, name: str) -> 'Stage':
+        """Get specific stage by name"""
+        from .stage import Stage
+        return Stage(self._database_name, self._schema_name, name, self._context)
+    
     def has_table(self, name: str) -> bool:
         """Check if table exists in schema"""
         from .table import Table
@@ -97,4 +103,9 @@ class Schema(Container):
     def has_view(self, name: str) -> bool:
         """Check if view exists in schema"""
         from .table import View
-        return self._show_instance.exists(View, name, container=self)
+        return self._show_instance.exists(View, name, container=self)
+    
+    def has_stage(self, name: str) -> bool:
+        """Check if stage exists in schema"""
+        from .stage import Stage
+        return self._show_instance.exists(Stage, name, container=self)

snowlib-0.4.2/src/snowlib/models/stage.py

@@ -0,0 +1,178 @@
+"""Stage object class for managing Snowflake stages"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import ClassVar, Optional, Any, cast
+
+from snowlib.context import SnowflakeContext
+from snowlib.models.base import SchemaChild
+from snowlib.primitives import execute_sql, query
+
+try:
+    from tqdm import tqdm
+    HAS_TQDM = True
+except ImportError:
+    tqdm = None  # type: ignore
+    HAS_TQDM = False
+
+
+@dataclass
+class StageObject:
+    """Represents a file or directory in a Snowflake stage"""
+    
+    name: str
+    size: int
+    md5: Optional[str]
+    last_modified: datetime
+    _stage: Stage
+    
+    @property
+    def path(self) -> str:
+        """Full path within the stage (e.g., @DB.SCHEMA.STAGE/path/to/file.csv)"""
+        return f"@{self._stage.fqn}/{self.name}"
+    
+    def exists(self) -> bool:
+        """Check if this object still exists in the stage"""
+        df = query(f"LIST {self.path}", self._stage._context)
+        return len(df) > 0
+    
+    def delete(self) -> dict[str, Any]:
+        """Delete this object from the stage, returns the result info"""
+        result = execute_sql(f"REMOVE {self.path}", self._stage._context)
+        df = result.to_df()
+        if len(df) > 0:
+            return cast(dict[str, Any], df.iloc[0].to_dict())
+        return {"status": "no result"}
+    
+    def __repr__(self) -> str:
+        return f"StageObject({self.name!r}, size={self.size})"
+
+
+class Stage(SchemaChild):
+    """Represents a Snowflake internal named stage"""
+    
+    SHOW_PLURAL: ClassVar[str] = "STAGES"
+    SHOW_NAME_COLUMN: ClassVar[str] = "name"
+    
+    def __init__(
+        self,
+        database: str,
+        schema: str,
+        name: str,
+        context: SnowflakeContext
+    ):
+        """Initialize stage object"""
+        super().__init__(database, schema, name, context)
+    
+    @property
+    def stage_path(self) -> str:
+        """Stage path with @ prefix for use in SQL"""
+        return f"@{self.fqn}"
+    
+    def create(self, if_not_exists: bool = True) -> Stage:
+        """Create the stage in Snowflake"""
+        sql = "CREATE STAGE"
+        if if_not_exists:
+            sql += " IF NOT EXISTS"
+        sql += f" {self.fqn}"
+        execute_sql(sql, self._context)
+        return self
+    
+    def drop(self, if_exists: bool = False) -> None:
+        """Drop the stage"""
+        sql = "DROP STAGE"
+        if if_exists:
+            sql += " IF EXISTS"
+        sql += f" {self.fqn}"
+        execute_sql(sql, self._context)
+    
+    def list(self, pattern: Optional[str] = None) -> list[StageObject]:
+        """List all objects in the stage"""
+        sql = f"LIST {self.stage_path}"
+        if pattern:
+            sql += f" PATTERN = '{pattern}'"
+        
+        df = query(sql, self._context)
+        
+        objects = []
+        for _, row in df.iterrows():
+            obj = StageObject(
+                name=row['name'].replace(self.stage_path + '/', ''),
+                size=row['size'],
+                md5=row.get('md5'),
+                last_modified=row['last_modified'],
+                _stage=self,
+            )
+            objects.append(obj)
+        
+        return objects
+    
+    @property
+    def objects(self) -> list[StageObject]:
+        """Get all objects in the stage"""
+        return self.list()
+    
+    def clear(self) -> list[dict[str, Any]]:
+        """Remove all files from the stage"""
+        result = execute_sql(f"REMOVE {self.stage_path}", self._context)
+        df = result.to_df()
+        return cast(list[dict[str, Any]], df.to_dict('records')) if len(df) > 0 else []
+    
+    def load(
+        self,
+        files: list[Path],
+        auto_compress: bool = True,
+        overwrite: bool = False,
+        show_progress: bool = True,
+    ) -> list[dict[str, Any]]:
+        """Upload local files to the stage with progress bar"""
+        results = []
+        
+        iterator = tqdm(files, desc="Uploading") if (show_progress and HAS_TQDM and tqdm is not None) else files
+        
+        for file_path in iterator:
+            if not file_path.exists():
+                results.append({
+                    "source": str(file_path),
+                    "status": "ERROR",
+                    "message": "File not found",
+                })
+                continue
+            
+            sql = f"PUT 'file://{file_path.as_posix()}' {self.stage_path}"
+            sql += f" AUTO_COMPRESS = {str(auto_compress).upper()}"
+            sql += f" OVERWRITE = {str(overwrite).upper()}"
+            
+            try:
+                result = execute_sql(sql, self._context)
+                df = result.to_df()
+                if len(df) > 0:
+                    row_dict = cast(dict[str, Any], df.iloc[0].to_dict())
+                    row_dict["query_id"] = result.query_id
+                    results.append(row_dict)
+                else:
+                    results.append({
+                        "source": str(file_path),
+                        "status": "UNKNOWN",
+                        "query_id": result.query_id,
+                    })
+            except Exception as e:
+                results.append({
+                    "source": str(file_path),
+                    "status": "ERROR",
+                    "message": str(e),
+                })
+        
+        # Print summary
+        uploaded = sum(1 for r in results if r.get("status") == "UPLOADED")
+        skipped = sum(1 for r in results if r.get("status") == "SKIPPED")
+        failed = sum(1 for r in results if r.get("status") in ("ERROR", "UNKNOWN"))
+        print(f"Upload complete: {uploaded} uploaded, {skipped} skipped, {failed} failed")
+        
+        return results
+    
+    def __repr__(self) -> str:
+        return f"Stage({self.fqn!r})"

{snowlib-0.4.0 → snowlib-0.4.2}/src/snowlib/models/table/__init__.py

@@ -1,7 +1,7 @@
 """Table-like Snowflake objects (tables, views, materialized views, dynamic tables)."""
 
 from snowlib.models.table.base import TableLike
-from snowlib.models.table.table import Table
+from snowlib.models.table.table import Table, WriteMethod
 from snowlib.models.table.view import View
 from snowlib.models.table.materialized_view import MaterializedView
 from snowlib.models.table.dynamic_table import DynamicTable
@@ -9,6 +9,7 @@ from snowlib.models.table.dynamic_table import DynamicTable
 __all__ = [
     "TableLike",
     "Table",
+    "WriteMethod",
     "View",
     "MaterializedView",
     "DynamicTable",