metta-sqlite 0.9.2__tar.gz

metta_sqlite-0.9.2/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: metta-sqlite
+Version: 0.9.2
+Summary: sqlite3 as a SQL engine a MeTTa head can be registered into
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pymetta==0.9.2
+
+# metta-sqlite
+
+sqlite3 as a SQL engine a MeTTa head can be registered into.
+
+`pymetta` names no third-party library. This package is one row against the `sql` point, and the seat
+finds it exactly as it finds a package written by somebody else: through the
+`metta.extensions` entry point, loaded at the first dispatch that has no answer
+without it, or through `import metta_sqlite`, whose module body registers the same
+rows.
+
+```sh
+pip install metta-sqlite          # or: pip install 'pymetta[sql]'
+```
+
+Its tests are in `tests/`, and they run in the workspace suite:
+
+```sh
+sh extensions/python/test.sh ext/metta-sqlite
+```

metta_sqlite-0.9.2/README.md

@@ -0,0 +1,19 @@
+# metta-sqlite
+
+sqlite3 as a SQL engine a MeTTa head can be registered into.
+
+`pymetta` names no third-party library. This package is one row against the `sql` point, and the seat
+finds it exactly as it finds a package written by somebody else: through the
+`metta.extensions` entry point, loaded at the first dispatch that has no answer
+without it, or through `import metta_sqlite`, whose module body registers the same
+rows.
+
+```sh
+pip install metta-sqlite          # or: pip install 'pymetta[sql]'
+```
+
+Its tests are in `tests/`, and they run in the workspace suite:
+
+```sh
+sh extensions/python/test.sh ext/metta-sqlite
+```

metta_sqlite-0.9.2/metta_sqlite.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: metta-sqlite
+Version: 0.9.2
+Summary: sqlite3 as a SQL engine a MeTTa head can be registered into
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pymetta==0.9.2
+
+# metta-sqlite
+
+sqlite3 as a SQL engine a MeTTa head can be registered into.
+
+`pymetta` names no third-party library. This package is one row against the `sql` point, and the seat
+finds it exactly as it finds a package written by somebody else: through the
+`metta.extensions` entry point, loaded at the first dispatch that has no answer
+without it, or through `import metta_sqlite`, whose module body registers the same
+rows.
+
+```sh
+pip install metta-sqlite          # or: pip install 'pymetta[sql]'
+```
+
+Its tests are in `tests/`, and they run in the workspace suite:
+
+```sh
+sh extensions/python/test.sh ext/metta-sqlite
+```

metta_sqlite-0.9.2/metta_sqlite.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+metta_sqlite.py
+pyproject.toml
+metta_sqlite.egg-info/PKG-INFO
+metta_sqlite.egg-info/SOURCES.txt
+metta_sqlite.egg-info/dependency_links.txt
+metta_sqlite.egg-info/entry_points.txt
+metta_sqlite.egg-info/requires.txt
+metta_sqlite.egg-info/top_level.txt
+tests/test_sqlite.py

metta_sqlite-0.9.2/metta_sqlite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

metta_sqlite-0.9.2/metta_sqlite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[metta.extensions]
+metta-sqlite = metta_sqlite

metta_sqlite-0.9.2/metta_sqlite.egg-info/requires.txt

@@ -0,0 +1 @@
+pymetta==0.9.2

metta_sqlite-0.9.2/metta_sqlite.egg-info/top_level.txt

@@ -0,0 +1 @@
+metta_sqlite

metta_sqlite-0.9.2/metta_sqlite.py

@@ -0,0 +1,52 @@
+"""Purpose: sqlite3 as a SQL engine of the MeTTa Python seat, in one row.
+
+A MeTTa head registered into a sqlite3 connection becomes a scalar SQL
+function, so a query can call a definition the space holds. One row against
+the seat's `sql` point; pymetta names no engine.
+
+sqlite3 is the standard library, so this distribution depends on nothing but
+pymetta. It is still a distribution and not a shipped row, because "in the
+standard library" is not a reason for the core to know a SQL engine: the second
+engine of the class has to reach the same door the first did, and a row that
+lived in the core would be the branch a fork starts from.
+
+Assumes:
+  - sqlite3 wants an ARITY and no types, which is why an undeclared head
+    registers here where DuckDB refuses one
+Guarantees:
+  - a head with no declared arrow still registers, taking its argument count
+    from the signature [tested: tests/test_sqlite.py; commit=94057a0f073c0fab0a35c42beff2c324d8a0addd]
+  - a connection of any other engine is declined, so the next row is consulted
+    [tested: tests/test_sqlite.py::test_a_foreign_connection_is_declined;
+    commit=94057a0f073c0fab0a35c42beff2c324d8a0addd]
+Open Obligations:
+  To Do: None
+  Hacks: None
+  Future Enhancements: None
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Any
+
+from metta import seam
+
+
+def _claims(connection: Any) -> Any:
+    """sqlite3's own connection type, which is in the standard library."""
+    return connection if isinstance(connection, sqlite3.Connection) else None
+
+
+def _define(connection: Any, name: str, call: Any, head: Any, signature: Any) -> None:
+    """sqlite3 wants the arity and no types, so an undeclared head registers."""
+    del head
+    connection.create_function(name, seam.sql_arity(signature), call)
+
+
+def register() -> None:
+    """This package's one row, against the seat's `sql` point."""
+    seam.sql.register("sqlite3", claims=_claims, define=_define)
+
+
+register()

metta_sqlite-0.9.2/pyproject.toml

@@ -0,0 +1,39 @@
+# Purpose: package metta-sqlite, one distribution for one library.
+# Assumes: pymetta of the same version is installed; this is a workspace member
+#   released with it and pinned to it exactly.
+# Guarantees: importing metta_sqlite registers this package's rows, and so does the
+#   `metta.extensions` entry point below when a dispatch discovers it.
+# Decides: the dependency set is this library and nothing else, which is what
+#   makes "the core names no library" hold without an allowlist.
+[build-system]
+requires = ["setuptools>=83"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "metta-sqlite"
+version = "0.9.2"
+description = "sqlite3 as a SQL engine a MeTTa head can be registered into"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+dependencies = [
+    #: pymetta of exactly this version. A member is released with the core and
+    #: reads its seam, so a floating pin would let a row meet a seam that no
+    #: longer declares its point.
+    "pymetta==0.9.2",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Science/Research",
+]
+
+#: How a seat that never heard of this package finds it: one entry in the
+#: group `metta.seam` reads, loaded at the first dispatch that has no answer
+#: without it. The target is the MODULE, whose body registers on import, which
+#: is the same door `import metta_sqlite` opens.
+[project.entry-points."metta.extensions"]
+metta-sqlite = "metta_sqlite"
+
+[tool.setuptools]
+py-modules = ["metta_sqlite"]

metta_sqlite-0.9.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

metta_sqlite-0.9.2/tests/test_sqlite.py

@@ -0,0 +1,46 @@
+"""Purpose: prove the sqlite3 row registers a MeTTa head as a SQL function.
+
+Blackbox through `metta.tables.sql_function`, which is the door a program
+takes; this package's row is what makes a sqlite3 connection one the seat
+recognises.
+Open Obligations:
+  To Do: None
+  Hacks: None
+  Future Enhancements: None
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+import metta_sqlite  # noqa: F401  -- imported for the sql row it registers
+
+from metta import seam, tables
+
+
+def test_the_row_is_registered_against_the_sql_point():
+    """One row, named for the engine, carrying claims and define."""
+    row = seam.sql.find("sqlite3")
+    assert row is not None
+    assert not row.fallback
+
+
+def test_an_undeclared_head_registers_by_its_arity(scratch_space):
+    """sqlite3 wants the arity and no types, so no arrow is needed."""
+    scratch_space.run("(= (dbl $x) (* 2 $x))")
+    connection = sqlite3.connect(":memory:")
+    try:
+        assert tables.sql_function(connection, scratch_space.fn.dbl) == "dbl"
+        assert connection.execute("select dbl(21)").fetchone() == (42,)
+    finally:
+        connection.close()
+
+
+def test_a_foreign_connection_is_declined(scratch_space):
+    """A connection this engine does not own leaves the next row to answer."""
+    scratch_space.run("(= (dbl $x) (* 2 $x))")
+
+    class SqliteProbeConnection:
+        """Not a connection any registered engine claims."""
+
+    assert seam.sql.claim(SqliteProbeConnection()) is None