socketmap-sql 0.2.0__tar.gz → 0.2.1__tar.gz

{socketmap-sql-0.2.0 → socketmap_sql-0.2.1}/PKG-INFO

@@ -1,18 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: socketmap-sql
-Version: 0.2.0
+Version: 0.2.1
 Summary: An implementation of the sendmail socketmap protocol to allow an SQL database
 Author-email: Keith Gaughan <k@stereochro.me>
-Requires-Python: >=3.8
+Requires-Python: >=3.12
 Description-Content-Type: text/x-rst
+License-Expression: MIT
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Communications :: Email :: Mail Transport Agents
 Classifier: Topic :: Database
+License-File: LICENSE
 Project-URL: Source, https://github.com/kgaughan/socketmap-sql
 
 =============

socketmap_sql-0.2.1/pyproject.toml

@@ -0,0 +1,104 @@
+#:schema https://json.schemastore.org/pyproject.json
+
+[build-system]
+requires = ["flit_core >=3.12.0,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "socketmap-sql"
+authors = [{ name = "Keith Gaughan", email = "k@stereochro.me" }]
+readme = "README.rst"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: System Administrators",
+  "Operating System :: POSIX",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Communications :: Email :: Mail Transport Agents",
+  "Topic :: Database",
+]
+dynamic = ["version", "description"]
+
+[project.urls]
+Source = "https://github.com/kgaughan/socketmap-sql"
+
+[project.scripts]
+socketmap-sql = "socketmapsql:main"
+
+[tool.flit.module]
+name = "socketmapsql"
+
+[dependency-groups]
+dev = [
+  "mypy>=1.10.1",
+]
+
+[tool.mypy]
+ignore_missing_imports = true
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+  "A",
+  # "ANN",
+  "ARG",
+  "B",
+  "C",
+  "DTZ",
+  "E",
+  "EM",
+  "EXE",
+  "F",
+  "FBT",
+  "FLY",
+  "FURB",
+  "G",
+  "I",
+  "ICN",
+  "ISC002",
+  "LOG",
+  "N",
+  "PERF",
+  "PIE",
+  "PLC",
+  "PLE",
+  "PLR",
+  "PLW",
+  # "PT",
+  "PYI",
+  "Q",
+  "RET",
+  "RSE",
+  "RUF",
+  "S",
+  "SIM",
+  "SLOT",
+  "T",
+  "TC",
+  "TID",
+  "TRY",
+  "UP",
+  "W",
+  "YTT",
+]
+ignore = [
+  "EM102",   # Exception must not use an f-string literal, assign to variable first
+  "PLR0913", # Too many arguments in function definition
+  "T201",    # `print` found
+  "TRY003",  # Avoid specifying long messages outside the exception class
+]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = true
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"

{socketmap-sql-0.2.0 → socketmap_sql-0.2.1}/socketmapsql.py

@@ -9,19 +9,17 @@ import configparser
 import contextlib
 import dataclasses
 import importlib
-import io
 import os.path
 import re
 import select
 import subprocess
 import sys
-from typing import Callable, Dict, List, Mapping, Optional, Tuple, TypedDict
+import typing as t
 
+__version__: str = "0.2.1"
 
-__version__ = "0.2.0"
 
-
-Transform = Callable[[str, Mapping[str, str]], List[str]]
+Transform = t.Callable[[str, t.Mapping[str, str]], list[str]]
 
 
 @dataclasses.dataclass
@@ -30,10 +28,10 @@ class TableCfg:
     transform: Transform
 
 
-class Cfg(TypedDict):
-    database: Dict[str, str]
-    misc: Dict[str, str]
-    tables: Dict[str, TableCfg]
+class Cfg(t.TypedDict):
+    database: dict[str, str]
+    misc: dict[str, str]
+    tables: dict[str, TableCfg]
 
 
 FUNC_REF_PATTERN = re.compile(
@@ -44,18 +42,18 @@ FUNC_REF_PATTERN = re.compile(
     (?P<object>[a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)*)
     $
     """,
-    re.I | re.X,
+    re.IGNORECASE | re.VERBOSE,
 )
 
 
-def match(name: str) -> Tuple[str, str]:
+def match(name: str) -> tuple[str, str]:
     matches = FUNC_REF_PATTERN.match(name)
     if not matches:
         raise ValueError(f"Malformed callable '{name}'")
     return matches.group("module"), matches.group("object")
 
 
-def resolve(module_name: str, obj_name: str) -> Callable:
+def resolve(module_name: str, obj_name: str) -> t.Callable:
     """
     Resolve a named object in a module.
     """
@@ -66,10 +64,8 @@ class MalformedNetstringError(Exception):
     pass
 
 
-def read_netstring(fp: io.TextIOWrapper) -> Optional[str]:
-    """
-    Reads a single netstring.
-    """
+def read_netstring(fp: t.IO[str]) -> str | None:
+    """Reads a single netstring."""
     ns = ""
     while True:
         c = fp.read(1)
@@ -77,7 +73,7 @@ def read_netstring(fp: io.TextIOWrapper) -> Optional[str]:
             return None
         if c == ":":
             break
-        if len(ns) > 10:
+        if len(ns) > 10:  # noqa: PLR2004
             raise MalformedNetstringError
         if c == "0" and ns == "":
             # We can't allow leading zeros.
@@ -99,31 +95,31 @@ def read_netstring(fp: io.TextIOWrapper) -> Optional[str]:
     return result
 
 
-def write_netstring(fp: io.TextIOWrapper, response: str):
+def write_netstring(fp: t.IO[str], response: str) -> None:
     fp.write(f"{len(response)}:{response},")
     fp.flush()
 
 
-def process_local(local_part: str, cfg: Mapping[str, str]) -> str:
+def process_local(local_part: str, cfg: t.Mapping[str, str]) -> str:
     delimiter = cfg.get("recipient_delimiter", "").strip()
     if delimiter != "":
         local_part = local_part.split(delimiter, 1)[0]
     return local_part.lower()
 
 
-def split(arg: str, cfg: Mapping[str, str]) -> List[str]:
+def split(arg: str, cfg: t.Mapping[str, str]) -> list[str]:
     parts = arg.split("@", 1)
     parts[0] = process_local(parts[0], cfg)
     parts[1] = parts[1].lower()
     return parts
 
 
-def parse_config(fp: io.TextIOWrapper) -> Cfg:
+def parse_config(fp: t.IO[str]) -> Cfg:
     transforms = {
-        "all": lambda arg, cfg: [arg],
-        "lowercase": lambda arg, cfg: [arg.lower()],
+        "all": lambda arg, _: [arg],
+        "lowercase": lambda arg, _: [arg.lower()],
         "local": lambda arg, cfg: [process_local(arg.split("@", 1)[0], cfg)],
-        "domain": lambda arg, cfg: [arg.split("@", 1)[1].lower()],
+        "domain": lambda arg, _: [arg.split("@", 1)[1].lower()],
         "split": split,
     }
 
@@ -157,18 +153,18 @@ def parse_config(fp: io.TextIOWrapper) -> Cfg:
     )
 
 
-def get_int(cfg: Mapping[str, str], key: str) -> Optional[int]:
+def get_int(cfg: t.Mapping[str, str], key: str) -> int | None:
     return int(cfg[key]) if key in cfg else None
 
 
 def serve_client(
-    fh_in: io.TextIOWrapper,
-    fh_out: io.TextIOWrapper,
+    fh_in: t.IO[str],
+    fh_out: t.IO[str],
     conn,
     timeout: int,
-    tables: Mapping[str, TableCfg],
-    cfg: Mapping[str, str],
-):
+    tables: t.Mapping[str, TableCfg],
+    cfg: t.Mapping[str, str],
+) -> None:
     max_requests = get_int(cfg, "max_requests")
     try:
         while True:
@@ -203,17 +199,15 @@ def serve_client(
             if result is None:
                 write_netstring(fh_out, "NOTFOUND ")
             else:
-                write_netstring(fh_out, f"OK {str(result[0])}")
+                write_netstring(fh_out, f"OK {result[0]!s}")
     except MalformedNetstringError:
         write_netstring(fh_out, "PERM malformed netstring")
     except Exception as exc:
-        write_netstring(fh_out, f"PERM {str(exc)}")
+        write_netstring(fh_out, f"PERM {exc!s}")
 
 
-def connect(settings: Dict[str, str]):
-    """
-    Connect to a database.
-    """
+def connect(settings: dict[str, str]):
+    """Connect to a database."""
     driver = importlib.import_module(settings.pop("driver", "sqlite3"))
     return driver.connect(**settings)
 
@@ -240,7 +234,7 @@ def make_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def main():
+def main() -> int:
     args = make_parser().parse_args()
 
     with contextlib.closing(args.config):
@@ -261,8 +255,9 @@ def main():
             if req == ".exit":
                 proc.terminate()
                 break
-            write_netstring(proc.stdin, req)
-            print(read_netstring(proc.stdout))
+            if proc.stdin is not None and proc.stdout is not None:
+                write_netstring(proc.stdin, req)
+                print(read_netstring(proc.stdout))
     else:
         with contextlib.closing(connect(cfg["database"])) as conn:
             serve_client(

socketmap-sql-0.2.0/.gitignore

@@ -1,103 +0,0 @@
-.*.sw?
-
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-env/
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# pyenv
-.python-version
-
-# celery beat schedule file
-celerybeat-schedule
-
-# SageMath parsed files
-*.sage.py
-
-# dotenv
-.env
-
-# virtualenv
-.venv
-venv/
-ENV/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/

socketmap-sql-0.2.0/Makefile

@@ -1,14 +0,0 @@
-.venv:
-	python3 -m venv .venv
-
-dev: .venv
-	.venv/bin/pip install flit
-	.venv/bin/flit install --symlink
-
-wheel: dev
-	.venv/bin/flit build
-
-release: wheel
-	.venv/bin/flit publish
-
-.PHONY: dev wheel release

socketmap-sql-0.2.0/examples/format.ini

@@ -1,13 +0,0 @@
-[database]
-; Path of SQLite database to use
-database = /path/to/sqlite.db
-
-[table:foo]
-; Function to call to transform the argument in a suitable manner.
-transform = name.of.module:name_of_function
-; Query to run. ? is the parameter in the prepared statement after it's gone
-; through the transform function.
-query =
-   SELECT bar
-   FROM   foo
-   WHERE  baz = ?

socketmap-sql-0.2.0/pyproject.toml

@@ -1,31 +0,0 @@
-[build-system]
-requires = ["flit_core >=3.2,<4"]
-build-backend = "flit_core.buildapi"
-
-[project]
-name = "socketmap-sql"
-authors = [
-	{name = "Keith Gaughan", email = "k@stereochro.me"},
-]
-readme = "README.rst"
-requires-python = ">=3.8"
-classifiers = [
-	"Development Status :: 4 - Beta",
-	"Intended Audience :: System Administrators",
-	"License :: OSI Approved :: MIT License",
-	"Operating System :: POSIX",
-	"Programming Language :: Python :: 3",
-	"Programming Language :: Python :: 3 :: Only",
-	"Topic :: Communications :: Email :: Mail Transport Agents",
-	"Topic :: Database",
-]
-dynamic = ["version", "description"]
-
-[project.urls]
-Source = "https://github.com/kgaughan/socketmap-sql"
-
-[project.scripts]
-socketmap-sql = "socketmapsql:main"
-
-[tool.flit.module]
-name = "socketmapsql"