sa-values 0.1.0__tar.gz

sa_values-0.1.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: sa-values
+Version: 0.1.0
+Summary: Storing key-value pairs in database powered by SQLAlchemy.
+License-Expression: MIT
+Keywords: sqlalchemy,key-value,database,configuration
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: sa-values[test]; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+[![Tests](https://github.com/elmordo/sa-values/actions/workflows/tests.yml/badge.svg)](https://github.com/elmordo/sa-values/actions/workflows/tests.yml)
+
+The `sa-values` (SQLAlchemy values) is designed as light-weight library for storing key-value pairs in database.
+
+# Installation
+
+```shell
+pip install sa-values
+```
+
+# Quick start
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+
+sa_vals = SaValues(conn)
+sa_vals.set("key", "value")
+print("Stored value: ", sa_vals.get("key"))
+```
+
+# Supported DBs
+
+The only officially supported database system is `sqlite`. Other DB systems should work too (experimentally tested on
+PostgreSQL), but use it at your own risk.
+
+# Usage
+
+The `sa-values` is based on SQLAlchemy and provides a simple interface for storing and retrieving key-value pairs in a
+database.
+
+## Initialization
+
+The `sa-values` use a single table to store all data. Default table name is `sa_values`. Before any operation is
+performed, the initialization should be done.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+```
+
+The `setup_sa_values` function accepts the second, optional, parameter `value_table_name`. This can be used to specify a
+different table name for storing key-value pairs.
+
+## Single values
+
+When using single values, each key can be stored only once. When setting an exising key, the original value is
+overridden.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+if not values.has("some_value"):
+    print("Some_value is not stored")
+values.set("some_value", "123")
+if values.has("some_value"):
+    print("Some_value is stored")
+    print("The value is: ", values.get("some_value"))
+values.set("some_value", "456")
+print("New value is: ", values.get("some_value"))
+
+values.delete("some_value")
+if not values.has("some_value"):
+    print("Some_value is not stored anymore")
+
+```
+
+## Multiple values
+
+If you want to manage key with more than one value, you can use the `SaValues::multi_value_key(key)`. The method returns
+an object for the multi-value key management. Each value must be unique. In case of duplicate values, the second and
+following values are ignored.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+multi_key = values.multi_value_key("multi_key")
+
+multi_key.add("value1")
+multi_key.add("value2")
+multi_key.add("value2")  # do nothing - each value can be stored only once
+multi_key.add("value3")
+
+print("Values: ", multi_key.get_all())  # ["value1", "value2", "value3"]
+
+multi_key.delete("value2")
+
+print("Values: ", multi_key.get())  # ["value1", "value3"]
+
+print("value1 exists: ", multi_key.has("value1"))  # true
+print("value10 exists: ", multi_key.has("value10"))  # false
+
+multi_key.clear()  # clear all
+```
+
+## Teardown
+
+When the `sa-values` is not needed anymore, it can be tear downed by calling the `teardown_sa_values`
+
+```python
+from sqlalchemy import create_engine
+from sa_values import SaValues, teardown_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+teardown_sa_values(conn)
+```
+
+# Buy me a ~~coffee~~ beer
+
+If you like this library, or you want to support its development, support me by one
+cold [beer](https://www.buymeacoffee.com/elmordo). The beer is tasty and full of vitamins :-)

sa_values-0.1.0/README.md

@@ -0,0 +1,132 @@
+[![Tests](https://github.com/elmordo/sa-values/actions/workflows/tests.yml/badge.svg)](https://github.com/elmordo/sa-values/actions/workflows/tests.yml)
+
+The `sa-values` (SQLAlchemy values) is designed as light-weight library for storing key-value pairs in database.
+
+# Installation
+
+```shell
+pip install sa-values
+```
+
+# Quick start
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+
+sa_vals = SaValues(conn)
+sa_vals.set("key", "value")
+print("Stored value: ", sa_vals.get("key"))
+```
+
+# Supported DBs
+
+The only officially supported database system is `sqlite`. Other DB systems should work too (experimentally tested on
+PostgreSQL), but use it at your own risk.
+
+# Usage
+
+The `sa-values` is based on SQLAlchemy and provides a simple interface for storing and retrieving key-value pairs in a
+database.
+
+## Initialization
+
+The `sa-values` use a single table to store all data. Default table name is `sa_values`. Before any operation is
+performed, the initialization should be done.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+```
+
+The `setup_sa_values` function accepts the second, optional, parameter `value_table_name`. This can be used to specify a
+different table name for storing key-value pairs.
+
+## Single values
+
+When using single values, each key can be stored only once. When setting an exising key, the original value is
+overridden.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+if not values.has("some_value"):
+    print("Some_value is not stored")
+values.set("some_value", "123")
+if values.has("some_value"):
+    print("Some_value is stored")
+    print("The value is: ", values.get("some_value"))
+values.set("some_value", "456")
+print("New value is: ", values.get("some_value"))
+
+values.delete("some_value")
+if not values.has("some_value"):
+    print("Some_value is not stored anymore")
+
+```
+
+## Multiple values
+
+If you want to manage key with more than one value, you can use the `SaValues::multi_value_key(key)`. The method returns
+an object for the multi-value key management. Each value must be unique. In case of duplicate values, the second and
+following values are ignored.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+multi_key = values.multi_value_key("multi_key")
+
+multi_key.add("value1")
+multi_key.add("value2")
+multi_key.add("value2")  # do nothing - each value can be stored only once
+multi_key.add("value3")
+
+print("Values: ", multi_key.get_all())  # ["value1", "value2", "value3"]
+
+multi_key.delete("value2")
+
+print("Values: ", multi_key.get())  # ["value1", "value3"]
+
+print("value1 exists: ", multi_key.has("value1"))  # true
+print("value10 exists: ", multi_key.has("value10"))  # false
+
+multi_key.clear()  # clear all
+```
+
+## Teardown
+
+When the `sa-values` is not needed anymore, it can be tear downed by calling the `teardown_sa_values`
+
+```python
+from sqlalchemy import create_engine
+from sa_values import SaValues, teardown_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+teardown_sa_values(conn)
+```
+
+# Buy me a ~~coffee~~ beer
+
+If you like this library, or you want to support its development, support me by one
+cold [beer](https://www.buymeacoffee.com/elmordo). The beer is tasty and full of vitamins :-)

sa_values-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sa-values"
+version = "0.1.0"
+description = "Storing key-value pairs in database powered by SQLAlchemy."
+readme = "README.md"
+keywords = ["sqlalchemy", "key-value", "database", "configuration"]
+license = "MIT"
+requires-python = ">=3.12"
+dependencies = [
+  "sqlalchemy",
+]
+
+[project.optional-dependencies]
+test = [
+  "pytest",
+]
+dev = [
+  "sa-values[test]",
+  "build",
+  "twine",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = true
+order-by-type = false
+lines-after-imports = 2
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true

sa_values-0.1.0/setup.cfg

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

sa_values-0.1.0/src/sa_values/__init__.py

@@ -0,0 +1,32 @@
+# MIT License
+#
+# Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+from __future__ import annotations
+
+from .setup import setup_sa_values, teardown_sa_values
+from .values import SaValues
+
+
+__all__ = [
+    "SaValues",
+    "setup_sa_values",
+    "teardown_sa_values",
+]

sa_values-0.1.0/src/sa_values/setup.py

@@ -0,0 +1,66 @@
+# MIT License
+#
+# Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+from __future__ import annotations
+
+from sqlalchemy import Connection
+from sqlalchemy.sql.ddl import CreateTable, DropTable
+
+from sa_values.table import setup_value_table
+
+from .table import get_value_table
+from .values import SaValues
+
+
+_TABLE_VERSION = 1
+
+
+def setup_sa_values(
+    connection: Connection, value_table_name: str | None = None
+) -> None:
+    if value_table_name is not None:
+        setup_value_table(value_table_name)
+
+    _create_table(connection)
+
+    values = SaValues(connection)
+    values._allow_empty = True
+
+    if not values.has(""):
+        values.set("", str(_TABLE_VERSION))
+    else:
+        current_version = int(values.get(""))
+        if current_version != _TABLE_VERSION:
+            raise ValueError(f"Invalid table version: {current_version}")
+
+
+def teardown_sa_values(connection: Connection) -> None:
+    _drop_table(connection)
+
+
+def _create_table(connection: Connection) -> None:
+    create_stmt = CreateTable(get_value_table(), if_not_exists=True)
+    connection.execute(create_stmt)
+
+
+def _drop_table(connection: Connection) -> None:
+    stmt = DropTable(get_value_table(), if_exists=True)
+    connection.execute(stmt)

sa_values-0.1.0/src/sa_values/table.py

@@ -0,0 +1,56 @@
+# MIT License
+#
+# Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+from sqlalchemy import Column, Integer, MetaData, String, Table
+
+
+_metadata = MetaData()
+
+_value_table = None
+
+
+def get_value_table() -> Table:
+    """Get the value table. If the table instance does not exists, create it"""
+    global _value_table
+
+    if _value_table is None:
+        _value_table = _create_value_table()
+    return _value_table
+
+
+def setup_value_table(table_name: str = "sa_values") -> None:
+    """Create the value table with the given name"""
+    global _value_table
+    _value_table = _create_value_table(table_name)
+
+
+def _create_value_table(table_name: str = "sa_values") -> Table:
+    """Create and return the value table with the given name."""
+    if (existing_table := _metadata.tables.get(table_name)) is not None:
+        return existing_table
+
+    return Table(
+        table_name,
+        _metadata,
+        Column("id", Integer, primary_key=True),
+        Column("name", String, nullable=False),
+        Column("value", String, nullable=False),
+    )

sa_values-0.1.0/src/sa_values/values.py

@@ -0,0 +1,178 @@
+# MIT License
+#
+# Copyright (c) [YEAR] [COPYRIGHT HOLDER]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+from __future__ import annotations
+
+from typing import Iterator
+
+from sqlalchemy import Connection, delete, insert, select, Table, update
+
+from .table import get_value_table
+
+
+class SaValues:
+    """
+    Features:
+
+    * manage single value keys (get, set, has, delete)
+    * manage multi-value keys. The multi-value accessor is provided by calling `multi_value_key` method.
+
+    The multi-value keys interface is provided by the `MultiValueKey` class.
+
+    Mutations flush the session; the caller owns the transaction. Keys and values
+    are strings, including empty strings.
+    """
+
+    def __init__(self, connection: Connection):
+        self.connection: Connection = connection
+        self._value_table = get_value_table()
+        self._allow_empty = False
+
+    def get(self, key: str) -> str | None:
+        """Return the oldest value by row ID, or None if the key is absent."""
+        stmt = (
+            select(self._value_table.c.value)
+            .where(self._value_table.c.name == key)
+            .order_by(self._value_table.c.id)
+            .limit(1)
+        )
+        return self.connection.scalar(stmt)
+
+    def get_keys(self) -> list[str]:
+        """Return all keys."""
+        stmt = (
+            select(self._value_table.c.name)
+            .distinct()
+            .order_by(self._value_table.c.name)
+        )
+        return list(self.connection.scalars(stmt))
+
+    def set(self, key: str, value: str) -> None:
+        """Store exactly one value for the key, replacing any existing values."""
+        if not key and not self._allow_empty:
+            raise ValueError("key must be non-empty")
+        stmt = (
+            select(self._value_table.c.id)
+            .where(self._value_table.c.name == key)
+            .order_by(self._value_table.c.id)
+        )
+        item_ids = list(self.connection.scalars(stmt))
+        if item_ids:
+            self.connection.execute(
+                update(self._value_table)
+                .where(self._value_table.c.id == item_ids[0])
+                .values(value=value),
+            )
+            if len(item_ids) > 1:
+                self.connection.execute(
+                    delete(self._value_table).where(
+                        self._value_table.c.id.in_(item_ids[1:])
+                    ),
+                )
+        else:
+            self.connection.execute(
+                insert(self._value_table).values(name=key, value=value)
+            )
+
+    def has(self, key: str) -> bool:
+        """Return whether the key has any stored values."""
+        return self.get(key) is not None
+
+    def delete(self, key: str) -> None:
+        """Remove all values for the key; missing keys are ignored."""
+        self.multi_value_key(key).clear()
+
+    def multi_value_key(self, key: str) -> MultiValueKey:
+        """Return an accessor sharing this session, without creating any rows."""
+        return MultiValueKey(self.connection, self._value_table, key)
+
+
+class MultiValueKey:
+    """Access to multi-value configuration keys.
+
+    Features:
+
+    * iterate over values
+    * clear all values
+    * get all values
+    * manage values (get, set, has, delete)
+
+    Repeated set calls store each value only once for the key. This does not
+    guarantee uniqueness across concurrent writers. Reads return distinct values
+    in oldest-row order. Mutations flush, leaving transaction control to the caller.
+    """
+
+    def __init__(self, connection: Connection, value_table: Table, key: str):
+        if not key:
+            raise ValueError("key must be non-empty")
+        self.connection = connection
+        self.key = key
+        self._value_table = value_table
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.get_all())
+
+    def get_all(self) -> list[str]:
+        """Return distinct values in oldest-row order, or an empty list."""
+        stmt = (
+            select(self._value_table.c.value)
+            .where(self._value_table.c.name == self.key)
+            .order_by(self._value_table.c.id)
+        )
+        return list(dict.fromkeys(self.connection.scalars(stmt)))
+
+    def get(self, value: str) -> str | None:
+        """Return the matching string, or None if it is absent."""
+        stmt = (
+            select(self._value_table.c.value)
+            .where(
+                self._value_table.c.name == self.key,
+                self._value_table.c.value == value,
+            )
+            .limit(1)
+        )
+        return self.connection.scalar(stmt)
+
+    def has(self, value: str) -> bool:
+        """Return whether this key contains the value."""
+        return self.get(value) is not None
+
+    def add(self, value: str) -> None:
+        """Add the value if absent, leaving other values intact."""
+        if not self.has(value):
+            self.connection.execute(
+                insert(self._value_table).values(name=self.key, value=value)
+            )
+
+    def delete(self, value: str) -> None:
+        """Remove every matching row; missing values are ignored."""
+        self.connection.execute(
+            delete(self._value_table).where(
+                self._value_table.c.name == self.key,
+                self._value_table.c.value == value,
+            ),
+        )
+
+    def clear(self) -> None:
+        """Remove all values for this key; missing keys are ignored."""
+        self.connection.execute(
+            delete(self._value_table).where(self._value_table.c.name == self.key)
+        )

sa_values-0.1.0/src/sa_values.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: sa-values
+Version: 0.1.0
+Summary: Storing key-value pairs in database powered by SQLAlchemy.
+License-Expression: MIT
+Keywords: sqlalchemy,key-value,database,configuration
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: sqlalchemy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dev
+Requires-Dist: sa-values[test]; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+[![Tests](https://github.com/elmordo/sa-values/actions/workflows/tests.yml/badge.svg)](https://github.com/elmordo/sa-values/actions/workflows/tests.yml)
+
+The `sa-values` (SQLAlchemy values) is designed as light-weight library for storing key-value pairs in database.
+
+# Installation
+
+```shell
+pip install sa-values
+```
+
+# Quick start
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+
+sa_vals = SaValues(conn)
+sa_vals.set("key", "value")
+print("Stored value: ", sa_vals.get("key"))
+```
+
+# Supported DBs
+
+The only officially supported database system is `sqlite`. Other DB systems should work too (experimentally tested on
+PostgreSQL), but use it at your own risk.
+
+# Usage
+
+The `sa-values` is based on SQLAlchemy and provides a simple interface for storing and retrieving key-value pairs in a
+database.
+
+## Initialization
+
+The `sa-values` use a single table to store all data. Default table name is `sa_values`. Before any operation is
+performed, the initialization should be done.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+```
+
+The `setup_sa_values` function accepts the second, optional, parameter `value_table_name`. This can be used to specify a
+different table name for storing key-value pairs.
+
+## Single values
+
+When using single values, each key can be stored only once. When setting an exising key, the original value is
+overridden.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+if not values.has("some_value"):
+    print("Some_value is not stored")
+values.set("some_value", "123")
+if values.has("some_value"):
+    print("Some_value is stored")
+    print("The value is: ", values.get("some_value"))
+values.set("some_value", "456")
+print("New value is: ", values.get("some_value"))
+
+values.delete("some_value")
+if not values.has("some_value"):
+    print("Some_value is not stored anymore")
+
+```
+
+## Multiple values
+
+If you want to manage key with more than one value, you can use the `SaValues::multi_value_key(key)`. The method returns
+an object for the multi-value key management. Each value must be unique. In case of duplicate values, the second and
+following values are ignored.
+
+```python
+from sqlalchemy import create_engine
+from sa_values import setup_sa_values, SaValues
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+setup_sa_values(conn)
+values = SaValues(conn)
+
+multi_key = values.multi_value_key("multi_key")
+
+multi_key.add("value1")
+multi_key.add("value2")
+multi_key.add("value2")  # do nothing - each value can be stored only once
+multi_key.add("value3")
+
+print("Values: ", multi_key.get_all())  # ["value1", "value2", "value3"]
+
+multi_key.delete("value2")
+
+print("Values: ", multi_key.get())  # ["value1", "value3"]
+
+print("value1 exists: ", multi_key.has("value1"))  # true
+print("value10 exists: ", multi_key.has("value10"))  # false
+
+multi_key.clear()  # clear all
+```
+
+## Teardown
+
+When the `sa-values` is not needed anymore, it can be tear downed by calling the `teardown_sa_values`
+
+```python
+from sqlalchemy import create_engine
+from sa_values import SaValues, teardown_sa_values
+
+# connect to db and setup sa-values
+conn = create_engine("sqlite:///:memory:").connect()
+teardown_sa_values(conn)
+```
+
+# Buy me a ~~coffee~~ beer
+
+If you like this library, or you want to support its development, support me by one
+cold [beer](https://www.buymeacoffee.com/elmordo). The beer is tasty and full of vitamins :-)

sa_values-0.1.0/src/sa_values.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/sa_values/__init__.py
+src/sa_values/setup.py
+src/sa_values/table.py
+src/sa_values/values.py
+src/sa_values.egg-info/PKG-INFO
+src/sa_values.egg-info/SOURCES.txt
+src/sa_values.egg-info/dependency_links.txt
+src/sa_values.egg-info/requires.txt
+src/sa_values.egg-info/top_level.txt

sa_values-0.1.0/src/sa_values.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sa_values-0.1.0/src/sa_values.egg-info/requires.txt

@@ -0,0 +1,9 @@
+sqlalchemy
+
+[dev]
+sa-values[test]
+build
+twine
+
+[test]
+pytest

sa_values-0.1.0/src/sa_values.egg-info/top_level.txt

@@ -0,0 +1 @@
+sa_values