fakesnow 0.9.41__py3-none-any.whl → 0.9.42__py3-none-any.whl

fakesnow/copy_into.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import datetime
+import os
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import Any, NamedTuple, Protocol, cast
+from pathlib import Path
+from typing import Any, NamedTuple, Protocol, Union, cast
 from urllib.parse import urlparse, urlunparse
 
 import duckdb
@@ -13,6 +15,9 @@ from sqlglot import exp
 
 import fakesnow.transforms.stage as stage
 from fakesnow import logger
+from fakesnow.params import MutableParams, pop_qmark_param
+
+Params = Union[Sequence[Any], dict[Any, Any]]
 
 
 class LoadHistoryRecord(NamedTuple):
@@ -38,9 +43,9 @@ def copy_into(
     current_database: str | None,
     current_schema: str | None,
     expr: exp.Copy,
-    params: Sequence[Any] | dict[Any, Any] | None = None,
+    params: MutableParams | None = None,
 ) -> str:
-    cparams = _params(expr)
+    cparams = _params(expr, params)
     if isinstance(cparams.file_format, ReadParquet):
         from_ = expr.args["files"][0]
         # parquet must use MATCH_BY_COLUMN_NAME (TODO) or a copy transformation
@@ -54,11 +59,15 @@ def copy_into(
 
     from_source = _from_source(expr)
     source = (
-        stage_url_from_var(from_source, duck_conn, current_database, current_schema)
+        stage_url_from_var(from_source[1:], duck_conn, current_database, current_schema)
         if from_source.startswith("@")
         else from_source
     )
-    urls = _source_urls(source, cparams.files)
+    urls = _source_urls(source, cparams.files) if cparams.files else _source_glob(source, duck_conn)
+    if not urls:
+        sql = "SELECT 'Copy executed with 0 files processed.' AS status"
+        duck_conn.execute(sql)
+        return sql
 
     inserts = _inserts(expr, cparams, urls)
     table = expr.this
@@ -95,6 +104,10 @@ def copy_into(
                 error_limit = 1
                 error_count = 0
                 first_error_message = None
+                path = urlparse(url).path
+                if cparams.purge and stage.is_internal(path):
+                    # If the file is internal, we can remove it from the stage
+                    os.remove(path)
 
             history = LoadHistoryRecord(
                 schema_name=schema,
@@ -123,7 +136,7 @@ def copy_into(
             "first_error_character, first_error_column_name"
         )
         values = "\n, ".join(
-            f"('{h.file_name}', '{h.status}', {h.row_parsed}, {h.row_count}, "
+            f"('{_result_file_name(h.file_name)}', '{h.status}', {h.row_parsed}, {h.row_count}, "
             f"{h.error_limit or 'NULL'}, {h.error_count}, "
             f"{repr(h.first_error_message) if h.first_error_message else 'NULL'}, "
             f"{h.first_error_line_number or 'NULL'}, {h.first_error_character_position or 'NULL'}, "
@@ -132,6 +145,7 @@ def copy_into(
         )
         sql = f"SELECT * FROM (VALUES\n  {values}\n) AS t({columns})"
         duck_conn.execute(sql)
+
         return sql
     except duckdb.HTTPException as e:
         raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=91016, sqlstate="22000") from None
@@ -139,13 +153,23 @@ def copy_into(
         raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=100038, sqlstate="22018") from None
 
 
-def _params(expr: exp.Copy) -> Params:
+def _result_file_name(url: str) -> str:
+    if not stage.is_internal(urlparse(url).path):
+        return url
+
+    # for internal stages, return the stage name lowered + file name
+    parts = url.split("/")
+    return f"{parts[-2].lower()}/{parts[-1]}"
+
+
+def _params(expr: exp.Copy, params: MutableParams | None = None) -> CopyParams:
     kwargs = {}
     force = False
+    purge = False
+    on_error = "ABORT_STATEMENT"
 
-    params = cast(list[exp.CopyParameter], expr.args.get("params", []))
-    cparams = Params()
-    for param in params:
+    cparams = CopyParams()
+    for param in cast(list[exp.CopyParameter], expr.args.get("params", [])):
         assert isinstance(param.this, exp.Var), f"{param.this.__class__} is not a Var"
         var = param.this.name.upper()
         if var == "FILE_FORMAT":
@@ -166,10 +190,22 @@ def _params(expr: exp.Copy) -> Params:
             force = True
         elif var == "FILES":
             kwargs["files"] = [lit.name for lit in param.find_all(exp.Literal)]
+        elif var == "PURGE":
+            purge = True
+        elif var == "ON_ERROR":
+            if isinstance(param.expression, exp.Var):
+                on_error = param.expression.name.upper()
+            elif isinstance(param.expression, exp.Placeholder):
+                on_error = pop_qmark_param(params, expr, param.expression)
+            else:
+                raise NotImplementedError(f"{param.expression.__class__=}")
+
+            if not (isinstance(on_error, str) and on_error.upper() == "ABORT_STATEMENT"):
+                raise NotImplementedError(param)
         else:
             raise ValueError(f"Unknown copy parameter: {param.this}")
 
-    return Params(force=force, **kwargs)
+    return CopyParams(force=force, purge=purge, on_error=on_error, **kwargs)
 
 
 def _from_source(expr: exp.Copy) -> str:
@@ -191,6 +227,9 @@ def _from_source(expr: exp.Copy) -> str:
             )
         # return the name of the stage, eg: @stage1
         return var.this
+    elif isinstance(from_, exp.Var):
+        # return the name of the stage, eg: @stage1
+        return from_.this
 
     assert isinstance(from_, exp.Literal), f"{from_} is not a exp.Literal"
     # return url
@@ -198,9 +237,9 @@ def _from_source(expr: exp.Copy) -> str:
 
 
 def stage_url_from_var(
-    from_source: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
+    var: str, duck_conn: DuckDBPyConnection, current_database: str | None, current_schema: str | None
 ) -> str:
-    database_name, schema_name, name = stage.parts_from_var(from_source, current_database, current_schema)
+    database_name, schema_name, name = stage.parts_from_var(var, current_database, current_schema)
 
     # Look up the stage URL
     duck_conn.execute(
@@ -211,7 +250,9 @@ def stage_url_from_var(
         (database_name, schema_name, name),
     )
     if result := duck_conn.fetchone():
-        return result[0]
+        # if no URL is found, it is an internal stage ie: local directory
+        url = result[0] or stage.internal_dir(f"{database_name}.{schema_name}.{name}")
+        return url
     else:
         raise snowflake.connector.errors.ProgrammingError(
             msg=f"SQL compilation error:\nStage '{database_name}.{schema_name}.{name}' does not exist or not authorized.",  # noqa: E501
@@ -220,16 +261,29 @@ def stage_url_from_var(
         )
 
 
-def _source_urls(from_source: str, files: list[str]) -> list[str]:
+def _source_urls(source: str, files: list[str]) -> list[str]:
     """Convert from_source to a list of URLs."""
-    scheme, netloc, path, params, query, fragment = urlparse(from_source)
+    scheme, netloc, path, params, query, fragment = urlparse(source)
     if not scheme:
         raise snowflake.connector.errors.ProgrammingError(
-            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{from_source}'", errno=1011, sqlstate="42601"
+            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{source}'", errno=1011, sqlstate="42601"
         )
 
     # rebuild url from components to ensure correct handling of host slash
-    return [_urlunparse(scheme, netloc, path, params, query, fragment, file) for file in files] or [from_source]
+    return [_urlunparse(scheme, netloc, path, params, query, fragment, file) for file in files] or [source]
+
+
+def _source_glob(source: str, duck_conn: DuckDBPyConnection) -> list[str]:
+    """List files from the source using duckdb glob."""
+    if stage.is_internal(source):
+        source = Path(source).as_uri()  # convert local directory to a file URL
+
+    scheme, _netloc, _path, _params, _query, _fragment = urlparse(source)
+    glob = f"{source}/*" if scheme == "file" else f"{source}*"
+    sql = f"SELECT file FROM glob('{glob}')"
+    logger.log_sql(sql)
+    result = duck_conn.execute(sql).fetchall()
+    return [r[0] for r in result]
 
 
 def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fragment: str, suffix: str) -> str:
@@ -245,7 +299,7 @@ def _urlunparse(scheme: str, netloc: str, path: str, params: str, query: str, fr
     return urlunparse((scheme, netloc, path, params, query, fragment))
 
 
-def _inserts(expr: exp.Copy, params: Params, urls: list[str]) -> list[exp.Expression]:
+def _inserts(expr: exp.Copy, params: CopyParams, urls: list[str]) -> list[exp.Expression]:
     # INTO expression
     target = expr.this
 
@@ -331,10 +385,8 @@ class ReadCSV(FileTypeHandler):
     delimiter: str = ","
 
     def read_expression(self, url: str) -> exp.Expression:
-        args = []
-
         # don't parse header and use as column names, keep them as column0, column1, etc
-        args.append(self.make_eq("header", False))
+        args = [self.make_eq("header", False)]
 
         if self.skip_header:
             args.append(self.make_eq("skip", 1))
@@ -357,8 +409,10 @@ class ReadParquet(FileTypeHandler):
 
 
 @dataclass
-class Params:
+class CopyParams:
     files: list[str] = field(default_factory=list)
     # Snowflake defaults to CSV when no file format is specified
     file_format: FileTypeHandler = field(default_factory=ReadCSV)
     force: bool = False
+    purge: bool = False
+    on_error: str = "ABORT_STATEMENT"  # Default to ABORT_STATEMENT

fakesnow/cursor.py

@@ -10,6 +10,7 @@ from types import TracebackType
 from typing import TYPE_CHECKING, Any, cast
 
 import duckdb
+import pandas as pd
 import pyarrow  # needed by fetch_arrow_table()
 import snowflake.connector.converter
 import snowflake.connector.errors
@@ -27,7 +28,9 @@ import fakesnow.info_schema as info_schema
 import fakesnow.transforms as transforms
 from fakesnow import logger
 from fakesnow.copy_into import copy_into
+from fakesnow.params import MutableParams
 from fakesnow.rowtype import describe_as_result_metadata
+from fakesnow.transforms import stage
 
 if TYPE_CHECKING:
     # don't require pandas at import time
@@ -41,6 +44,7 @@ SCHEMA_UNSET = "schema_unset"
 SQL_SUCCESS = "SELECT 'Statement executed successfully.' as 'status'"
 SQL_CREATED_DATABASE = Template("SELECT 'Database ${name} successfully created.' as 'status'")
 SQL_CREATED_SCHEMA = Template("SELECT 'Schema ${name} successfully created.' as 'status'")
+SQL_CREATED_SECRET = Template("SELECT 'Secret ${name} successfully created.' as 'status'")
 SQL_CREATED_TABLE = Template("SELECT 'Table ${name} successfully created.' as 'status'")
 SQL_CREATED_VIEW = Template("SELECT 'View ${name} successfully created.' as 'status'")
 SQL_CREATED_STAGE = Template("SELECT 'Stage area ${name} successfully created.' as status")
@@ -146,7 +150,8 @@ class FakeSnowflakeCursor:
             self._sqlstate = None
 
             if os.environ.get("FAKESNOW_DEBUG") == "snowflake":
-                print(f"{command};{params=}" if params else f"{command};", file=sys.stderr)
+                p = params or kwargs.get("binding_params")
+                print(f"{command};params={p}" if p else f"{command};", file=sys.stderr)
 
             command = self._inline_variables(command)
             if kwargs.get("binding_params"):
@@ -155,6 +160,10 @@ class FakeSnowflakeCursor:
             else:
                 command, params = self._rewrite_with_params(command, params)
 
+            # convert tuple to mutable list
+            if not isinstance(params, (list, dict)) and params is not None:
+                params = list(params)
+
             if self._conn.nop_regexes and any(re.match(p, command, re.IGNORECASE) for p in self._conn.nop_regexes):
                 transformed = transforms.SUCCESS_NOP
                 self._execute(transformed, params)
@@ -164,9 +173,12 @@ class FakeSnowflakeCursor:
             self.check_db_and_schema(expression)
 
             for exp in self._transform_explode(expression):
-                transformed = self._transform(exp)
+                transformed = self._transform(exp, params)
                 self._execute(transformed, params)
 
+            if not kwargs.get("server") and (put_stage_data := transformed.args.get("put_stage_data")):  # pyright: ignore[reportPossiblyUnboundVariable]
+                self._put_files(put_stage_data)
+
             return self
         except snowflake.connector.errors.ProgrammingError as e:
             self._sqlstate = e.sqlstate
@@ -180,6 +192,13 @@ class FakeSnowflakeCursor:
             msg = f"{e} not implemented. Please raise an issue via https://github.com/tekumara/fakesnow/issues/new"
             raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=9999, sqlstate="99999") from e
 
+    def _put_files(self, put_stage_data: stage.UploadCommandDict) -> None:
+        results = stage.upload_files(put_stage_data)
+        _df = pd.DataFrame.from_records(results)
+        self._duck_conn.execute("select * from _df")
+        self._arrow_table = self._duck_conn.fetch_arrow_table()
+        self._rowcount = self._arrow_table.num_rows
+
     def check_db_and_schema(self, expression: exp.Expression) -> None:
         no_database, no_schema = checks.is_unqualified_table_expression(expression)
 
@@ -198,9 +217,10 @@ class FakeSnowflakeCursor:
                 sqlstate="22000",
             )
 
-    def _transform(self, expression: exp.Expression) -> exp.Expression:
+    def _transform(self, expression: exp.Expression, params: MutableParams | None) -> exp.Expression:
         return (
-            expression.transform(transforms.upper_case_unquoted_identifiers)
+            expression.transform(lambda e: transforms.identifier(e, params))
+            .transform(transforms.upper_case_unquoted_identifiers)
             .transform(transforms.update_variables, variables=self._conn.variables)
             .transform(transforms.set_schema, current_database=self._conn.database)
             .transform(transforms.create_database, db_path=self._conn.db_path)
@@ -238,7 +258,6 @@ class FakeSnowflakeCursor:
             .transform(transforms.sample)
             .transform(transforms.array_size)
             .transform(transforms.random)
-            .transform(transforms.identifier)
             .transform(transforms.array_agg_within_group)
             .transform(transforms.array_agg)
             .transform(transforms.array_construct_etc)
@@ -264,7 +283,8 @@ class FakeSnowflakeCursor:
             .transform(transforms.alias_in_join)
             .transform(transforms.alter_table_strip_cluster_by)
             .transform(lambda e: transforms.create_stage(e, self._conn.database, self._conn.schema))
-            .transform(lambda e: transforms.put_stage(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.list_stage(e, self._conn.database, self._conn.schema))
+            .transform(lambda e: transforms.put_stage(e, self._conn.database, self._conn.schema, params))
         )
 
     def _transform_explode(self, expression: exp.Expression) -> list[exp.Expression]:
@@ -272,7 +292,7 @@ class FakeSnowflakeCursor:
         # Split transforms have limited support at the moment.
         return transforms.merge(expression)
 
-    def _execute(self, transformed: exp.Expression, params: Sequence[Any] | dict[Any, Any] | None = None) -> None:
+    def _execute(self, transformed: exp.Expression, params: MutableParams | None = None) -> None:
         self._arrow_table = None
         self._arrow_table_fetch_index = None
         self._rowcount = None
@@ -335,13 +355,26 @@ class FakeSnowflakeCursor:
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
         elif stage_name := transformed.args.get("create_stage_name"):
-            if stage_name == "?":
-                assert isinstance(params, (tuple, list)) and len(params) == 1, (
-                    "Expected single parameter for create_stage_name"
+            (affected_count,) = self._duck_conn.fetchall()[0]
+            if affected_count == 0:
+                raise snowflake.connector.errors.ProgrammingError(
+                    msg=f"SQL compilation error:\nObject '{stage_name}' already exists.",
+                    errno=2002,
+                    sqlstate="42710",
                 )
-                result_sql = SQL_CREATED_STAGE.substitute(name=params[0].upper())
-            else:
-                result_sql = SQL_CREATED_STAGE.substitute(name=stage_name.upper())
+            result_sql = SQL_CREATED_STAGE.substitute(name=stage_name)
+
+        elif stage_name := transformed.args.get("list_stage_name") or transformed.args.get("put_stage_name"):
+            if self._duck_conn.fetch_arrow_table().num_rows != 1:
+                raise snowflake.connector.errors.ProgrammingError(
+                    msg=f"SQL compilation error:\nStage '{stage_name}' does not exist or not authorized.",
+                    errno=2003,
+                    sqlstate="02000",
+                )
+            if transformed.args.get("list_stage_name"):
+                result_sql = stage.list_stage_files_sql(stage_name)
+            elif transformed.args.get("put_stage_name"):
+                result_sql = SQL_SUCCESS
 
         elif cmd == "INSERT":
             (affected_count,) = self._duck_conn.fetchall()[0]
@@ -365,8 +398,8 @@ class FakeSnowflakeCursor:
                 lambda e: transforms.describe_table(e, self._conn.database, self._conn.schema)
             ).sql(dialect="duckdb")
 
-        elif (eid := transformed.find(exp.Identifier, bfs=False)) and isinstance(eid.this, str):
-            ident = eid.this if eid.quoted else eid.this.upper()
+        elif eid := transformed.find(exp.Identifier, bfs=False):
+            ident = eid.name
             if cmd == "CREATE SCHEMA" and ident:
                 result_sql = SQL_CREATED_SCHEMA.substitute(name=ident)
 
@@ -389,6 +422,15 @@ class FakeSnowflakeCursor:
 
                 elif cmd == "DROP SCHEMA" and ident == self._conn.schema:
                     self._conn._schema = None  # noqa: SLF001
+        elif (
+            cmd == "CREATE"
+            and isinstance(transformed, exp.Command)
+            and isinstance(transformed.expression, str)
+            and transformed.expression.upper().startswith(" SECRET")
+        ):
+            match = re.search(r"SECRET\s+(\w+)\s*\(", transformed.expression, re.IGNORECASE)
+            secret_name = match[1].upper() if match else "UNKNOWN"
+            result_sql = SQL_CREATED_SECRET.substitute(name=secret_name)
 
         if table_comment := cast(tuple[exp.Table, str], transformed.args.get("table_comment")):
             # record table comment
@@ -415,18 +457,6 @@ class FakeSnowflakeCursor:
         self._rowcount = affected_count or self._arrow_table.num_rows
         self._sfqid = str(uuid.uuid4())
 
-        if stage_name := transformed.args.get("put_stage_name"):
-            if stage_name == "?":
-                assert isinstance(params, (tuple, list)) and len(params) == 1, (
-                    "Expected single parameter for put_stage_name"
-                )
-            if self._arrow_table.num_rows != 1:
-                raise snowflake.connector.errors.ProgrammingError(
-                    msg=f"SQL compilation error:\nStage '{stage_name}' does not exist or not authorized.",
-                    errno=2003,
-                    sqlstate="02000",
-                )
-
         self._last_sql = result_sql or sql
         self._last_params = None if result_sql else params
         self._last_transformed = transformed

fakesnow/params.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any, Union
+
+from sqlglot import exp
+
+MutableParams = Union[list[Any], dict[Any, Any]]
+
+
+def pop_qmark_param(params: MutableParams | None, expr: exp.Expression, pl: exp.Placeholder) -> Any:  # noqa: ANN401
+    assert isinstance(params, list), "params must be provided as a list or tuple to resolve qmarks"
+    i = index_of_placeholder(expr, pl)
+    return params.pop(i)
+
+
+def index_of_placeholder(expr: exp.Expression, target: exp.Placeholder) -> int:
+    """Count the number of prior placeholders to determine the index.
+
+    Args:
+        expression (exp.Expression): The expression to search.
+        ph (exp.Placeholder): The placeholder to find.
+
+    Returns:
+        int: The index of the placeholder, or -1 if not found.
+    """
+    for index, ph in enumerate(expr.find_all(exp.Placeholder, bfs=False)):
+        if ph is target:
+            return index
+    return -1

fakesnow/server.py

@@ -94,7 +94,7 @@ async def query_request(request: Request) -> JSONResponse:
 
         try:
             # only a single sql statement is sent at a time by the python snowflake connector
-            cur = await run_in_threadpool(conn.cursor().execute, sql_text, binding_params=params)
+            cur = await run_in_threadpool(conn.cursor().execute, sql_text, binding_params=params, server=True)
             rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
 
             expr = cur._last_transformed  # noqa: SLF001
@@ -124,7 +124,7 @@ async def query_request(request: Request) -> JSONResponse:
             )
         except Exception as e:
             # we have a bug or use of an unsupported feature
-            msg = f"{sql_text=} Unhandled exception"
+            msg = f"{sql_text=} {params=} Unhandled exception"
             logger.error(msg, exc_info=e)
             # my guess at mimicking a 500 error as per https://docs.snowflake.com/en/developer-guide/sql-api/reference
             # and https://github.com/snowflakedb/gosnowflake/blob/8ed4c75ffd707dd712ad843f40189843ace683c4/restful.go#L318

fakesnow/transforms/__init__.py

@@ -15,6 +15,7 @@ from fakesnow.transforms.show import (
 )
 from fakesnow.transforms.stage import (
     create_stage as create_stage,
+    list_stage as list_stage,
     put_stage as put_stage,
 )
 from fakesnow.transforms.transforms import (

fakesnow/transforms/show.py

@@ -62,9 +62,7 @@ def show_columns(
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-columns
     """
-    if not (
-        isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "COLUMNS"
-    ):
+    if not (isinstance(expression, exp.Show) and expression.name.upper() == "COLUMNS"):
         return expression
 
     scope_kind = expression.args.get("scope_kind")
@@ -139,7 +137,7 @@ def show_databases(expression: exp.Expression) -> exp.Expression:
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-databases
     """
-    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "DATABASES":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "DATABASES":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_databases", read="duckdb")
 
     return expression
@@ -177,7 +175,7 @@ def show_functions(expression: exp.Expression) -> exp.Expression:
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-functions
     """
-    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "FUNCTIONS":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "FUNCTIONS":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_show_functions", read="duckdb")
 
     return expression
@@ -197,11 +195,7 @@ def show_keys(
     if kind == "FOREIGN":
         snowflake_kind = "IMPORTED"
 
-    if (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == f"{snowflake_kind} KEYS"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == f"{snowflake_kind} KEYS":
         if kind == "FOREIGN":
             statement = f"""
                 SELECT
@@ -298,11 +292,7 @@ def show_procedures(expression: exp.Expression) -> exp.Expression:
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-procedures
     """
-    if (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "PROCEDURES"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == "PROCEDURES":
         return sqlglot.parse_one(
             "SELECT * FROM _fs_global._fs_information_schema._fs_show_procedures",
             read="duckdb",
@@ -333,7 +323,7 @@ def show_schemas(expression: exp.Expression, current_database: str | None) -> ex
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-schemas
     """
-    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "SCHEMAS":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "SCHEMAS":
         if (ident := expression.find(exp.Identifier)) and isinstance(ident.this, str):
             database = ident.this
         else:
@@ -350,9 +340,7 @@ def show_schemas(expression: exp.Expression, current_database: str | None) -> ex
 
 def show_stages(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
     """Transform SHOW STAGES to a select from the fake _fs_stages table."""
-    if not (
-        isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "STAGES"
-    ):
+    if not (isinstance(expression, exp.Show) and expression.name.upper() == "STAGES"):
         return expression
 
     scope_kind = expression.args.get("scope_kind")
@@ -480,8 +468,7 @@ def show_tables_etc(
     """Transform SHOW OBJECTS/TABLES/VIEWS to a query against the _fs_information_schema views."""
     if not (
         isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and (show := expression.this.upper())
+        and (show := expression.name.upper())
         and show in {"OBJECTS", "TABLES", "VIEWS"}
     ):
         return expression
@@ -538,7 +525,7 @@ def show_users(expression: exp.Expression) -> exp.Expression:
 
     https://docs.snowflake.com/en/sql-reference/sql/show-users
     """
-    if isinstance(expression, exp.Show) and isinstance(expression.this, str) and expression.this.upper() == "USERS":
+    if isinstance(expression, exp.Show) and expression.name.upper() == "USERS":
         return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users", read="duckdb")
 
     return expression
@@ -593,11 +580,7 @@ def show_warehouses(expression: exp.Expression) -> exp.Expression:
 
     See https://docs.snowflake.com/en/sql-reference/sql/show-warehouses
     """
-    if (
-        isinstance(expression, exp.Show)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "WAREHOUSES"
-    ):
+    if isinstance(expression, exp.Show) and expression.name.upper() == "WAREHOUSES":
         return sqlglot.parse_one(SQL_SHOW_WAREHOUSES, read="duckdb")
 
     return expression

fakesnow/transforms/stage.py

@@ -1,18 +1,44 @@
 from __future__ import annotations
 
 import datetime
+import os
+import tempfile
+from pathlib import PurePath
+from typing import Any, TypedDict
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
 import snowflake.connector.errors
 import sqlglot
+from snowflake.connector.file_util import SnowflakeFileUtil
 from sqlglot import exp
 
-LOCAL_BUCKET_PATH = "/tmp/fakesnow_bucket"
+from fakesnow.params import MutableParams
+
+# TODO: clean up temp files on exit
+LOCAL_BUCKET_PATH = tempfile.mkdtemp(prefix="fakesnow_bucket_")
+
+
+class StageInfoDict(TypedDict):
+    locationType: str
+    location: str
+    creds: dict[str, Any]
+
+
+class UploadCommandDict(TypedDict):
+    stageInfo: StageInfoDict
+    src_locations: list[str]
+    parallel: int
+    autoCompress: bool
+    sourceCompression: str
+    overwrite: bool
+    command: str
 
 
 def create_stage(
-    expression: exp.Expression, current_database: str | None, current_schema: str | None
+    expression: exp.Expression,
+    current_database: str | None,
+    current_schema: str | None,
 ) -> exp.Expression:
     """Transform CREATE STAGE to an INSERT statement for the fake stages table."""
     if not (
@@ -24,15 +50,17 @@ def create_stage(
     ):
         return expression
 
+    ident = table.this
+    if not isinstance(ident, exp.Identifier):
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=f"SQL compilation error:\nInvalid identifier type {ident.__class__.__name__} for stage name.",
+            errno=1003,
+            sqlstate="42000",
+        )
+
     catalog = table.catalog or current_database
     schema = table.db or current_schema
-    ident = table.this
-    if isinstance(ident, exp.Placeholder):
-        stage_name = "?"
-    elif isinstance(ident, exp.Identifier):
-        stage_name = ident.this if ident.quoted else ident.this.upper()
-    else:
-        raise ValueError(f"Invalid identifier type {ident.__class__.__name__} for stage name")
+    stage_name = ident.this
     now = datetime.datetime.now(datetime.timezone.utc).isoformat()
 
     is_temp = False
@@ -55,17 +83,19 @@ def create_stage(
     cloud = "AWS" if url.startswith("s3://") else None
 
     stage_type = ("EXTERNAL" if url else "INTERNAL") + (" TEMPORARY" if is_temp else "")
-    stage_name_value = stage_name if stage_name == "?" else repr(stage_name)
 
     insert_sql = f"""
         INSERT INTO _fs_global._fs_information_schema._fs_stages
         (created_on, name, database_name, schema_name, url, has_credentials, has_encryption_key, owner,
         comment, region, type, cloud, notification_channel, storage_integration, endpoint, owner_role_type,
         directory_enabled)
-        VALUES (
-            '{now}', {stage_name_value}, '{catalog}', '{schema}', '{url}', 'N', 'N', 'SYSADMIN',
+        SELECT
+            '{now}', '{stage_name}', '{catalog}', '{schema}', '{url}', 'N', 'N', 'SYSADMIN',
             '', NULL, '{stage_type}', {f"'{cloud}'" if cloud else "NULL"}, NULL, NULL, NULL, 'ROLE',
             'N'
+        WHERE NOT EXISTS (
+            SELECT 1 FROM _fs_global._fs_information_schema._fs_stages
+            WHERE name = '{stage_name}' AND database_name = '{catalog}' AND schema_name = '{schema}'
         )
         """
     transformed = sqlglot.parse_one(insert_sql, read="duckdb")
@@ -73,10 +103,44 @@ def create_stage(
     return transformed
 
 
-# TODO: handle ?
+def list_stage(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+    """Transform LIST to list file system operation.
 
+    See https://docs.snowflake.com/en/sql-reference/sql/list
+    """
+    if not (
+        isinstance(expression, exp.Alias)
+        and isinstance(expression.this, exp.Column)
+        and isinstance(expression.this.this, exp.Identifier)
+        and isinstance(expression.this.this.this, str)
+        and expression.this.this.this.upper() == "LIST"
+    ):
+        return expression
+
+    stage = expression.args["alias"].this
+    if not isinstance(stage, exp.Var):
+        raise ValueError(f"LIST command requires a stage name as a Var, got {stage}")
+
+    var = stage.text("this")
+    catalog, schema, stage_name = parts_from_var(var, current_database=current_database, current_schema=current_schema)
 
-def put_stage(expression: exp.Expression, current_database: str | None, current_schema: str | None) -> exp.Expression:
+    query = f"""
+        SELECT *
+        from _fs_global._fs_information_schema._fs_stages
+        where database_name = '{catalog}' and schema_name = '{schema}' and name = '{stage_name}'
+    """
+
+    transformed = sqlglot.parse_one(query, read="duckdb")
+    transformed.args["list_stage_name"] = f"{catalog}.{schema}.{stage_name}"
+    return transformed
+
+
+def put_stage(
+    expression: exp.Expression,
+    current_database: str | None,
+    current_schema: str | None,
+    params: MutableParams | None,
+) -> exp.Expression:
     """Transform PUT to a SELECT statement to locate the stage.
 
     See https://docs.snowflake.com/en/sql-reference/sql/put
@@ -90,14 +154,20 @@ def put_stage(expression: exp.Expression, current_database: str | None, current_
     target = expression.args["target"]
 
     assert isinstance(target, exp.Var), f"{target} is not a exp.Var"
-    var = target.text("this")
-    if not var.startswith("@"):
-        msg = f"SQL compilation error:\n{var} does not start with @"
+    this = target.text("this")
+    if this == "?":
+        if not (isinstance(params, list) and len(params) == 1):
+            raise NotImplementedError("PUT requires a single parameter for the stage name")
+        this = params.pop(0)
+    if not this.startswith("@"):
+        msg = f"SQL compilation error:\n{this} does not start with @"
         raise snowflake.connector.errors.ProgrammingError(
             msg=msg,
             errno=1003,
             sqlstate="42000",
         )
+    # strip leading @
+    var = this[1:]
     catalog, schema, stage_name = parts_from_var(var, current_database=current_database, current_schema=current_schema)
 
     query = f"""
@@ -107,12 +177,13 @@ def put_stage(expression: exp.Expression, current_database: str | None, current_
     """
 
     transformed = sqlglot.parse_one(query, read="duckdb")
-    transformed.args["put_stage_name"] = f"{catalog}.{schema}.{stage_name}"
+    fqname = f"{catalog}.{schema}.{stage_name}"
+    transformed.args["put_stage_name"] = fqname
     transformed.args["put_stage_data"] = {
         "stageInfo": {
             # use LOCAL_FS otherwise we need to mock S3 with HTTPS which requires a certificate
             "locationType": "LOCAL_FS",
-            "location": f"{LOCAL_BUCKET_PATH}/{stage_name}/",
+            "location": internal_dir(fqname),
             "creds": {},
         },
         "src_locations": [src_path],
@@ -139,7 +210,7 @@ def normalise_ident(name: str) -> str:
 
 
 def parts_from_var(var: str, current_database: str | None, current_schema: str | None) -> tuple[str, str, str]:
-    parts = var[1:].split(".")
+    parts = var.split(".")
     if len(parts) == 3:
         # Fully qualified name
         database_name, schema_name, name = parts
@@ -161,3 +232,62 @@ def parts_from_var(var: str, current_database: str | None, current_schema: str |
     name = normalise_ident(name)
 
     return database_name, schema_name, name
+
+
+def is_internal(s: str) -> bool:
+    return PurePath(s).is_relative_to(LOCAL_BUCKET_PATH)
+
+
+def internal_dir(fqname: str) -> str:
+    """
+    Given a fully qualified stage name, return the directory path where the stage files are stored.
+    """
+    catalog, schema, stage_name = fqname.split(".")
+    return f"{LOCAL_BUCKET_PATH}/{catalog}/{schema}/{stage_name}/"
+
+
+def list_stage_files_sql(stage_name: str) -> str:
+    """
+    Generate SQL to list files in a stage directory, matching Snowflake's LIST output format.
+    """
+    sdir = internal_dir(stage_name)
+    return f"""
+        select
+            lower(split_part(filename, '/', -2)) || '/' || split_part(filename, '/', -1) AS name,
+            size,
+            md5(content) as md5,
+            strftime(last_modified, '%a, %d %b %Y %H:%M:%S GMT') as last_modified
+        from read_blob('{sdir}/*')
+    """
+
+
+def upload_files(put_stage_data: UploadCommandDict) -> list[dict[str, Any]]:
+    results = []
+    for src in put_stage_data["src_locations"]:
+        basename = os.path.basename(src)
+        stage_dir = put_stage_data["stageInfo"]["location"]
+
+        os.makedirs(stage_dir, exist_ok=True)
+        gzip_file_name, target_size = SnowflakeFileUtil.compress_file_with_gzip(src, stage_dir)
+
+        # Rename to match expected .gz extension on upload
+        target_basename = basename + ".gz"
+        target = os.path.join(stage_dir, target_basename)
+        os.replace(gzip_file_name, target)
+
+        target_size = os.path.getsize(target)
+        source_size = os.path.getsize(src)
+
+        results.append(
+            {
+                "source": basename,
+                "target": target_basename,
+                "source_size": source_size,
+                "target_size": target_size,
+                "source_compression": "NONE",
+                "target_compression": "GZIP",
+                "status": "UPLOADED",
+                "message": "",
+            }
+        )
+    return results

fakesnow/transforms/transforms.py

@@ -7,6 +7,7 @@ from typing import ClassVar, cast
 import sqlglot
 from sqlglot import exp
 
+from fakesnow.params import MutableParams, pop_qmark_param
 from fakesnow.variables import Variables
 
 SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
@@ -230,7 +231,7 @@ def describe_table(
         catalog = table.catalog or current_database
         schema = table.db or current_schema
 
-        if schema and schema.upper() == "_FS_INFORMATION_SCHEMA":
+        if schema == "_FS_INFORMATION_SCHEMA":
             # describing an information_schema view
             # (schema already transformed from information_schema -> _fs_information_schema)
             return sqlglot.parse_one(SQL_DESCRIBE_INFO_SCHEMA.substitute(view=f"{schema}.{table.name}"), read="duckdb")
@@ -537,22 +538,47 @@ def float_to_double(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
-def identifier(expression: exp.Expression) -> exp.Expression:
-    """Convert identifier function to an identifier.
+def identifier(expression: exp.Expression, params: MutableParams | None) -> exp.Expression:
+    """Convert identifier function to an identifier or table.
 
     See https://docs.snowflake.com/en/sql-reference/identifier-literal
     """
 
     if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "IDENTIFIER"
+        isinstance(expression, exp.Table)
+        and isinstance(expression.this, exp.Anonymous)
+        and isinstance(expression.this.this, str)
+        and expression.this.this.upper() == "IDENTIFIER"
     ):
-        arg = expression.expressions[0]
+        arg = expression.this.expressions[0]
+
         # ? is parsed as exp.Placeholder
-        if isinstance(arg, exp.Placeholder):
-            return arg
-        return exp.Identifier(this=arg.this, quoted=False)
+        val: str = pop_qmark_param(params, arg.root(), arg) if isinstance(arg, exp.Placeholder) else arg.this
+
+        # If the whole identifier is quoted, treat as a single quoted identifier inside a Table node
+        if val.startswith('"') and val.endswith('"'):
+            return exp.Table(this=exp.Identifier(this=val[1:-1], quoted=True))
+
+        # Split a dotted identifier string into parts, identifying and stripping quoted segments
+        parts = [(p[1:-1], True) if p.startswith('"') and p.endswith('"') else (p, False) for p in val.split(".")]
+        if len(parts) == 1:
+            return exp.Table(this=exp.Identifier(this=parts[0][0], quoted=parts[0][1]))
+        elif len(parts) == 2:
+            # db.table
+            return exp.Table(
+                this=exp.Identifier(this=parts[1][0], quoted=parts[1][1]),
+                db=exp.Identifier(this=parts[0][0], quoted=parts[0][1]),
+            )
+        elif len(parts) == 3:
+            # catalog.db.table
+            return exp.Table(
+                this=exp.Identifier(this=parts[2][0], quoted=parts[2][1]),
+                db=exp.Identifier(this=parts[1][0], quoted=parts[1][1]),
+                catalog=exp.Identifier(this=parts[0][0], quoted=parts[0][1]),
+            )
+        else:
+            # fallback: treat as a single identifier
+            return exp.Table(this=exp.Identifier(this=val, quoted=False))
     return expression
 
 
@@ -600,10 +626,10 @@ def information_schema_fs(expression: exp.Expression) -> exp.Expression:
 
     if (
         isinstance(expression, exp.Table)
-        and expression.db.upper() == "INFORMATION_SCHEMA"
-        and expression.name.upper() in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
+        and expression.db == "INFORMATION_SCHEMA"
+        and expression.name in {"COLUMNS", "TABLES", "VIEWS", "LOAD_HISTORY"}
     ):
-        expression.set("this", exp.Identifier(this=f"_FS_{expression.name.upper()}", quoted=False))
+        expression.set("this", exp.Identifier(this=f"_FS_{expression.name}", quoted=False))
         expression.set("db", exp.Identifier(this="_FS_INFORMATION_SCHEMA", quoted=False))
 
     return expression
@@ -615,11 +641,8 @@ def information_schema_databases(
 ) -> exp.Expression:
     if (
         isinstance(expression, exp.Table)
-        and (
-            expression.db.upper() == "INFORMATION_SCHEMA"
-            or (current_schema and current_schema.upper() == "INFORMATION_SCHEMA")
-        )
-        and expression.name.upper() == "DATABASES"
+        and (expression.db == "INFORMATION_SCHEMA" or (current_schema and current_schema == "INFORMATION_SCHEMA"))
+        and expression.name == "DATABASES"
     ):
         return exp.Table(
             this=exp.Identifier(this="DATABASES", quoted=False),
@@ -978,11 +1001,7 @@ def to_date(expression: exp.Expression) -> exp.Expression:
         exp.Expression: The transformed expression.
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "TO_DATE"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TO_DATE":
         return exp.Cast(
             this=expression.expressions[0],
             to=exp.DataType(this=exp.DataType.Type.DATE, nested=False, prefix=False),
@@ -1066,11 +1085,7 @@ def to_decimal(expression: exp.Expression) -> exp.Expression:
             to=exp.DataType(this=exp.DataType.Type.DECIMAL, expressions=[precision, scale], nested=False, prefix=False),
         )
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() in ["TO_DECIMAL", "TO_NUMERIC"]
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() in ["TO_DECIMAL", "TO_NUMERIC"]:
         return _to_decimal(expression, exp.Cast)
 
     return expression
@@ -1081,11 +1096,11 @@ def try_to_decimal(expression: exp.Expression) -> exp.Expression:
     See https://docs.snowflake.com/en/sql-reference/functions/try_to_decimal
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() in ["TRY_TO_DECIMAL", "TRY_TO_NUMBER", "TRY_TO_NUMERIC"]
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() in [
+        "TRY_TO_DECIMAL",
+        "TRY_TO_NUMBER",
+        "TRY_TO_NUMERIC",
+    ]:
         return _to_decimal(expression, exp.TryCast)
 
     return expression
@@ -1111,9 +1126,7 @@ def to_timestamp_ntz(expression: exp.Expression) -> exp.Expression:
     Because it's not yet supported by sqlglot, see https://github.com/tobymao/sqlglot/issues/2748
     """
 
-    if isinstance(expression, exp.Anonymous) and (
-        isinstance(expression.this, str) and expression.this.upper() == "TO_TIMESTAMP_NTZ"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TO_TIMESTAMP_NTZ":
         return exp.StrToTime(
             this=expression.expressions[0],
             format=exp.Literal(this="%Y-%m-%d %H:%M:%S", is_string=True),
@@ -1164,11 +1177,7 @@ def try_parse_json(expression: exp.Expression) -> exp.Expression:
         exp.Expression: The transformed expression.
     """
 
-    if (
-        isinstance(expression, exp.Anonymous)
-        and isinstance(expression.this, str)
-        and expression.this.upper() == "TRY_PARSE_JSON"
-    ):
+    if isinstance(expression, exp.Anonymous) and expression.name.upper() == "TRY_PARSE_JSON":
         expressions = expression.expressions
         return exp.TryCast(
             this=expressions[0],

{fakesnow-0.9.41.dist-info → fakesnow-0.9.42.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.41
+Version: 0.9.42
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004

{fakesnow-0.9.41.dist-info → fakesnow-0.9.42.dist-info}/RECORD

@@ -5,8 +5,8 @@ fakesnow/checks.py,sha256=bOJPMp46AvjJV_bXXjx2njO2dXNjffLrznwRuKyYZ4g,2889
 fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
 fakesnow/conn.py,sha256=diCwcjaCBrlCn9PyjbScfIQTNQjqiPTkQanUTqcvblE,6009
 fakesnow/converter.py,sha256=wPOfsFXIUJNJSx5oFNAxh13udxmAVIIHsLK8BiGkXGA,1635
-fakesnow/copy_into.py,sha256=YIr5Bq3JwKOPYWm5t2QXUuFGxLL-1ioEXEumNjGbBvM,13648
-fakesnow/cursor.py,sha256=mOwyXnBFXp79nDh0vtbmxS_hmFNy4j7hPlskENWeIrI,23818
+fakesnow/copy_into.py,sha256=utlV03RWHdWblIlKs92Q__9BWHi_gvqT76RV6tEMWTo,16006
+fakesnow/cursor.py,sha256=T0aI_AC8U7_mRMccGUIOs8WFby4-8O3ETHpcxJLtM38,25432
 fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
 fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
 fakesnow/fixtures.py,sha256=2rj0MTZlaZc4PNWhaqC5IiiLa7E9G0QZT3g45YawsL0,633
@@ -15,19 +15,20 @@ fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/logger.py,sha256=U6EjUENQuTrDeNYqER2hxazoySmXzLmZJ-t-SDZgjkg,363
 fakesnow/macros.py,sha256=lxtznTCYryjecFkwswbqWMzCVamDLWyQZRKWtkWCWEk,1397
 fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
+fakesnow/params.py,sha256=Hp7tBiDycdOh8LuRoISsOZycD7DufDAMKyF_hqEjh6M,929
 fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
 fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
-fakesnow/server.py,sha256=PGNuYEpmI0L0ZrwBCP1pDTc_lnFrtfSnlZ6zyVuCTqk,7173
+fakesnow/server.py,sha256=anlieEI2WO81rDv7h5-M10CetYL_HJFXWZO9wScr0Dw,7196
 fakesnow/variables.py,sha256=BGnD4LAdVByfJ2GXL6qpGBaTF8ZJRjt3pdJsd9sIAcw,3134
-fakesnow/transforms/__init__.py,sha256=OE-dunCuum8lv832s2cjEzThgBnpKELo5aaTXD_bMNg,2807
+fakesnow/transforms/__init__.py,sha256=3dpcXjeLkfc4e9rO0G8Mnv9zZgmwsKSwQ7UJeyLYnOg,2837
 fakesnow/transforms/merge.py,sha256=H2yYyzGsxjpggS6PY91rAUtYCFuOkBm8uGi0EO0r6T0,8375
-fakesnow/transforms/show.py,sha256=ejvs9S2l2Wcal4fhnNSVs3JkZwKsFxMEU35ufUV3-kg,20421
-fakesnow/transforms/stage.py,sha256=FSIyI5kpthD_pdbVfzYCrby5HaikMZUpdRr6oBSrgk4,6176
-fakesnow/transforms/transforms.py,sha256=t99pHmNm8aG89o738zVSXCG6a0dOXpnY1OqAz28EQHc,48072
-fakesnow-0.9.41.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow/transforms/show.py,sha256=NIJDkf4-ns4VTw0DQphEn2DnwxQjXyTU2wS9VSUh6Wc,19919
+fakesnow/transforms/stage.py,sha256=yBC0jMmUYhmHY5Of08lPxgH9R6arNUWAjL9M4ArDnjY,10344
+fakesnow/transforms/transforms.py,sha256=ykzay7J28MsifhRKhm5qJJd__hMcLNVZTT14MSdWcJs,49102
+fakesnow-0.9.42.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.41.dist-info/METADATA,sha256=cOvEP3Mo_H0yn37XeRPozuvwY6OS7tqDnleGP8Vgplg,20680
-fakesnow-0.9.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fakesnow-0.9.41.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.41.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.41.dist-info/RECORD,,
+fakesnow-0.9.42.dist-info/METADATA,sha256=tYGXY_3aBbYYkLyFlajE1ebKbXT4xhyain0JLC9vfb0,20680
+fakesnow-0.9.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fakesnow-0.9.42.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.42.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.42.dist-info/RECORD,,