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

fakesnow/converter.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import binascii
+import datetime
+from datetime import date, time, timezone
+
+# convert server bindings from strings into python types
+
+
+def from_binding(binding: dict[str, str]) -> int | bytes | bool | date | time | datetime.datetime | str:
+    typ = binding["type"]
+    value = binding["value"]
+    if typ == "FIXED":
+        return int(value)
+    elif typ == "BINARY":
+        return from_binary(value)
+    # TODO: not strictly needed
+    elif typ == "BOOLEAN":
+        return value.lower() == "true"
+    elif typ == "DATE":
+        return from_date(value)
+    elif typ == "TIME":
+        return from_time(value)
+    elif typ == "TIMESTAMP_NTZ":
+        return from_datetime(value)
+    else:
+        # For other types, return str
+        return value
+
+
+def from_binary(s: str) -> bytes:
+    return binascii.unhexlify(s)
+
+
+def from_boolean(s: str) -> bool:
+    return s.lower() == "true"
+
+
+def from_date(s: str) -> date:
+    milliseconds = int(s)
+    seconds = milliseconds / 1000
+    return datetime.datetime.fromtimestamp(seconds, timezone.utc).date()
+
+
+def from_time(s: str) -> time:
+    nanoseconds = int(s)
+    microseconds = nanoseconds / 1000
+    return (
+        datetime.datetime.fromtimestamp(microseconds / 1_000_000, timezone.utc)
+        .replace(microsecond=int(microseconds % 1_000_000))
+        .time()
+    )
+
+
+def from_datetime(s: str) -> datetime.datetime:
+    nanoseconds = int(s)
+    microseconds = nanoseconds / 1000
+    return datetime.datetime.fromtimestamp(microseconds / 1_000_000, timezone.utc).replace(
+        microsecond=int(microseconds % 1_000_000)
+    )

fakesnow/cursor.py

@@ -139,7 +139,12 @@ class FakeSnowflakeCursor:
                 print(f"{command};{params=}" if params else f"{command};", file=sys.stderr)
 
             command = self._inline_variables(command)
-            command, params = self._rewrite_with_params(command, params)
+            if kwargs.get("binding_params"):
+                # params have come via the server
+                params = kwargs["binding_params"]
+            else:
+                command, params = self._rewrite_with_params(command, 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)
@@ -161,6 +166,9 @@ class FakeSnowflakeCursor:
             # strip highlight for better readability, TODO: show pointer to start of error
             msg = str(e).replace("\x1b[4m", "").replace("\x1b[0m", "")
             raise snowflake.connector.errors.ProgrammingError(msg=msg, errno=1003, sqlstate="42000") from None
+        except NotImplementedError as e:
+            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 check_db_and_schema(self, expression: exp.Expression) -> None:
         no_database, no_schema = checks.is_unqualified_table_expression(expression)
@@ -233,7 +241,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.show_procedures)
             .transform(transforms.show_warehouses)
             .transform(lambda e: transforms.show_schemas(e, self._conn.database))
-            .transform(lambda e: transforms.show_objects_tables(e, self._conn.database))
+            .transform(lambda e: transforms.show_tables_etc(e, self._conn.database))
             .transform(lambda e: transforms.show_columns(e, self._conn.database))
             # TODO collapse into a single show_keys function
             .transform(lambda e: transforms.show_keys(e, self._conn.database, kind="PRIMARY"))
@@ -384,7 +392,7 @@ class FakeSnowflakeCursor:
         self._sfqid = str(uuid.uuid4())
 
         self._last_sql = result_sql or sql
-        self._last_params = params
+        self._last_params = None if result_sql else params
 
     def _log_sql(self, sql: str, params: Sequence[Any] | dict[Any, Any] | None = None) -> None:
         if (fs_debug := os.environ.get("FAKESNOW_DEBUG")) and fs_debug != "snowflake":
@@ -398,7 +406,7 @@ class FakeSnowflakeCursor:
     ) -> FakeSnowflakeCursor:
         if isinstance(seqparams, dict):
             # see https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api
-            raise NotImplementedError("dict params not supported yet")
+            raise NotImplementedError("executemany dict params")
 
         # TODO: support insert optimisations
         # the snowflake connector will optimise inserts into a single query

fakesnow/info_schema.py

@@ -34,8 +34,8 @@ create table if not exists _fs_global._fs_information_schema._fs_columns_ext (
 """
 
 # replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
-SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT = """
-create table if not exists _fs_global._fs_information_schema._fs_users_ext (
+SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE = """
+create table if not exists _fs_global._fs_information_schema._fs_users (
     name varchar,
     created_on TIMESTAMPTZ,
     login_name varchar,
@@ -196,13 +196,13 @@ def per_db_creation_sql(catalog: str) -> str:
     """
 
 
-def fs_global_creation_sql(catalog: str) -> str:
+def fs_global_creation_sql() -> str:
     return f"""
         {SQL_CREATE_GLOBAL_FS_INFORMATION_SCHEMA};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_TABLES_EXT};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_EXT};
         {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_COLUMNS_VIEW};
-        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE_EXT};
+        {SQL_CREATE_GLOBAL_INFORMATION_SCHEMA_USERS_TABLE};
     """
 
 

fakesnow/instance.py

@@ -7,6 +7,7 @@ import duckdb
 
 import fakesnow.fakes as fakes
 from fakesnow import info_schema
+from fakesnow.transforms import show
 
 GLOBAL_DATABASE_NAME = "_fs_global"
 
@@ -28,8 +29,9 @@ class FakeSnow:
 
         # create a "global" database for storing objects which span databases.
         self.duck_conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-        # create the info schema extensions
-        self.duck_conn.execute(info_schema.fs_global_creation_sql(GLOBAL_DATABASE_NAME))
+        # create the info schema extensions and show views
+        self.duck_conn.execute(info_schema.fs_global_creation_sql())
+        self.duck_conn.execute(show.fs_global_creation_sql())
 
         # use UTC instead of local time zone for consistent testing
         self.duck_conn.execute("SET GLOBAL TimeZone = 'UTC'")

fakesnow/server.py

@@ -16,6 +16,7 @@ from starlette.responses import JSONResponse
 from starlette.routing import Route
 
 from fakesnow.arrow import to_ipc, to_sf
+from fakesnow.converter import from_binding
 from fakesnow.fakes import FakeSnowflakeConnection
 from fakesnow.instance import FakeSnow
 from fakesnow.rowtype import describe_as_rowtype
@@ -77,9 +78,16 @@ async def query_request(request: Request) -> JSONResponse:
 
         sql_text = body_json["sqlText"]
 
+        if bindings := body_json.get("bindings"):
+            # Convert parameters like {'1': {'type': 'FIXED', 'value': '10'}, ...} to tuple (10, ...)
+            params = tuple(from_binding(bindings[str(pos)]) for pos in range(1, len(bindings) + 1))
+            logger.debug(f"Bindings: {params}")
+        else:
+            params = None
+
         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)
+            cur = await run_in_threadpool(conn.cursor().execute, sql_text, binding_params=params)
             rowtype = describe_as_rowtype(cur._describe_last_sql())  # noqa: SLF001
 
         except snowflake.connector.errors.ProgrammingError as e:
@@ -113,6 +121,9 @@ async def query_request(request: Request) -> JSONResponse:
         return JSONResponse(
             {
                 "data": {
+                    "parameters": [
+                        {"name": "TIMEZONE", "value": "Etc/UTC"},
+                    ],
                     "rowtype": rowtype,
                     "rowsetBase64": rowset_b64,
                     "total": cur._rowcount,  # noqa: SLF001

fakesnow/transforms/__init__.py

@@ -13,9 +13,9 @@ from fakesnow.transforms.show import (
     show_databases as show_databases,
     show_functions as show_functions,
     show_keys as show_keys,
-    show_objects_tables as show_objects_tables,
     show_procedures as show_procedures,
     show_schemas as show_schemas,
+    show_tables_etc as show_tables_etc,
     show_users as show_users,
     show_warehouses as show_warehouses,
 )
@@ -837,7 +837,7 @@ def regex_replace(expression: exp.Expression) -> exp.Expression:
         if len(expression.args) > 3:
             # see https://docs.snowflake.com/en/sql-reference/functions/regexp_replace
             raise NotImplementedError(
-                "REGEXP_REPLACE with additional parameters (eg: <position>, <occurrence>, <parameters>) not supported"
+                "REGEXP_REPLACE with additional parameters (eg: <position>, <occurrence>, <parameters>)"
             )
 
         # pattern: snowflake requires escaping backslashes in single-quoted string constants, but duckdb doesn't
@@ -1316,9 +1316,9 @@ def create_user(expression: exp.Expression) -> exp.Expression:
         if sub_exp.upper().startswith("USER"):
             _, name, *ignored = sub_exp.split(" ")
             if ignored:
-                raise NotImplementedError(f"`CREATE USER` with {ignored} not yet supported")
+                raise NotImplementedError(f"`CREATE USER` with {ignored}")
             return sqlglot.parse_one(
-                f"INSERT INTO _fs_global._fs_information_schema._fs_users_ext (name) VALUES ('{name}')", read="duckdb"
+                f"INSERT INTO _fs_global._fs_information_schema._fs_users (name) VALUES ('{name}')", read="duckdb"
             )
 
     return expression

fakesnow/transforms/show.py

@@ -6,6 +6,14 @@ import sqlglot
 from sqlglot import exp
 
 
+def fs_global_creation_sql() -> str:
+    return f"""
+        {SQL_CREATE_VIEW_SHOW_OBJECTS};
+        {SQL_CREATE_VIEW_SHOW_TABLES};
+        {SQL_CREATE_VIEW_SHOW_VIEWS};
+    """
+
+
 def show_columns(
     expression: exp.Expression, current_database: str | None = None, current_schema: str | None = None
 ) -> exp.Expression:
@@ -283,22 +291,99 @@ def show_keys(
 
                 statement += f"AND table_name = '{table.name}' "
             else:
-                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind} not yet supported")
+                raise NotImplementedError(f"SHOW PRIMARY KEYS with {scope_kind}")
         return sqlglot.parse_one(statement)
     return expression
 
 
-def show_objects_tables(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
-    """Transform SHOW OBJECTS/TABLES to a query against the information_schema.tables table.
+# see https://docs.snowflake.com/en/sql-reference/sql/show-objects
+SQL_CREATE_VIEW_SHOW_OBJECTS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_objects as
+select
+    to_timestamp(0)::timestamptz as created_on,
+    table_name as name,
+    case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind',
+    table_catalog as database_name,
+    table_schema as schema_name,
+    '' as comment,
+    '' as cluster_by,
+    -- TODO: implement rows and bytes as rows * 1024
+    0 as rows,
+    0 as bytes,
+    'SYSADMIN' as owner,
+    1 as retention_time,
+    'ROLE' as owner_role_type,
+    null as budget,
+    'N' as is_hybrid,
+    'N' as is_dynamic
+from information_schema.tables
+where not (table_schema == '_fs_information_schema')
+"""
 
-    See https://docs.snowflake.com/en/sql-reference/sql/show-objects
-        https://docs.snowflake.com/en/sql-reference/sql/show-tables
-    """
+# see https://docs.snowflake.com/en/sql-reference/sql/show-tables
+SQL_CREATE_VIEW_SHOW_TABLES = """
+create view if not exists _fs_global._fs_information_schema._fs_show_tables as
+select
+    to_timestamp(0)::timestamptz as created_on,
+    table_name as name,
+    'TABLE' as kind,
+    table_catalog as database_name,
+    table_schema as schema_name,
+    '' as comment,
+    '' as cluster_by,
+    -- TODO: implement rows and bytes as rows * 1024
+    0 as rows,
+    0 as bytes,
+    'SYSADMIN' as owner,
+    1 as retention_time,
+    'OFF' as automatic_clustering,
+    'OFF' as change_tracking,
+    'OFF' as search_optimization,
+    null as search_optimization_progress,
+    null as search_optimization_bytes,
+    'N' as is_external,
+    'N' as enable_schema_evolution,
+    'ROLE' as owner_role_type,
+    'N' as is_event,
+    null as budget,
+    'N' as is_hybrid,
+    'N' as is_iceberg,
+    'N' as is_dynamic,
+    'N' as is_immutable
+from information_schema.tables
+where not (table_schema == '_fs_information_schema')
+and table_type = 'BASE TABLE'
+"""
+
+# see https://docs.snowflake.com/en/sql-reference/sql/show-views
+SQL_CREATE_VIEW_SHOW_VIEWS = """
+create view if not exists _fs_global._fs_information_schema._fs_show_views as
+select
+    to_timestamp(0)::timestamptz as created_on,
+    table_name as name,
+    '' as reserved,
+    table_catalog as database_name,
+    table_schema as schema_name,
+    'SYSADMIN' as owner,
+    '' as comment,
+    view_definition as text,
+    false as is_secure,
+    false as is_materialized,
+    'ROLE' as owner_role_type,
+    'OFF' as change_tracking
+from information_schema.views
+where not table_catalog in ('system')
+  and not table_schema in ('main', '_fs_information_schema')
+"""
+
+
+def show_tables_etc(expression: exp.Expression, current_database: str | None = None) -> exp.Expression:
+    """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 in {"OBJECTS", "TABLES"}
+        and show in {"OBJECTS", "TABLES", "VIEWS"}
     ):
         return expression
 
@@ -316,76 +401,28 @@ def show_objects_tables(expression: exp.Expression, current_database: str | None
         catalog = None
         schema = None
 
-    columns = [
-        "to_timestamp(0)::timestamptz as 'created_on'",
-        "table_name as 'name'",
-        "case when table_type='BASE TABLE' then 'TABLE' else table_type end as 'kind'",
-        "table_catalog as 'database_name'",
-        "table_schema as 'schema_name'",
-    ]
-    if not expression.args["terse"]:
-        if show == "OBJECTS":
-            columns.extend(
-                [
-                    "'' as 'comment'",
-                    "'' as 'cluster_by'",
-                    # TODO: implement rows and bytes as rows * 1024
-                    "0 as 'rows'",
-                    "0 as 'bytes'",
-                    "'SYSADMIN' as 'owner'",
-                    "1 as 'retention_time'",
-                    "'ROLE' as 'owner_role_type'",
-                    "null as 'budget'",
-                    "'N' as 'is_hybrid'",
-                    "'N' as 'is_dynamic'",
-                ]
-            )
-        else:
-            # show == "TABLES"
-            columns.extend(
-                [
-                    "'' as 'comment'",
-                    "'' as 'cluster_by'",
-                    # TODO: implement rows and bytes as rows * 1024
-                    "0 as 'rows'",
-                    "0 as 'bytes'",
-                    "'SYSADMIN' as 'owner'",
-                    "1 as 'retention_time'",
-                    "'OFF' as 'automatic_clustering'",
-                    "'OFF' as 'change_tracking'",
-                    "'OFF' as 'search_optimization'",
-                    "null as 'search_optimization_progress'",
-                    "null as 'search_optimization_bytes'",
-                    "'N' as 'is_external'",
-                    "'N' as 'enable_schema_evolution'",
-                    "'ROLE' as 'owner_role_type'",
-                    "'N' as 'is_event'",
-                    "null as 'budget'",
-                    "'N' as 'is_hybrid'",
-                    "'N' as 'is_iceberg'",
-                    "'N' as 'is_dynamic'",
-                    "'N' as 'is_immutable'",
-                ]
-            )
-
+    if expression.args["terse"] and show == "VIEWS":
+        columns = ["created_on, name, 'VIEW' as kind, database_name, schema_name"]
+    elif expression.args["terse"]:
+        columns = ["created_on, name, kind, database_name, schema_name"]
+    else:
+        columns = ["*"]
     columns_clause = ", ".join(columns)
 
-    where = ["not (table_schema == '_fs_information_schema')"]  # exclude fakesnow's internal schemas
-    if show == "TABLES":
-        where.append("table_type = 'BASE TABLE'")
+    where = ["1=1"]
     if catalog:
-        where.append(f"table_catalog = '{catalog}'")
+        where.append(f"database_name = '{catalog}'")
     if schema:
-        where.append(f"table_schema = '{schema}'")
+        where.append(f"schema_name = '{schema}'")
     if (like := expression.args.get("like")) and isinstance(like, exp.Expression):
-        where.append(f"table_name ilike {like.sql()}")
+        where.append(f"name ilike {like.sql()}")
     where_clause = " AND ".join(where)
 
     limit = limit.sql() if (limit := expression.args.get("limit")) and isinstance(limit, exp.Expression) else ""
 
     query = f"""
         SELECT {columns_clause}
-        from information_schema.tables
+        from _fs_global._fs_information_schema._fs_show_{show.lower()}
         where {where_clause}
         {limit}
     """
@@ -471,6 +508,6 @@ 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":
-        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users_ext", read="duckdb")
+        return sqlglot.parse_one("SELECT * FROM _fs_global._fs_information_schema._fs_users", read="duckdb")
 
     return expression

fakesnow/variables.py

@@ -45,7 +45,7 @@ class Variables:
                 self._set(name, value)
             else:
                 # Haven't been able to produce this in tests yet due to UNSET being parsed as an Alias expression.
-                raise NotImplementedError("UNSET not supported yet")
+                raise NotImplementedError("UNSET")
         elif self._is_unset_expression(expr):  # Unfortunately UNSET varname; is parsed as an Alias expression :(
             alias = expr.args.get("alias")
             assert alias, "UNSET without value in alias attribute is unexpected."

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

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

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

@@ -4,25 +4,26 @@ 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/cursor.py,sha256=Nvr8TQmmTFs6i0sJwfgCocrEF9td0D0SdDG41quIudI,21621
+fakesnow/converter.py,sha256=xoBFnfBbGWQyUQAVr6zi-RyglU8A7A3GSlwLPkH1dzI,1621
+fakesnow/cursor.py,sha256=e-nY-w25xmLs1jdhIbO6mwzBHVIUKYIkzR37Wnf3Cfc,22068
 fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
 fakesnow/fakes.py,sha256=JQTiUkkwPeQrJ8FDWhPFPK6pGwd_aR2oiOrNzCWznlM,187
 fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
-fakesnow/info_schema.py,sha256=xDhGy07fpc8bcy_VTfh54UzwNIaB4ZhGmjgJeoiZ0hQ,8744
-fakesnow/instance.py,sha256=VsFbhVfy6EAJdEKykgavJwkMtrig01NehorptT51Jh8,2020
+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=oLnWJgcxwhPw4sNebJF3B9uxk28A-a-AI8Pyl_lz2_E,5986
-fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
-fakesnow/transforms/__init__.py,sha256=xFrpw28DaHvMt6LGaRMsPqTo8PWogg10JgEu3oa6jdA,49515
+fakesnow/server.py,sha256=6EMdNMxL0DgfMNXfFBqRFYmRThbuEVFFpa_1sCW-rZ4,6519
+fakesnow/variables.py,sha256=C3y_9u7LuVtARkpcim3ihgVWg6KKdz1hSVeW4YI7oL4,3014
+fakesnow/transforms/__init__.py,sha256=eJ_XH9pKO4Mxb7MKVgJuo6Wea-LYahF1dc_py5lPHAY,49471
 fakesnow/transforms/merge.py,sha256=Pg7_rwbAT_vr1U4ocBofUSyqaK8_e3qdIz_2SDm2S3s,8320
-fakesnow/transforms/show.py,sha256=2qfK3Fi0RLylqTnkwSVgv5JIorXYb1y0fnf5oErRZ2o,16839
-fakesnow-0.9.33.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow/transforms/show.py,sha256=0NjuLQjodrukfUw8mcxcAmtBkV_6r02mA3nuE3ad3rE,17458
+fakesnow-0.9.35.dist-info/licenses/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
 tools/decode.py,sha256=kC5kUvLQxdCkMRsnH6BqCajlKxKeN77w6rwCKsY6gqU,1781
-fakesnow-0.9.33.dist-info/METADATA,sha256=xOQPPYwFTgDETx_lx1bO2nBpD7wbqWwN1rn2U5MJHFw,18128
-fakesnow-0.9.33.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fakesnow-0.9.33.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.33.dist-info/top_level.txt,sha256=Yos7YveA3f03xVYuURqnBsfMV2DePXfu_yGcsj3pPzI,30
-fakesnow-0.9.33.dist-info/RECORD,,
+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,,