sqlite-utils 3.35.2__py3-none-any.whl → 3.37__py3-none-any.whl

sqlite_utils/cli.py

@@ -60,6 +60,14 @@ It's often worth trying: --encoding=latin-1
 maximize_csv_field_size_limit()
 
 
+class CaseInsensitiveChoice(click.Choice):
+    def __init__(self, choices):
+        super().__init__([choice.lower() for choice in choices])
+
+    def convert(self, value, param, ctx):
+        return super().convert(value.lower(), param, ctx)
+
+
 def output_options(fn):
     for decorator in reversed(
         (
@@ -412,7 +420,8 @@ def dump(path, load_extension):
 @click.argument(
     "col_type",
     type=click.Choice(
-        ["integer", "float", "blob", "text", "INTEGER", "FLOAT", "BLOB", "TEXT"]
+        ["integer", "int", "float", "text", "str", "blob", "bytes"],
+        case_sensitive=False,
     ),
     required=False,
 )
@@ -900,6 +909,12 @@ def insert_upsert_options(*, require_pk=False):
                 ),
                 load_extension_option,
                 click.option("--silent", is_flag=True, help="Do not show progress bar"),
+                click.option(
+                    "--strict",
+                    is_flag=True,
+                    default=False,
+                    help="Apply STRICT mode to created table",
+                ),
             )
         ):
             fn = decorator(fn)
@@ -942,6 +957,7 @@ def insert_upsert_implementation(
     silent=False,
     bulk_sql=None,
     functions=None,
+    strict=False,
 ):
     db = sqlite_utils.Database(path)
     _load_extensions(db, load_extension)
@@ -1057,6 +1073,7 @@ def insert_upsert_implementation(
             "replace": replace,
             "truncate": truncate,
             "analyze": analyze,
+            "strict": strict,
         }
         if not_null:
             extra_kwargs["not_null"] = set(not_null)
@@ -1177,6 +1194,7 @@ def insert(
     truncate,
     not_null,
     default,
+    strict,
 ):
     """
     Insert records from FILE into a table, creating the table if it
@@ -1255,6 +1273,7 @@ def insert(
             silent=silent,
             not_null=not_null,
             default=default,
+            strict=strict,
         )
     except UnicodeDecodeError as ex:
         raise click.ClickException(UNICODE_ERROR.format(ex))
@@ -1290,6 +1309,7 @@ def upsert(
     analyze,
     load_extension,
     silent,
+    strict,
 ):
     """
     Upsert records based on their primary key. Works like 'insert' but if
@@ -1334,6 +1354,7 @@ def upsert(
             analyze=analyze,
             load_extension=load_extension,
             silent=silent,
+            strict=strict,
         )
     except UnicodeDecodeError as ex:
         raise click.ClickException(UNICODE_ERROR.format(ex))
@@ -1468,7 +1489,7 @@ def create_database(path, enable_wal, init_spatialite, load_extension):
 )
 @click.argument("table")
 @click.argument("columns", nargs=-1, required=True)
-@click.option("--pk", help="Column to use as primary key")
+@click.option("pks", "--pk", help="Column to use as primary key", multiple=True)
 @click.option(
     "--not-null",
     multiple=True,
@@ -1502,11 +1523,16 @@ def create_database(path, enable_wal, init_spatialite, load_extension):
     help="If table already exists, try to transform the schema",
 )
 @load_extension_option
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="Apply STRICT mode to created table",
+)
 def create_table(
     path,
     table,
     columns,
-    pk,
+    pks,
     not_null,
     default,
     fk,
@@ -1514,6 +1540,7 @@ def create_table(
     replace,
     transform,
     load_extension,
+    strict,
 ):
     """
     Add a table with the specified columns. Columns should be specified using
@@ -1554,13 +1581,14 @@ def create_table(
             )
     db[table].create(
         coltypes,
-        pk=pk,
+        pk=pks[0] if len(pks) == 1 else pks,
         not_null=not_null,
         defaults=dict(default),
         foreign_keys=fk,
         ignore=ignore,
         replace=replace,
         transform=transform,
+        strict=strict,
     )
 
 
@@ -2566,7 +2594,7 @@ def extract(
     multiple=True,
     help="Column definitions for the table",
 )
-@click.option("--pk", type=str, help="Column to use as primary key")
+@click.option("pks", "--pk", help="Column to use as primary key", multiple=True)
 @click.option("--alter", is_flag=True, help="Alter table to add missing columns")
 @click.option("--replace", is_flag=True, help="Replace files with matching primary key")
 @click.option("--upsert", is_flag=True, help="Upsert files with matching primary key")
@@ -2583,7 +2611,7 @@ def insert_files(
     table,
     file_or_dir,
     column,
-    pk,
+    pks,
     alter,
     replace,
     upsert,
@@ -2613,8 +2641,8 @@ def insert_files(
             column = ["path:path", "content_text:content_text", "size:size"]
         else:
             column = ["path:path", "content:content", "size:size"]
-        if not pk:
-            pk = "path"
+        if not pks:
+            pks = ["path"]
 
     def yield_paths_and_relative_paths():
         for f_or_d in file_or_dir:
@@ -2684,7 +2712,11 @@ def insert_files(
         try:
             with db.conn:
                 db[table].insert_all(
-                    to_insert(), pk=pk, alter=alter, replace=replace, upsert=upsert
+                    to_insert(),
+                    pk=pks[0] if len(pks) == 1 else pks,
+                    alter=alter,
+                    replace=replace,
+                    upsert=upsert,
                 )
         except UnicodeDecodeErrorForPath as e:
             raise click.ClickException(
@@ -2843,9 +2875,9 @@ def _generate_convert_help():
     Convert columns using Python code you supply. For example:
 
     \b
-        sqlite-utils convert my.db mytable mycolumn \\
-            '"\\n".join(textwrap.wrap(value, 10))' \\
-            --import=textwrap
+    sqlite-utils convert my.db mytable mycolumn \\
+        '"\\n".join(textwrap.wrap(value, 10))' \\
+        --import=textwrap
 
     "value" is a variable with the column value to be converted.
 
@@ -2864,7 +2896,7 @@ def _generate_convert_help():
     for name in recipe_names:
         fn = getattr(recipes, name)
         help += "\n\nr.{}{}\n\n\b{}".format(
-            name, str(inspect.signature(fn)), fn.__doc__.rstrip()
+            name, str(inspect.signature(fn)), textwrap.dedent(fn.__doc__.rstrip())
         )
     help += "\n\n"
     help += textwrap.dedent(
@@ -2872,8 +2904,8 @@ def _generate_convert_help():
     You can use these recipes like so:
 
     \b
-        sqlite-utils convert my.db mytable mycolumn \\
-            'r.jsonsplit(value, delimiter=":")'
+    sqlite-utils convert my.db mytable mycolumn \\
+        'r.jsonsplit(value, delimiter=":")'
     """
     ).strip()
     return help

sqlite_utils/db.py

@@ -197,27 +197,34 @@ COLUMN_TYPE_MAPPING = {
     "FLOAT": "FLOAT",
     "BLOB": "BLOB",
     "text": "TEXT",
+    "str": "TEXT",
     "integer": "INTEGER",
+    "int": "INTEGER",
     "float": "FLOAT",
     "blob": "BLOB",
+    "bytes": "BLOB",
 }
 # If numpy is available, add more types
 if np:
-    COLUMN_TYPE_MAPPING.update(
-        {
-            np.int8: "INTEGER",
-            np.int16: "INTEGER",
-            np.int32: "INTEGER",
-            np.int64: "INTEGER",
-            np.uint8: "INTEGER",
-            np.uint16: "INTEGER",
-            np.uint32: "INTEGER",
-            np.uint64: "INTEGER",
-            np.float16: "FLOAT",
-            np.float32: "FLOAT",
-            np.float64: "FLOAT",
-        }
-    )
+    try:
+        COLUMN_TYPE_MAPPING.update(
+            {
+                np.int8: "INTEGER",
+                np.int16: "INTEGER",
+                np.int32: "INTEGER",
+                np.int64: "INTEGER",
+                np.uint8: "INTEGER",
+                np.uint16: "INTEGER",
+                np.uint32: "INTEGER",
+                np.uint64: "INTEGER",
+                np.float16: "FLOAT",
+                np.float32: "FLOAT",
+                np.float64: "FLOAT",
+            }
+        )
+    except AttributeError:
+        # https://github.com/simonw/sqlite-utils/issues/632
+        pass
 
 # If pandas is available, add more types
 if pd:
@@ -300,6 +307,7 @@ class Database:
       ``sql, parameters`` every time a SQL query is executed
     :param use_counts_table: set to ``True`` to use a cached counts table, if available. See
       :ref:`python_api_cached_table_counts`
+    :param strict: Apply STRICT mode to all created tables (unless overridden)
     """
 
     _counts_table_name = "_counts"
@@ -315,6 +323,7 @@ class Database:
         tracer: Optional[Callable] = None,
         use_counts_table: bool = False,
         execute_plugins: bool = True,
+        strict: bool = False,
     ):
         assert (filename_or_conn is not None and (not memory and not memory_name)) or (
             filename_or_conn is None and (memory or memory_name)
@@ -348,6 +357,7 @@ class Database:
         self.use_counts_table = use_counts_table
         if execute_plugins:
             pm.hook.prepare_connection(conn=self.conn)
+        self.strict = strict
 
     def close(self):
         "Close the SQLite connection, and the underlying database file"
@@ -451,8 +461,7 @@ class Database:
                         fn_name, arity, fn, **dict(kwargs, deterministic=True)
                     )
                     registered = True
-                except (sqlite3.NotSupportedError, TypeError):
-                    # TypeError is Python 3.7 "function takes at most 3 arguments"
+                except sqlite3.NotSupportedError:
                     pass
             if not registered:
                 self.conn.create_function(fn_name, arity, fn, **kwargs)
@@ -534,8 +543,11 @@ class Database:
 
         :param table_name: Name of the table
         """
-        klass = View if table_name in self.view_names() else Table
-        return klass(self, table_name, **kwargs)
+        if table_name in self.view_names():
+            return View(self, table_name, **kwargs)
+        else:
+            kwargs.setdefault("strict", self.strict)
+            return Table(self, table_name, **kwargs)
 
     def quote(self, value: str) -> str:
         """
@@ -821,6 +833,7 @@ class Database:
         hash_id_columns: Optional[Iterable[str]] = None,
         extracts: Optional[Union[Dict[str, str], List[str]]] = None,
         if_not_exists: bool = False,
+        strict: bool = False,
     ) -> str:
         """
         Returns the SQL ``CREATE TABLE`` statement for creating the specified table.
@@ -836,6 +849,7 @@ class Database:
         :param hash_id_columns: List of columns to be used when calculating the hash ID for a row
         :param extracts: List or dictionary of columns to be extracted during inserts, see :ref:`python_api_extracts`
         :param if_not_exists: Use ``CREATE TABLE IF NOT EXISTS``
+        :param strict: Apply STRICT mode to table
         """
         if hash_id_columns and (hash_id is None):
             hash_id = "id"
@@ -919,9 +933,9 @@ class Database:
                 "   [{column_name}] {column_type}{column_extras}".format(
                     column_name=column_name,
                     column_type=COLUMN_TYPE_MAPPING[column_type],
-                    column_extras=(" " + " ".join(column_extras))
-                    if column_extras
-                    else "",
+                    column_extras=(
+                        (" " + " ".join(column_extras)) if column_extras else ""
+                    ),
                 )
             )
         extra_pk = ""
@@ -932,12 +946,13 @@ class Database:
         columns_sql = ",\n".join(column_defs)
         sql = """CREATE TABLE {if_not_exists}[{table}] (
 {columns_sql}{extra_pk}
-);
+){strict};
         """.format(
             if_not_exists="IF NOT EXISTS " if if_not_exists else "",
             table=name,
             columns_sql=columns_sql,
             extra_pk=extra_pk,
+            strict=" STRICT" if strict and self.supports_strict else "",
         )
         return sql
 
@@ -957,6 +972,7 @@ class Database:
         replace: bool = False,
         ignore: bool = False,
         transform: bool = False,
+        strict: bool = False,
     ) -> "Table":
         """
         Create a table with the specified name and the specified ``{column_name: type}`` columns.
@@ -977,6 +993,7 @@ class Database:
         :param replace: Drop and replace table if it already exists
         :param ignore: Silently do nothing if table already exists
         :param transform: If table already exists transform it to fit the specified schema
+        :param strict: Apply STRICT mode to table
         """
         # Transform table to match the new definition if table already exists:
         if self[name].exists():
@@ -1048,6 +1065,7 @@ class Database:
             hash_id_columns=hash_id_columns,
             extracts=extracts,
             if_not_exists=if_not_exists,
+            strict=strict,
         )
         self.execute(sql)
         created_table = self.table(
@@ -1416,6 +1434,7 @@ class Table(Queryable):
     :param extracts: Dictionary or list of column names to extract into a separate table on inserts
     :param conversions: Dictionary of column names and conversion functions
     :param columns: Dictionary of column names to column types
+    :param strict: If True, apply STRICT mode to table
     """
 
     #: The ``rowid`` of the last inserted, updated or selected row.
@@ -1441,6 +1460,7 @@ class Table(Queryable):
         extracts: Optional[Union[Dict[str, str], List[str]]] = None,
         conversions: Optional[dict] = None,
         columns: Optional[Dict[str, Any]] = None,
+        strict: bool = False,
     ):
         super().__init__(db, name)
         self._defaults = dict(
@@ -1458,14 +1478,17 @@ class Table(Queryable):
             extracts=extracts,
             conversions=conversions or {},
             columns=columns,
+            strict=strict,
         )
 
     def __repr__(self) -> str:
         return "<Table {}{}>".format(
             self.name,
-            " (does not exist yet)"
-            if not self.exists()
-            else " ({})".format(", ".join(c.name for c in self.columns)),
+            (
+                " (does not exist yet)"
+                if not self.exists()
+                else " ({})".format(", ".join(c.name for c in self.columns))
+            ),
         )
 
     @property
@@ -1639,6 +1662,7 @@ class Table(Queryable):
         replace: bool = False,
         ignore: bool = False,
         transform: bool = False,
+        strict: bool = False,
     ) -> "Table":
         """
         Create a table with the specified columns.
@@ -1658,6 +1682,7 @@ class Table(Queryable):
         :param replace: Drop and replace table if it already exists
         :param ignore: Silently do nothing if table already exists
         :param transform: If table already exists transform it to fit the specified schema
+        :param strict: Apply STRICT mode to table
         """
         columns = {name: value for (name, value) in columns.items()}
         with self.db.conn:
@@ -1676,6 +1701,7 @@ class Table(Queryable):
                 replace=replace,
                 ignore=ignore,
                 transform=transform,
+                strict=strict,
             )
         return self
 
@@ -1909,6 +1935,7 @@ class Table(Queryable):
                 defaults=create_table_defaults,
                 foreign_keys=create_table_foreign_keys,
                 column_order=column_order,
+                strict=self.strict,
             ).strip()
         )
 
@@ -2918,9 +2945,11 @@ class Table(Queryable):
                 value = jsonify_if_needed(
                     record.get(
                         key,
-                        None
-                        if key != hash_id
-                        else hash_record(record, hash_id_columns),
+                        (
+                            None
+                            if key != hash_id
+                            else hash_record(record, hash_id_columns)
+                        ),
                     )
                 )
                 if key in extracts:
@@ -3111,6 +3140,7 @@ class Table(Queryable):
         extracts: Optional[Union[Dict[str, str], List[str], Default]] = DEFAULT,
         conversions: Optional[Union[Dict[str, str], Default]] = DEFAULT,
         columns: Optional[Union[Dict[str, Any], Default]] = DEFAULT,
+        strict: Optional[Union[bool, Default]] = DEFAULT,
     ) -> "Table":
         """
         Insert a single record into the table. The table will be created with a schema that matches
@@ -3143,6 +3173,7 @@ class Table(Queryable):
           is being inserted, for example ``{"name": "upper(?)"}``. See :ref:`python_api_conversions`.
         :param columns: Dictionary over-riding the detected types used for the columns, for example
           ``{"age": int, "weight": float}``.
+        :param strict: Boolean, apply STRICT mode if creating the table.
         """
         return self.insert_all(
             [record],
@@ -3159,6 +3190,7 @@ class Table(Queryable):
             extracts=extracts,
             conversions=conversions,
             columns=columns,
+            strict=strict,
         )
 
     def insert_all(
@@ -3181,6 +3213,7 @@ class Table(Queryable):
         columns=DEFAULT,
         upsert=False,
         analyze=False,
+        strict=DEFAULT,
     ) -> "Table":
         """
         Like ``.insert()`` but takes a list of records and ensures that the table
@@ -3202,6 +3235,7 @@ class Table(Queryable):
         extracts = self.value_or_default("extracts", extracts)
         conversions = self.value_or_default("conversions", conversions) or {}
         columns = self.value_or_default("columns", columns)
+        strict = self.value_or_default("strict", strict)
 
         if hash_id_columns and hash_id is None:
             hash_id = "id"
@@ -3257,6 +3291,7 @@ class Table(Queryable):
                         hash_id=hash_id,
                         hash_id_columns=hash_id_columns,
                         extracts=extracts,
+                        strict=strict,
                     )
                 all_columns_set = set()
                 for record in chunk:
@@ -3307,6 +3342,7 @@ class Table(Queryable):
         extracts=DEFAULT,
         conversions=DEFAULT,
         columns=DEFAULT,
+        strict=DEFAULT,
     ) -> "Table":
         """
         Like ``.insert()`` but performs an ``UPSERT``, where records are inserted if they do
@@ -3327,6 +3363,7 @@ class Table(Queryable):
             extracts=extracts,
             conversions=conversions,
             columns=columns,
+            strict=strict,
         )
 
     def upsert_all(
@@ -3345,6 +3382,7 @@ class Table(Queryable):
         conversions=DEFAULT,
         columns=DEFAULT,
         analyze=False,
+        strict=DEFAULT,
     ) -> "Table":
         """
         Like ``.upsert()`` but can be applied to a list of records.
@@ -3365,6 +3403,7 @@ class Table(Queryable):
             columns=columns,
             upsert=True,
             analyze=analyze,
+            strict=strict,
         )
 
     def add_missing_columns(self, records: Iterable[Dict[str, Any]]) -> "Table":
@@ -3387,6 +3426,7 @@ class Table(Queryable):
         extracts: Optional[Union[Dict[str, str], List[str]]] = None,
         conversions: Optional[Dict[str, str]] = None,
         columns: Optional[Dict[str, Any]] = None,
+        strict: Optional[bool] = False,
     ):
         """
         Create or populate a lookup table with the specified values.
@@ -3409,6 +3449,7 @@ class Table(Queryable):
 
         :param lookup_values: Dictionary specifying column names and values to use for the lookup
         :param extra_values: Additional column values to be used only if creating a new record
+        :param strict: Boolean, apply STRICT mode if creating the table.
         """
         assert isinstance(lookup_values, dict)
         if extra_values is not None:
@@ -3440,6 +3481,7 @@ class Table(Queryable):
                     extracts=extracts,
                     conversions=conversions,
                     columns=columns,
+                    strict=strict,
                 ).last_pk
         else:
             pk = self.insert(
@@ -3452,6 +3494,7 @@ class Table(Queryable):
                 extracts=extracts,
                 conversions=conversions,
                 columns=columns,
+                strict=strict,
             ).last_pk
             self.create_index(lookup_values.keys(), unique=True)
             return pk

sqlite_utils/utils.py

@@ -304,10 +304,7 @@ def rows_from_file(
         rows = rows_from_file(
             fp, format=Format.CSV, dialect=csv.excel_tab, encoding=encoding
         )[0]
-        return (
-            _extra_key_strategy(rows, ignore_extras, extras_key),
-            Format.TSV,
-        )
+        return _extra_key_strategy(rows, ignore_extras, extras_key), Format.TSV
     elif format is None:
         # Detect the format, then call this recursively
         buffered = io.BufferedReader(cast(io.RawIOBase, fp), buffer_size=4096)

{sqlite_utils-3.35.2.dist-info → sqlite_utils-3.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlite-utils
-Version: 3.35.2
+Version: 3.37
 Summary: CLI tool and Python library for manipulating SQLite databases
 Home-page: https://github.com/simonw/sqlite-utils
 Author: Simon Willison
@@ -16,13 +16,13 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Topic :: Database
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sqlite-fts4
@@ -49,7 +49,7 @@ Requires-Dist: types-pluggy ; extra == 'mypy'
 Requires-Dist: data-science-types ; extra == 'mypy'
 Provides-Extra: test
 Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: black ; extra == 'test'
+Requires-Dist: black >=24.1.1 ; extra == 'test'
 Requires-Dist: hypothesis ; extra == 'test'
 Requires-Dist: cogapp ; extra == 'test'
 Provides-Extra: tui

sqlite_utils-3.37.dist-info/RECORD

@@ -0,0 +1,15 @@
+sqlite_utils/__init__.py,sha256=eyDK-5KOo-ARS3i0JcuxGiJmk5T-58Z1p_bhACbBrGc,201
+sqlite_utils/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
+sqlite_utils/cli.py,sha256=sBAF9cxvJ108OBWspzQoz1dvN_fLBhlJSaAbmWbYlHc,89771
+sqlite_utils/db.py,sha256=na--6HxI5db7_LaZwwY2nAusVJaZ2AlC-DYTNHwY1A8,146365
+sqlite_utils/hookspecs.py,sha256=NFA0BFZ8WUhnI_NRz4oFVDcomQYlguuAgUCBKAN792o,395
+sqlite_utils/plugins.py,sha256=V5nXD4r0o1wSbIHHOAiUBBV66ZOfKVnywKfZzCUqdsA,771
+sqlite_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlite_utils/recipes.py,sha256=_npzti0nPV6XxvMj69Ca4QF-pXwZZQp_f_VY3i7pQDs,1687
+sqlite_utils/utils.py,sha256=PRqoITtqmaUI7xzyB2exaTPg6oXbTMhGDzld7srNOG4,17099
+sqlite_utils-3.37.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlite_utils-3.37.dist-info/METADATA,sha256=DdfINwbgTnsxBvYUgSaz0pePxd9PqJCcyfn107VNkJA,7561
+sqlite_utils-3.37.dist-info/WHEEL,sha256=-oYQCr74JF3a37z2nRlQays_SX2MqOANoqVjBBAP2yE,91
+sqlite_utils-3.37.dist-info/entry_points.txt,sha256=33jbVHROlRBNhoXoSI-QI2rN6JDkJIkKIX7P5sNIWdY,54
+sqlite_utils-3.37.dist-info/top_level.txt,sha256=_dw_n5BWKUEtCYB2DTlmPMQfdRZSuFsmRQe2ZhNYwnQ,13
+sqlite_utils-3.37.dist-info/RECORD,,

{sqlite_utils-3.35.2.dist-info → sqlite_utils-3.37.dist-info}/WHEEL

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

sqlite_utils-3.35.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-sqlite_utils/__init__.py,sha256=eyDK-5KOo-ARS3i0JcuxGiJmk5T-58Z1p_bhACbBrGc,201
-sqlite_utils/__main__.py,sha256=8hDtWlaFZK24KhfNq_ZKgtXqYHsDQDetukOCMlsbW0Q,59
-sqlite_utils/cli.py,sha256=kHYDOWFbAbas5rkdr67BanbqHBVIlsymKkd0BRSsags,88859
-sqlite_utils/db.py,sha256=a89cAwKNxrx0eAmhurorKDRWGyQ_u4II9-HwRSG0cuE,144794
-sqlite_utils/hookspecs.py,sha256=NFA0BFZ8WUhnI_NRz4oFVDcomQYlguuAgUCBKAN792o,395
-sqlite_utils/plugins.py,sha256=V5nXD4r0o1wSbIHHOAiUBBV66ZOfKVnywKfZzCUqdsA,771
-sqlite_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlite_utils/recipes.py,sha256=_npzti0nPV6XxvMj69Ca4QF-pXwZZQp_f_VY3i7pQDs,1687
-sqlite_utils/utils.py,sha256=jvlsGQ5F_Z7-bAiP7gw4hmov_58PrVMvY_5UZ3nXfAg,17136
-sqlite_utils-3.35.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlite_utils-3.35.2.dist-info/METADATA,sha256=sWiT3qYyM8iNmyXtU993w5y-Y7LNu5l3sk1k4ZKHSos,7553
-sqlite_utils-3.35.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-sqlite_utils-3.35.2.dist-info/entry_points.txt,sha256=33jbVHROlRBNhoXoSI-QI2rN6JDkJIkKIX7P5sNIWdY,54
-sqlite_utils-3.35.2.dist-info/top_level.txt,sha256=_dw_n5BWKUEtCYB2DTlmPMQfdRZSuFsmRQe2ZhNYwnQ,13
-sqlite_utils-3.35.2.dist-info/RECORD,,