sqlite-utils 3.35.2__tar.gz → 3.37__tar.gz

{sqlite-utils-3.35.2/sqlite_utils.egg-info → sqlite_utils-3.37}/PKG-INFO

@@ -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
@@ -33,7 +33,7 @@ Requires-Dist: python-dateutil
 Requires-Dist: pluggy
 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: docs

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/docs/changelog.rst

@@ -4,6 +4,26 @@
  Changelog
 ===========
 
+.. _v3_37:
+
+3.37 (2024-07-18)
+-----------------
+
+- The ``create-table`` and ``insert-files`` commands all now accept multiple ``--pk`` options for compound primary keys. (:issue:`620`)
+- Now tested against Python 3.13 pre-release. (`#619 <https://github.com/simonw/sqlite-utils/pull/619>`__)
+- Fixed a crash that can occur in environments with a broken ``numpy`` installation, producing a ``module 'numpy' has no attribute 'int8'``. (:issue:`632`)
+
+.. _v3_36:
+
+3.36 (2023-12-07)
+-----------------
+
+- Support for creating tables in `SQLite STRICT mode <https://www.sqlite.org/stricttables.html>`__. Thanks, `Taj Khattra <https://github.com/tkhattra>`__. (:issue:`344`)
+    - CLI commands ``create-table``, ``insert`` and ``upsert`` all now accept a ``--strict`` option.
+    - Python methods that can create a table - ``table.create()`` and ``insert/upsert/insert_all/upsert_all`` all now accept an optional ``strict=True`` parameter.
+    - The ``transform`` command and ``table.transform()`` method preserve strict mode when transforming a table.
+- The ``sqlite-utils create-table`` command now accepts ``str``, ``int`` and ``bytes`` as aliases for ``text``, ``integer`` and ``blob`` respectively. (:issue:`606`)
+
 .. _v3_35_2:
 
 3.35.2 (2023-11-03)

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/docs/cli-reference.rst

@@ -85,6 +85,7 @@ This page lists the ``--help`` for every ``sqlite-utils`` CLI sub-command.
         cog.out("::\n\n")
         result = CliRunner().invoke(cli.cli, [command, "--help"])
         output = result.output.replace("Usage: cli ", "Usage: sqlite-utils ")
+        output = output.replace('\b', '')
         cog.out(textwrap.indent(output, '    '))
         cog.out("\n\n")
 .. ]]]
@@ -289,6 +290,7 @@ See :ref:`cli_inserting_data`, :ref:`cli_insert_csv_tsv`, :ref:`cli_insert_unstr
       --analyze                 Run ANALYZE at the end of this operation
       --load-extension TEXT     Path to SQLite extension, with optional :entrypoint
       --silent                  Do not show progress bar
+      --strict                  Apply STRICT mode to created table
       --ignore                  Ignore records if pk already exists
       --replace                 Replace records if pk already exists
       --truncate                Truncate table before inserting records, if table
@@ -345,6 +347,7 @@ See :ref:`cli_upsert`.
       --analyze                 Run ANALYZE at the end of this operation
       --load-extension TEXT     Path to SQLite extension, with optional :entrypoint
       --silent                  Do not show progress bar
+      --strict                  Apply STRICT mode to created table
       -h, --help                Show this message and exit.
 
 
@@ -601,9 +604,9 @@ See :ref:`cli_convert`.
 
       Convert columns using Python code you supply. For example:
 
-          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.
 
@@ -613,30 +616,30 @@ See :ref:`cli_convert`.
 
       r.jsonsplit(value, delimiter=',', type=<class 'str'>)
 
-          Convert a string like a,b,c into a JSON array ["a", "b", "c"]
+      Convert a string like a,b,c into a JSON array ["a", "b", "c"]
 
       r.parsedate(value, dayfirst=False, yearfirst=False, errors=None)
 
-          Parse a date and convert it to ISO date format: yyyy-mm-dd
-          
-          - dayfirst=True: treat xx as the day in xx/yy/zz
-          - yearfirst=True: treat xx as the year in xx/yy/zz
-          - errors=r.IGNORE to ignore values that cannot be parsed
-          - errors=r.SET_NULL to set values that cannot be parsed to null
+      Parse a date and convert it to ISO date format: yyyy-mm-dd
+  
+      - dayfirst=True: treat xx as the day in xx/yy/zz
+      - yearfirst=True: treat xx as the year in xx/yy/zz
+      - errors=r.IGNORE to ignore values that cannot be parsed
+      - errors=r.SET_NULL to set values that cannot be parsed to null
 
       r.parsedatetime(value, dayfirst=False, yearfirst=False, errors=None)
 
-          Parse a datetime and convert it to ISO datetime format: yyyy-mm-ddTHH:MM:SS
-          
-          - dayfirst=True: treat xx as the day in xx/yy/zz
-          - yearfirst=True: treat xx as the year in xx/yy/zz
-          - errors=r.IGNORE to ignore values that cannot be parsed
-          - errors=r.SET_NULL to set values that cannot be parsed to null
+      Parse a datetime and convert it to ISO datetime format: yyyy-mm-ddTHH:MM:SS
+  
+      - dayfirst=True: treat xx as the day in xx/yy/zz
+      - yearfirst=True: treat xx as the year in xx/yy/zz
+      - errors=r.IGNORE to ignore values that cannot be parsed
+      - errors=r.SET_NULL to set values that cannot be parsed to null
 
       You can use these recipes like so:
 
-          sqlite-utils convert my.db mytable mycolumn \
-              'r.jsonsplit(value, delimiter=":")'
+      sqlite-utils convert my.db mytable mycolumn \
+          'r.jsonsplit(value, delimiter=":")'
 
     Options:
       --import TEXT                   Python modules to import
@@ -920,6 +923,7 @@ See :ref:`cli_create_table`.
       --replace                 If table already exists, replace it
       --transform               If table already exists, try to transform the schema
       --load-extension TEXT     Path to SQLite extension, with optional :entrypoint
+      --strict                  Apply STRICT mode to created table
       -h, --help                Show this message and exit.
 
 
@@ -1157,7 +1161,7 @@ See :ref:`cli_add_column`.
 ::
 
     Usage: sqlite-utils add-column [OPTIONS] PATH TABLE COL_NAME
-                          [[integer|float|blob|text|INTEGER|FLOAT|BLOB|TEXT]]
+                          [[integer|int|float|text|str|blob|bytes]]
 
       Add a column to the specified table
 

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/docs/cli.rst

@@ -1088,11 +1088,13 @@ You can import all three records into an automatically created ``dogs`` table an
 
     sqlite-utils insert dogs.db dogs dogs.json --pk=id
 
+Pass ``--pk`` multiple times to define a compound primary key.
+
 You can skip inserting any records that have a primary key that already exists using ``--ignore``:
 
 .. code-block:: bash
 
-    sqlite-utils insert dogs.db dogs dogs.json --ignore
+    sqlite-utils insert dogs.db dogs dogs.json --pk=id --ignore
 
 You can delete all the existing rows in the table before inserting the new records using ``--truncate``:
 
@@ -1909,6 +1911,8 @@ This will create a table called ``mytable`` with two columns - an integer ``id``
 
 You can pass as many column-name column-type pairs as you like. Valid types are ``integer``, ``text``, ``float`` and ``blob``.
 
+Pass ``--pk`` more than once for a compound primary key that covers multiple columns.
+
 You can specify columns that should be NOT NULL using ``--not-null colname``. You can specify default values for columns using ``--default colname defaultvalue``.
 
 .. code-block:: bash
@@ -1972,6 +1976,25 @@ You can specify foreign key relationships between the tables you are creating us
                 [author_id] INTEGER REFERENCES [authors]([id])
              )
 
+You can create a table in `SQLite STRICT mode <https://www.sqlite.org/stricttables.html>`__ using ``--strict``:
+
+.. code-block:: bash
+
+   sqlite-utils create-table mydb.db mytable id integer name text --strict
+
+.. code-block:: bash
+
+   sqlite-utils tables mydb.db --schema -t
+
+.. code-block:: output
+
+   table    schema
+   -------  ------------------------
+   mytable  CREATE TABLE [mytable] (
+               [id] INTEGER,
+               [name] TEXT
+            ) STRICT
+
 If a table with the same name already exists, you will get an error. You can choose to silently ignore this error with ``--ignore``, or you can replace the existing table with a new, empty table using ``--replace``.
 
 You can also pass ``--transform`` to transform the existing table to match the new schema. See :ref:`python_api_explicit_create` in the Python library documentation for details of how this option works.
@@ -2018,7 +2041,7 @@ Use ``--ignore`` to ignore the error if the table does not exist.
 Transforming tables
 ===================
 
-The ``transform`` command allows you to apply complex transformations to a table that cannot be implemented using a regular SQLite ``ALTER TABLE`` command. See :ref:`python_api_transform` for details of how this works.
+The ``transform`` command allows you to apply complex transformations to a table that cannot be implemented using a regular SQLite ``ALTER TABLE`` command. See :ref:`python_api_transform` for details of how this works. The ``transform`` command preserves a table's ``STRICT`` mode.
 
 .. code-block:: bash
 
@@ -2310,7 +2333,14 @@ You can add a column using the ``add-column`` command:
 
     sqlite-utils add-column mydb.db mytable nameofcolumn text
 
-The last argument here is the type of the column to be created. You can use one of ``text``, ``integer``, ``float`` or ``blob``. If you leave it off, ``text`` will be used.
+The last argument here is the type of the column to be created. This can be one of:
+
+- ``text`` or ``str``
+- ``integer`` or ``int``
+- ``float``
+- ``blob`` or ``bytes``
+
+This argument is optional and defaults to ``text``.
 
 You can add a column that is a foreign key reference to another table using the ``--fk`` option:
 

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/docs/plugins.rst

@@ -49,7 +49,7 @@ In that folder create two files. The first is a ``pyproject.toml`` file describi
     [project.entry-points.sqlite_utils]
     hello_world = "sqlite_utils_hello_world"
 
-The ```[project.entry-points.sqlite_utils]`` section tells ``sqlite-tils`` which module to load when executing the plugin.
+The ``[project.entry-points.sqlite_utils]`` section tells ``sqlite-utils`` which module to load when executing the plugin.
 
 Then create ``sqlite_utils_hello_world.py`` with the following content:
 
@@ -75,7 +75,7 @@ Or pass the path to your plugin directory:
 
 .. code-block:: bash
 
-    sqlite-utils install -e `/dev/sqlite-utils-hello-world
+    sqlite-utils install -e /dev/sqlite-utils-hello-world
 
 Now, running this should execute your new command:
 

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/docs/python-api.rst

@@ -117,6 +117,12 @@ By default, any :ref:`sqlite-utils plugins <plugins>` that implement the :ref:`p
 
     db = Database(memory=True, execute_plugins=False)
 
+You can pass ``strict=True`` to enable `SQLite STRICT mode <https://www.sqlite.org/stricttables.html>`__ for all tables created using this database object:
+
+.. code-block:: python
+
+    db = Database("my_database.db", strict=True)
+
 .. _python_api_attach:
 
 Attaching additional databases
@@ -581,6 +587,15 @@ The ``transform=True`` option will update the table schema if any of the followi
 
 Changes to ``foreign_keys=`` are not currently detected and applied by ``transform=True``.
 
+You can pass ``strict=True`` to create a table in ``STRICT`` mode:
+
+.. code-block:: python
+
+    db["cats"].create({
+        "id": int,
+        "name": str,
+    }, strict=True)
+
 .. _python_api_compound_primary_keys:
 
 Compound primary keys
@@ -661,7 +676,7 @@ You can set default values for these methods by accessing the table through the
     # Now you can call .insert() like so:
     table.insert({"id": 1, "name": "Tracy", "score": 5})
 
-The configuration options that can be specified in this way are ``pk``, ``foreign_keys``, ``column_order``, ``not_null``, ``defaults``, ``batch_size``, ``hash_id``, ``hash_id_columns``, ``alter``, ``ignore``, ``replace``, ``extracts``, ``conversions``, ``columns``. These are all documented below.
+The configuration options that can be specified in this way are ``pk``, ``foreign_keys``, ``column_order``, ``not_null``, ``defaults``, ``batch_size``, ``hash_id``, ``hash_id_columns``, ``alter``, ``ignore``, ``replace``, ``extracts``, ``conversions``, ``columns``, ``strict``. These are all documented below.
 
 .. _python_api_defaults_not_null:
 
@@ -875,7 +890,8 @@ You can delete all records in a table that match a specific WHERE statement usin
 
     >>> db = sqlite_utils.Database("dogs.db")
     >>> # Delete every dog with age less than 3
-    >>> db["dogs"].delete_where("age < ?", [3])
+    >>> with db.conn:
+    >>>     db["dogs"].delete_where("age < ?", [3])
 
 Calling ``table.delete_where()`` with no other arguments will delete every row in the table.
 
@@ -1011,6 +1027,7 @@ The first time this is called the record will be created for ``name="Palm"``. An
 - ``extracts``
 - ``conversions``
 - ``columns``
+- ``strict``
 
 .. _python_api_extracts:
 
@@ -2161,6 +2178,18 @@ The ``.has_counts_triggers`` property shows if a table has been configured with
     >>> db["authors"].has_counts_triggers
     True
 
+.. _python_api_introspection_supports_strict:
+
+db.supports_strict
+------------------
+
+This property on the database object returns ``True`` if the available SQLite version supports `STRICT mode <https://www.sqlite.org/stricttables.html>`__, which was added in SQLite 3.37.0 (on 2021-11-27).
+
+::
+
+    >>> db.supports_strict
+    True
+
 .. _python_api_fts:
 
 Full-text search

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import io
 import os
 
-VERSION = "3.35.2"
+VERSION = "3.37"
 
 
 def get_long_description():
@@ -32,7 +32,7 @@ setup(
         "pluggy",
     ],
     extras_require={
-        "test": ["pytest", "black", "hypothesis", "cogapp"],
+        "test": ["pytest", "black>=24.1.1", "hypothesis", "cogapp"],
         "docs": [
             "furo",
             "sphinx-autobuild",
@@ -64,7 +64,7 @@ setup(
         "Issues": "https://github.com/simonw/sqlite-utils/issues",
         "CI": "https://github.com/simonw/sqlite-utils/actions",
     },
-    python_requires=">=3.7",
+    python_requires=">=3.8",
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
@@ -72,12 +72,12 @@ setup(
         "Intended Audience :: End Users/Desktop",
         "Topic :: Database",
         "License :: OSI Approved :: Apache Software License",
-        "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
     ],
     # Needed to bundle py.typed so mypy can see it:
     zip_safe=False,

{sqlite-utils-3.35.2 → sqlite_utils-3.37}/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