fakesnow 0.9.35__py3-none-any.whl → 0.9.36__py3-none-any.whl

fakesnow/__init__.py

@@ -91,3 +91,54 @@ def patch(
     finally:
         stack.close()
         fs.duck_conn.close()
+
+
+@contextmanager
+def server(port: int | None = None, session_parameters: dict[str, str | int | bool] | None = None) -> Iterator[dict]:
+    """Start a fake snowflake server in a separate thread and yield connection kwargs.
+
+    Args:
+        port (int | None, optional): Port to run the server on. If None, an available port is chosen. Defaults to None.
+
+    Yields:
+        Iterator[dict]: Connection parameters for the fake snowflake server.
+    """
+    import socket
+    import threading
+    from time import sleep
+
+    import uvicorn
+
+    import fakesnow.server
+
+    # find an unused TCP port between 1024-65535
+    if not port:
+        with contextlib.closing(socket.socket(type=socket.SOCK_STREAM)) as sock:
+            sock.bind(("127.0.0.1", 0))
+            port = sock.getsockname()[1]
+
+    assert port
+    server = uvicorn.Server(uvicorn.Config(fakesnow.server.app, port=port, log_level="info"))
+    thread = threading.Thread(target=server.run, name="Server", daemon=True)
+    thread.start()
+
+    while not server.started:
+        sleep(0.1)
+
+    try:
+        yield dict(
+            user="fake",
+            password="snow",
+            account="fakesnow",
+            host="localhost",
+            port=port,
+            protocol="http",
+            # disable telemetry
+            session_parameters={"CLIENT_OUT_OF_BAND_TELEMETRY_ENABLED": False} | (session_parameters or {}),
+            # disable retries on error
+            network_timeout=1,
+        )
+    finally:
+        server.should_exit = True
+        # wait for server thread to end
+        thread.join()

fakesnow/conn.py

@@ -6,8 +6,7 @@ from pathlib import Path
 from types import TracebackType
 from typing import Any
 
-import snowflake.connector.converter
-import snowflake.connector.errors
+import snowflake.connector
 import sqlglot
 from duckdb import DuckDBPyConnection
 from snowflake.connector.cursor import DictCursor, SnowflakeCursor

fakesnow/cursor.py

@@ -46,6 +46,12 @@ SQL_DROPPED = Template("SELECT '${name} successfully dropped.' as 'status'")
 SQL_INSERTED_ROWS = Template("SELECT ${count} as 'number of rows inserted'")
 SQL_UPDATED_ROWS = Template("SELECT ${count} as 'number of rows updated', 0 as 'number of multi-joined rows updated'")
 SQL_DELETED_ROWS = Template("SELECT ${count} as 'number of rows deleted'")
+SQL_COPY_ROWS = Template(
+    "SELECT '${file}' as file, 'LOADED' as status, ${count} as rows_parsed, "
+    "${count} as rows_loaded, 1 as error_limit, 0 as errors_seen, "
+    "NULL as first_error, NULL as first_error_line, NULL as first_error_character, "
+    "NULL as first_error_column_name"
+)
 
 
 class FakeSnowflakeCursor:
@@ -249,6 +255,7 @@ class FakeSnowflakeCursor:
             .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="FOREIGN"))
             .transform(transforms.show_users)
             .transform(transforms.create_user)
+            .transform(transforms.copy_into)
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
@@ -300,6 +307,10 @@ class FakeSnowflakeCursor:
             raise snowflake.connector.errors.DatabaseError(msg=e.args[0], errno=250002, sqlstate="08003") from None
         except duckdb.ParserException as e:
             raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=1003, sqlstate="42000") from None
+        except duckdb.HTTPException as e:
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=91016, sqlstate="22000") from None
+        except duckdb.ConversionException as e:
+            raise snowflake.connector.errors.ProgrammingError(msg=e.args[0], errno=100038, sqlstate="22018") from None
 
         affected_count = None
 
@@ -319,6 +330,10 @@ class FakeSnowflakeCursor:
             self._duck_conn.execute(info_schema.per_db_creation_sql(create_db_name))
             result_sql = SQL_CREATED_DATABASE.substitute(name=create_db_name)
 
+        elif copy_from := transformed.args.get("copy_from"):
+            (affected_count,) = self._duck_conn.fetchall()[0]
+            result_sql = SQL_COPY_ROWS.substitute(count=affected_count, file=copy_from)
+
         elif cmd == "INSERT":
             (affected_count,) = self._duck_conn.fetchall()[0]
             result_sql = SQL_INSERTED_ROWS.substitute(count=affected_count)

fakesnow/fixtures.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterator
+from typing import Any
 
 import pytest
 
@@ -11,6 +12,12 @@ def _fakesnow() -> Iterator[None]:
         yield
 
 
+@pytest.fixture(scope="session")
+def fakesnow_server() -> Iterator[dict[str, Any]]:
+    with fakesnow.server() as conn_kwargs:
+        yield conn_kwargs
+
+
 @pytest.fixture
 def _fakesnow_no_auto_create() -> Iterator[None]:
     with fakesnow.patch(create_database_on_connect=False, create_schema_on_connect=False):

fakesnow/server.py

@@ -59,7 +59,10 @@ async def login_request(request: Request) -> JSONResponse:
         {
             "data": {
                 "token": token,
-                "parameters": [{"name": "AUTOCOMMIT", "value": True}],
+                "parameters": [
+                    {"name": "AUTOCOMMIT", "value": True},
+                    {"name": "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "value": 3600},
+                ],
             },
             "success": True,
         }

fakesnow/transforms/__init__.py

@@ -7,6 +7,7 @@ from typing import ClassVar, cast
 import sqlglot
 from sqlglot import exp
 
+from fakesnow.transforms.copy_into import copy_into as copy_into
 from fakesnow.transforms.merge import merge as merge
 from fakesnow.transforms.show import (
     show_columns as show_columns,

fakesnow/transforms/copy_into.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from pathlib import PurePath
+from typing import Protocol
+from urllib.parse import urlparse, urlunparse
+
+import snowflake.connector.errors
+from sqlglot import exp
+from typing_extensions import Self
+
+
+def copy_into(expr: exp.Expression) -> exp.Expression:
+    if not isinstance(expr, exp.Copy):
+        return expr
+
+    schema = expr.this
+
+    columns = [exp.Column(this=exp.Identifier(this=f"column{i}")) for i in range(len(schema.expressions))] or [
+        exp.Column(this=exp.Star())
+    ]
+
+    params = expr.args.get("params", [])
+    # TODO: remove columns
+    file_type_handler = _handle_params(params, [c.name for c in columns])
+
+    # the FROM expression
+    source = expr.args["files"][0].this
+    assert isinstance(source, exp.Literal), f"{source.__class__} is not a exp.Literal"
+
+    if len(file_type_handler.files) > 1:
+        raise NotImplementedError("Multiple files not currently supported")
+    file = file_type_handler.files[0]
+
+    scheme, netloc, path, params, query, fragment = urlparse(source.name)
+    if not scheme:
+        raise snowflake.connector.errors.ProgrammingError(
+            msg=f"SQL compilation error:\ninvalid URL prefix found in: '{source.name}'", errno=1011, sqlstate="42601"
+        )
+    path = str(PurePath(path) / file.name)
+    url = urlunparse((scheme, netloc, path, params, query, fragment))
+
+    return exp.Insert(
+        this=schema,
+        expression=exp.Select(expressions=columns).from_(exp.Table(this=file_type_handler.read_expression(url))),
+        copy_from=url,
+    )
+
+
+def _handle_params(params: list[exp.CopyParameter], columns: list[str]) -> FileTypeHandler:
+    file_type_handler = None
+    force = False
+    files = []
+    for param in params:
+        var = param.this.name
+        if var == "FILE_FORMAT":
+            if file_type_handler:
+                raise ValueError(params)
+
+            var_type = next((e.args["value"].this for e in param.expressions if e.this.this == "TYPE"), None)
+            if not var_type:
+                raise NotImplementedError("FILE_FORMAT without TYPE is not currently implemented")
+
+            if var_type == "CSV":
+                file_type_handler = handle_csv(param.expressions, columns)
+            else:
+                raise NotImplementedError(f"{var_type} FILE_FORMAT is not currently implemented")
+
+        elif var == "FILES":
+            files = param.expression.expressions if isinstance(param.expression, exp.Tuple) else [param.expression.this]
+        elif var == "FORCE":
+            force = True
+            pass
+        else:
+            raise ValueError(f"Unknown copy parameter: {param.this}")
+
+    if not force:
+        raise NotImplementedError("COPY INTO with FORCE=false (default) is not currently implemented")
+
+    if not files:
+        raise NotImplementedError("COPY INTO without FILES is not currently implemented")
+
+    if not file_type_handler:
+        # default to CSV
+        file_type_handler = handle_csv([], columns)
+
+    file_type_handler = file_type_handler.with_files(files)
+    return file_type_handler
+
+
+def handle_csv(expressions: list[exp.Property], columns: list[str]) -> ReadCSV:
+    skip_header = ReadCSV.skip_header
+    quote = ReadCSV.quote
+    delimiter = ReadCSV.delimiter
+
+    for expression in expressions:
+        exp_type = expression.name
+        if exp_type in {"TYPE"}:
+            continue
+
+        elif exp_type == "SKIP_HEADER":
+            skip_header = True
+        elif exp_type == "FIELD_OPTIONALLY_ENCLOSED_BY":
+            quote = expression.args["value"].this
+        elif exp_type == "FIELD_DELIMITER":
+            delimiter = expression.args["value"].this
+        else:
+            raise NotImplementedError(f"{exp_type} is not currently implemented")
+
+    return ReadCSV(
+        skip_header=skip_header,
+        quote=quote,
+        delimiter=delimiter,
+        columns=columns,
+    )
+
+
+@dataclass
+class FileTypeHandler(Protocol):
+    files: list = field(default_factory=list)
+
+    def read_expression(self, url: str) -> exp.Expression: ...
+
+    def with_files(self, files: list) -> Self:
+        return replace(self, files=files)
+
+    @staticmethod
+    def make_eq(name: str, value: list | str | int | bool) -> exp.EQ:
+        if isinstance(value, list):
+            expression = exp.array(*[exp.Literal(this=str(v), is_string=isinstance(v, str)) for v in value])
+        elif isinstance(value, bool):
+            expression = exp.Boolean(this=value)
+        else:
+            expression = exp.Literal(this=str(value), is_string=isinstance(value, str))
+
+        return exp.EQ(this=exp.Literal(this=name, is_string=False), expression=expression)
+
+
+@dataclass
+class ReadCSV(FileTypeHandler):
+    skip_header: bool = False
+    quote: str | None = None
+    delimiter: str = ","
+    columns: list[str] = field(default_factory=list)
+
+    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))
+
+        if self.skip_header:
+            args.append(self.make_eq("skip", 1))
+
+        if self.quote:
+            quote = self.quote.replace("'", "''")
+            args.append(self.make_eq("quote", quote))
+
+        if self.delimiter and self.delimiter != ",":
+            delimiter = self.delimiter.replace("'", "''")
+            args.append(self.make_eq("sep", delimiter))
+
+        return exp.func("read_csv", exp.Literal(this=url, is_string=True), *args)

{fakesnow-0.9.35.dist-info → fakesnow-0.9.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fakesnow
-Version: 0.9.35
+Version: 0.9.36
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -215,6 +215,7 @@ Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
 Requires-Dist: sqlglot~=26.12.1
 Provides-Extra: dev
+Requires-Dist: boto3-stubs[s3,sts]; extra == "dev"
 Requires-Dist: build~=1.0; extra == "dev"
 Requires-Dist: dirty-equals; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
@@ -222,10 +223,11 @@ Requires-Dist: snowflake-connector-python[pandas,secure-local-storage]; extra ==
 Requires-Dist: pre-commit~=4.0; extra == "dev"
 Requires-Dist: pyarrow-stubs==17.19; extra == "dev"
 Requires-Dist: pytest~=8.0; extra == "dev"
-Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: ruff~=0.11.0; extra == "dev"
 Requires-Dist: twine~=6.0; extra == "dev"
 Requires-Dist: snowflake-sqlalchemy~=1.7.0; extra == "dev"
+Requires-Dist: boto3; extra == "dev"
+Requires-Dist: moto[server]>=5; extra == "dev"
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine; extra == "notebook"
 Requires-Dist: ipykernel; extra == "notebook"
@@ -242,7 +244,7 @@ Dynamic: license-file
 [![PyPI](https://img.shields.io/pypi/v/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/fakesnow?color=violet)](https://pypi.org/project/fakesnow/)
 
-Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector). Run and mock Snowflake DB locally.
+Run, mock and test fake Snowflake databases locally.
 
 ## Install
 
@@ -250,9 +252,21 @@ Fake [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/p
 pip install fakesnow
 ```
 
+Or to install with the server:
+
+```
+pip install fakesnow[server]
+```
+
 ## Usage
 
-Run script.py with fakesnow:
+fakesnow offers two main approaches for faking Snowflake: in-process patching of the [Snowflake Connector for Python](https://docs.snowflake.com/en/user-guide/python-connector) or a standalone HTTP server.
+
+Patching only applies to the current Python process. If a subprocess is spawned it won't be patched. For subprocesses, or for non-Python clients, use the server instead.
+
+### In-process patching
+
+To run script.py with patching:
 
 ```shell
 fakesnow script.py
@@ -266,9 +280,9 @@ fakesnow -m pytest
 
 `fakesnow` executes `fakesnow.patch` before running the script or module.
 
-### fakesnow.patch
+#### Use fakesnow.patch in your code
 
-To use fakesnow within your code:
+Alternatively, use fakesnow.patch in your code:
 
 ```python
 import fakesnow
@@ -280,12 +294,16 @@ with fakesnow.patch():
     print(conn.cursor().execute("SELECT 'Hello fake world!'").fetchone())
 ```
 
-The following imports are automatically patched:
+#### What gets patched
+
+The following standard imports are automatically patched:
 
 - `import snowflake.connector.connect`
 - `import snowflake.connector.pandas_tools.write_pandas`
 
-To patch modules that use the `from ... import` syntax, manually specify them, eg: if _mymodule.py_ has the import:
+#### Handling "from ... import" Statements
+
+To patch modules that use the `from ... import` syntax, you need to manually specify them, eg: if _mymodule.py_ contains:
 
 ```python
 from snowflake.connector.pandas_tools import write_pandas
@@ -298,33 +316,77 @@ with fakesnow.patch("mymodule.write_pandas"):
     ...
 ```
 
-By default databases are in-memory. To persist databases between processes, specify a databases path:
+#### Database Persistence
+
+By default, databases are in-memory and will be lost when the process ends. To persist databases between processes, specify a databases path:
 
 ```python
 with fakesnow.patch(db_path="databases/"):
     ...
 ```
 
+### Run fakesnow as a server
+
+For scenarios where patching won't work (like subprocesses or non-Python clients), you can run fakesnow as an HTTP server:
+
+```python
+import fakesnow
+import snowflake.connector
+
+# Start the fakesnow server in a context manager
+# This yields connection kwargs (host, port, etc.)
+with fakesnow.server() as conn_kwargs:
+    # Connect to the fakesnow server using the yielded kwargs
+    with snowflake.connector.connect(**conn_kwargs) as conn:
+        print(conn.cursor().execute("SELECT 'Hello fake server!'").fetchone())
+
+    # The server is automatically stopped when exiting the context manager
+```
+
+This starts an HTTP server in its own thread listening for requests on localhost on an available random port.
+The server accepts any username/password combination.
+
+#### Server Configuration Options
+
+By default, the server uses a single in-memory database for its lifetime. To configure database persistence or isolation:
+
+```python
+# Databases will be saved to the "databases/" directory
+with fakesnow.server(session_parameters={"FAKESNOW_DB_PATH": "databases/"}):
+    ...
+
+# Each connection gets its own isolated in-memory database
+with fakesnow.server(session_parameters={"FAKESNOW_DB_PATH": ":isolated:"}):
+    ...
+```
+
+To specify a port for the server:
+
+```python
+with fakesnow.server(port=12345) as conn_kwargs:
+    ...
+```
+
 ### pytest fixtures
 
-pytest [fixtures](fakesnow/fixtures.py) are provided for testing. Example _conftest.py_:
+fakesnow provides [fixtures](fakesnow/fixtures.py) for easier test integration. Here's an example _conftest.py_ using them:
 
 ```python
 from typing import Iterator
 
-import fakesnow.fixtures
 import pytest
 
-pytest_plugins = fakesnow.fixtures.__name__
+pytest_plugins = "fakesnow.fixtures"
 
 @pytest.fixture(scope="session", autouse=True)
 def setup(_fakesnow_session: None) -> Iterator[None]:
     # the standard imports are now patched
-    ...
+    # Add any additional setup here
     yield
+    # Add any teardown here
 ```
 
-Or with `from ... import` patch targets:
+For code that uses `from ... import` statements:
 
 ```python
 from typing import Iterator
@@ -338,34 +400,56 @@ def _fakesnow_session() -> Iterator[None]:
         yield
 ```
 
+To start a fakesnow server instance, use the `fakesnow_server` session fixture:
+
+```python
+import snowflake.connector
+
+def test_with_server(fakesnow_server: dict):
+    # fakesnow_server contains connection kwargs (host, port, etc.)
+    with snowflake.connector.connect(**fakesnow_server) as conn:
+        conn.cursor().execute("SELECT 1")
+        assert conn.cursor().fetchone() == (1,)
+```
+
 ## Implementation coverage
 
-- [x] cursors and standard SQL
-- [x] [get_result_batches()](https://docs.snowflake.com/en/user-guide/python-connector-api#get_result_batches)
-- [x] information schema
-- [x] multiple databases
-- [x] [parameter binding](https://docs.snowflake.com/en/user-guide/python-connector-example#binding-data)
-- [x] table comments
-- [x] [write_pandas(..)](https://docs.snowflake.com/en/user-guide/python-connector-api#write_pandas)
-- [ ] [access control](https://docs.snowflake.com/en/user-guide/security-access-control-overview)
-- [ ] standalone/out of process api/support for faking non-python connectors
-- [ ] [stored procedures](https://docs.snowflake.com/en/sql-reference/stored-procedures)
+Fully supported:
 
-Partial support
+- Standard SQL operations and cursors
+- Information schema queries
+- Multiple databases
+- [Parameter binding](https://docs.snowflake.com/en/user-guide/python-connector-example#binding-data) in queries
+- Table comments
+- Pandas integration including [write_pandas(..)](https://docs.snowflake.com/en/user-guide/python-connector-api#write_pandas) (not available via the server yet)
+- Result batch retrieval via [get_result_batches()](https://docs.snowflake.com/en/user-guide/python-connector-api#get_result_batches)
+- HTTP server for non-Python connectors
 
-- [x] date functions
-- [x] regex functions
-- [x] semi-structured data
-- [x] tags
-- [x] user management (See [tests/test_users.py](tests/test_users.py))
+Partially supported:
 
-For more detail see [tests/test_fakes.py](tests/test_fakes.py)
+- Date functions
+- Regular expression functions
+- Semi-structured data operations
+- Tags
+- User management
+- `COPY INTO` from S3 sources, see [COPY INTO](#copy-into)
+
+Not yet implemented:
+
+- [Access control](https://docs.snowflake.com/en/user-guide/security-access-control-overview)
+- [Stored procedures](https://docs.snowflake.com/en/sql-reference/stored-procedures)
+
+For more detail see the [test suite](tests/).
 
 ## Caveats
 
-- The order of rows is non deterministic and may not match Snowflake unless ORDER BY is fully specified.
-- A more liberal Snowflake SQL dialect than used by a real Snowflake instance is supported, ie: some queries might pass using fakesnow that a real Snowflake instance would reject.
+- Row ordering is non-deterministic and may differ from Snowflake unless you fully specify the ORDER BY clause.
+- fakesnow supports a more liberal SQL dialect than actual Snowflake. This means some queries that work with fakesnow might not work with a real Snowflake instance.
+
+## COPY INTO
+
+`COPY INTO` can be used from S3 sources. By default the standard AWS credential chain will be used. If you are getting an HTTP 403 or need to provide alternative S3 credentials you can use the duckdb [CREATE SECRET](https://duckdb.org/docs/stable/extensions/httpfs/s3api) statement. For an example of creating a secret to use a moto S3 endpoint see `s3_client` in [conftest.py](tests/conftest.py#L80)
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) to get started and develop in this repo.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for instructions on getting started with development and contributing to this project.

{fakesnow-0.9.35.dist-info → fakesnow-0.9.36.dist-info}/RECORD

@@ -1,29 +1,30 @@
-fakesnow/__init__.py,sha256=qUfgucQYPdELrJaxczalhJgWAWQ6cfTCUAHx6nUqRaI,3528
+fakesnow/__init__.py,sha256=It-8mTZWBaVi4suZjL7UJlJBGFhLWmPnI-THX02XRJU,5108
 fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
 fakesnow/arrow.py,sha256=XjTpFyLrD9jULWOtPgpr0RyNMmO6a5yi82y6ivi2CCI,4884
 fakesnow/checks.py,sha256=be-xo0oMoAUVhlMDCu1_Rkoh_L8p_p8qo9P6reJSHIQ,2874
 fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/conn.py,sha256=2WClMmUgfQkQA2hFQjfMP3R-85TbTbZh_8Y1tCdcerA,6053
+fakesnow/conn.py,sha256=diCwcjaCBrlCn9PyjbScfIQTNQjqiPTkQanUTqcvblE,6009
 fakesnow/converter.py,sha256=xoBFnfBbGWQyUQAVr6zi-RyglU8A7A3GSlwLPkH1dzI,1621
-fakesnow/cursor.py,sha256=e-nY-w25xmLs1jdhIbO6mwzBHVIUKYIkzR37Wnf3Cfc,22068
+fakesnow/cursor.py,sha256=3JCxSoBJ2g6bndIGQnJnTAWu8Ad7zK_6kwmAY_b0VKE,22949
 fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
 fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
-fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
+fakesnow/fixtures.py,sha256=2rj0MTZlaZc4PNWhaqC5IiiLa7E9G0QZT3g45YawsL0,633
 fakesnow/info_schema.py,sha256=AYmTIHxk5Y6xdMTgttgBL1V0VO8qiM2T1-gKwkLmWDs,8720
 fakesnow/instance.py,sha256=OKoYXwaI6kL9HQpnHx44yzpON_xNfuIT_F4oJNF_XXQ,2114
 fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
 fakesnow/pandas_tools.py,sha256=wI203UQHC8JvDzxE_VjE1NeV4rThek2P-u52oTg2foo,3481
 fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
 fakesnow/rowtype.py,sha256=QUp8EaXD5LT0Xv8BXk5ze4WseEn52xoJ6R05pJjs5mM,2729
-fakesnow/server.py,sha256=6EMdNMxL0DgfMNXfFBqRFYmRThbuEVFFpa_1sCW-rZ4,6519
+fakesnow/server.py,sha256=RHf7ffKYi5xBH9fh8wZr3tEPmnzFWuvUbziCC8UwTh4,6652
 fakesnow/variables.py,sha256=C3y_9u7LuVtARkpcim3ihgVWg6KKdz1hSVeW4YI7oL4,3014
-fakesnow/transforms/__init__.py,sha256=eJ_XH9pKO4Mxb7MKVgJuo6Wea-LYahF1dc_py5lPHAY,49471
+fakesnow/transforms/__init__.py,sha256=RcVGkp95yKByluQ5O6RALJTiRlox8FK4pMl1rt_gJPc,49536
+fakesnow/transforms/copy_into.py,sha256=QJ1hh3hVi9kPJgyQHlGO3Vi8sP3qnWmvY4JWO--HWl0,5565
 fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
 fakesnow/transforms/show.py,sha256=0NjuLQjodrukfUw8mcxcAmtBkV_6r02mA3nuE3ad3rE,17458
-fakesnow-0.9.35.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.36.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.35.dist-info/METADATA,sha256=D2aDpQUAIuSHEf6W5f1m84IG3BBDEvvMN5fU_FiWl3c,18128
-fakesnow-0.9.35.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fakesnow-0.9.35.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.35.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.35.dist-info/RECORD,,
+fakesnow-0.9.36.dist-info/METADATA,sha256=Nu1iV0SOnWCNeQCVJXbwC2PVxx7mkdQ6YDfDVkfTmI4,21160
+fakesnow-0.9.36.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+fakesnow-0.9.36.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.36.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
+fakesnow-0.9.36.dist-info/RECORD,,

{fakesnow-0.9.35.dist-info → fakesnow-0.9.36.dist-info}/WHEEL

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