lumenrag 0.1.2__tar.gz

lumenrag-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 brma-tech
+
+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.

lumenrag-0.1.2/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: lumenrag
+Version: 0.1.2
+Summary: Local-first RAG studio powered by LumenVec
+Author: brma-tech
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/brma-tech/lumenrag
+Project-URL: Repository, https://github.com/brma-tech/lumenrag
+Project-URL: Issues, https://github.com/brma-tech/lumenrag/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Requires-Dist: openai<3,>=1.99.0
+Requires-Dist: pypdf>=5.0.0
+Requires-Dist: python-docx>=1.1.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: python-multipart>=0.0.9
+Dynamic: license-file
+
+LumenRAG is a local-first RAG studio powered by LumenVec.

lumenrag-0.1.2/lumenrag/__init__.py

@@ -0,0 +1,3 @@
+"""Public package for the LumenRAG product."""
+
+__version__ = "0.1.2"

lumenrag-0.1.2/lumenrag/__main__.py

@@ -0,0 +1,3 @@
+from lumenrag.cli import main
+
+raise SystemExit(main())

lumenrag-0.1.2/lumenrag/bundled.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import stat
+from functools import lru_cache
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+
+class BundledAssetError(RuntimeError):
+    """Raised when packaged product assets fail integrity validation."""
+
+
+def _assets_root() -> Path | None:
+    candidate = resources.files("lumenrag").joinpath("assets")
+    try:
+        path = Path(os.fspath(candidate))
+    except TypeError:
+        return None
+    return path if path.is_dir() else None
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+@lru_cache(maxsize=1)
+def verified_manifest() -> tuple[Path, dict[str, Any]] | None:
+    assets = _assets_root()
+    if assets is None:
+        return None
+    manifest_path = assets / "manifest.json"
+    if not manifest_path.is_file():
+        raise BundledAssetError("Packaged asset manifest is missing.")
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise BundledAssetError("Packaged asset manifest is invalid.") from exc
+    if manifest.get("schema_version") != 1:
+        raise BundledAssetError("Unsupported packaged asset manifest.")
+    files = manifest.get("files")
+    if not isinstance(files, dict) or not files:
+        raise BundledAssetError("Packaged asset manifest contains no files.")
+    for relative, expected in files.items():
+        if not isinstance(relative, str) or not isinstance(expected, str):
+            raise BundledAssetError("Packaged asset manifest has invalid entries.")
+        path = (assets / relative).resolve()
+        if assets.resolve() not in path.parents or not path.is_file():
+            raise BundledAssetError(f"Packaged asset is missing: {relative}")
+        if _sha256(path) != expected:
+            raise BundledAssetError(f"Packaged asset integrity failed: {relative}")
+    return assets, manifest
+
+
+def bundled_binary() -> Path | None:
+    verified = verified_manifest()
+    if verified is None:
+        return None
+    assets, manifest = verified
+    binary = assets / str(manifest["binary"])
+    if os.name != "nt":
+        binary.chmod(
+            binary.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+        )
+    return binary
+
+
+def bundled_studio() -> Path | None:
+    verified = verified_manifest()
+    if verified is None:
+        return None
+    assets, manifest = verified
+    return assets / Path(str(manifest["studio"])).parent

lumenrag-0.1.2/lumenrag/cli.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from lumenrag import __version__
+from lumenrag.launcher import LauncherError, StartOptions, default_workspace, start
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="lumenrag",
+        description="Local-first RAG studio powered by LumenVec.",
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    start_parser = commands.add_parser("start", help="Start the local RAG studio")
+    start_parser.add_argument("--host", default="127.0.0.1", help="Studio host")
+    start_parser.add_argument("--port", type=int, default=8000, help="Studio port")
+    start_parser.add_argument(
+        "--workspace",
+        type=Path,
+        default=default_workspace(),
+        help="Directory used for local data and logs",
+    )
+    start_parser.add_argument(
+        "--lumenvec-url",
+        default=os.getenv("LUMENVEC_BASE_URL", "http://127.0.0.1:19190"),
+        help="Existing or locally managed LumenVec HTTP endpoint",
+    )
+    start_parser.add_argument(
+        "--lumenvec-binary",
+        type=Path,
+        help="Path to a LumenVec executable",
+    )
+    start_parser.add_argument(
+        "--external-lumenvec",
+        action="store_true",
+        help="Require an already running LumenVec instead of starting one",
+    )
+    start_parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Do not open the Studio in the default browser",
+    )
+    start_parser.add_argument(
+        "--startup-timeout",
+        type=float,
+        default=20.0,
+        help="Seconds to wait for LumenVec startup",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.command != "start":  # pragma: no cover - argparse enforces this
+        return 2
+
+    options = StartOptions(
+        host=args.host,
+        port=args.port,
+        workspace=args.workspace.expanduser().resolve(),
+        lumenvec_url=args.lumenvec_url,
+        lumenvec_binary=args.lumenvec_binary,
+        external_lumenvec=args.external_lumenvec,
+        open_browser=not args.no_browser,
+        startup_timeout=args.startup_timeout,
+    )
+    try:
+        start(options)
+    except LauncherError as exc:
+        print(f"LumenRAG could not start: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+    return 0

lumenrag-0.1.2/lumenrag/launcher.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+import webbrowser
+from collections.abc import Callable
+from contextlib import nullcontext
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+from urllib.parse import urlparse
+
+from lumenrag.bundled import BundledAssetError, bundled_binary, bundled_studio
+
+
+class LauncherError(RuntimeError):
+    """Raised when the local product stack cannot be started safely."""
+
+
+class Process(Protocol):
+    def poll(self) -> int | None: ...
+
+    def wait(self, timeout: float | None = None) -> int: ...
+
+    def terminate(self) -> None: ...
+
+    def kill(self) -> None: ...
+
+    def send_signal(self, sig: int) -> None: ...
+
+
+@dataclass(frozen=True)
+class StartOptions:
+    host: str = "127.0.0.1"
+    port: int = 8000
+    workspace: Path = Path(".lumenrag")
+    lumenvec_url: str = "http://127.0.0.1:19190"
+    lumenvec_binary: Path | None = None
+    external_lumenvec: bool = False
+    open_browser: bool = True
+    startup_timeout: float = 20.0
+
+
+@dataclass
+class ManagedProcess:
+    process: Process
+    use_process_group: bool = False
+
+    def stop(self, timeout: float = 5.0) -> None:
+        if self.process.poll() is not None:
+            return
+        try:
+            if self.use_process_group and os.name == "nt":
+                self.process.send_signal(signal.CTRL_BREAK_EVENT)
+            else:
+                self.process.terminate()
+            self.process.wait(timeout=timeout)
+        except (OSError, subprocess.TimeoutExpired):
+            self.process.kill()
+            self.process.wait(timeout=timeout)
+
+
+def default_workspace() -> Path:
+    override = os.getenv("LUMENRAG_HOME")
+    if override:
+        return Path(override).expanduser()
+    if os.name == "nt":
+        base = Path(os.getenv("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        return base / "LumenRAG"
+    base = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+    return base / "lumenrag"
+
+
+def is_healthy(base_url: str, timeout: float = 1.0) -> bool:
+    health_url = f"{base_url.rstrip('/')}/health"
+    try:
+        with urllib.request.urlopen(health_url, timeout=timeout) as response:
+            return 200 <= response.status < 300
+    except (OSError, urllib.error.URLError, ValueError):
+        return False
+
+
+def is_url_ready(url: str, timeout: float = 1.0) -> bool:
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as response:
+            return 200 <= response.status < 300
+    except (OSError, urllib.error.URLError, ValueError):
+        return False
+
+
+def discover_lumenvec_binary(explicit: Path | None = None) -> Path:
+    configured = explicit or _configured_binary()
+    if configured:
+        candidate = configured.expanduser().resolve()
+        if candidate.is_file():
+            return candidate
+        raise LauncherError(f"LumenVec binary does not exist: {candidate}")
+
+    try:
+        packaged = bundled_binary()
+    except BundledAssetError as exc:
+        raise LauncherError(str(exc)) from exc
+    if packaged is not None:
+        return packaged.resolve()
+
+    names = ["lumenvec.exe", "lumenvec"] if os.name == "nt" else ["lumenvec"]
+    for name in names:
+        found = shutil.which(name)
+        if found:
+            return Path(found).resolve()
+
+    for candidate in _development_binary_candidates():
+        if candidate.is_file():
+            return candidate.resolve()
+
+    raise LauncherError(
+        "LumenVec was not found. Pass --lumenvec-binary, set LUMENVEC_BINARY, "
+        "or add lumenvec to PATH."
+    )
+
+
+def _configured_binary() -> Path | None:
+    raw = os.getenv("LUMENVEC_BINARY", "").strip()
+    return Path(raw) if raw else None
+
+
+def _development_binary_candidates() -> list[Path]:
+    project_root = Path(__file__).resolve().parents[2]
+    database_root = project_root.parents[1] if len(project_root.parents) > 1 else None
+    if database_root is None:
+        return []
+    lumenvec_root = database_root / "lumenvec"
+    platform_pattern = "*windows*http*" if os.name == "nt" else f"*{sys.platform}*"
+    executable = "lumenvec.exe" if os.name == "nt" else "lumenvec"
+    release_candidates = sorted(
+        lumenvec_root.glob(f"dist/release/{platform_pattern}/{executable}"),
+        reverse=True,
+    )
+    direct_candidates = sorted(
+        lumenvec_root.glob(f"dist/lumenvec-*-{sys.platform}-*"), reverse=True
+    )
+    return release_candidates + direct_candidates + [lumenvec_root / executable]
+
+
+def _lumenvec_port(base_url: str) -> int:
+    parsed = urlparse(base_url)
+    local_hosts = {"127.0.0.1", "localhost", "::1"}
+    if parsed.scheme != "http" or parsed.hostname not in local_hosts:
+        raise LauncherError(
+            "A managed LumenVec endpoint must use HTTP on localhost. "
+            "Use --external-lumenvec for remote endpoints."
+        )
+    return parsed.port or 80
+
+
+def lumenvec_environment(workspace: Path, base_url: str) -> dict[str, str]:
+    data_dir = workspace / "lumenvec"
+    vector_dir = data_dir / "vectors"
+    vector_dir.mkdir(parents=True, exist_ok=True)
+    environment = os.environ.copy()
+    environment.update(
+        {
+            "VECTOR_DB_PROTOCOL": "http",
+            "VECTOR_DB_PORT": str(_lumenvec_port(base_url)),
+            "VECTOR_DB_SNAPSHOT_PATH": str(data_dir / "snapshot.json"),
+            "VECTOR_DB_WAL_PATH": str(data_dir / "wal.log"),
+            "VECTOR_DB_VECTOR_PATH": str(vector_dir),
+            "VECTOR_DB_SEARCH_MODE": environment.get("VECTOR_DB_SEARCH_MODE", "ann"),
+        }
+    )
+    return environment
+
+
+def launch_lumenvec(
+    binary: Path,
+    workspace: Path,
+    base_url: str,
+    *,
+    popen: Callable[..., Process] = subprocess.Popen,
+) -> ManagedProcess:
+    log_dir = workspace / "logs"
+    process_dir = workspace / "lumenvec"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    process_dir.mkdir(parents=True, exist_ok=True)
+    creationflags = subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0
+    with (log_dir / "lumenvec.stdout.log").open("ab") as stdout, (
+        log_dir / "lumenvec.stderr.log"
+    ).open("ab") as stderr:
+        process = popen(
+            [str(binary)],
+            cwd=process_dir,
+            env=lumenvec_environment(workspace, base_url),
+            stdout=stdout,
+            stderr=stderr,
+            creationflags=creationflags,
+        )
+    return ManagedProcess(process, use_process_group=os.name == "nt")
+
+
+def wait_until_healthy(
+    base_url: str,
+    process: Process,
+    timeout: float,
+    *,
+    health_check: Callable[[str, float], bool] = is_healthy,
+) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        exit_code = process.poll()
+        if exit_code is not None:
+            raise LauncherError(
+                f"LumenVec exited during startup with code {exit_code}."
+            )
+        if health_check(base_url, 1.0):
+            return
+        time.sleep(0.15)
+    raise LauncherError(f"LumenVec did not become healthy within {timeout:g} seconds.")
+
+
+def ensure_lumenvec(
+    options: StartOptions,
+    *,
+    health_check: Callable[[str, float], bool] = is_healthy,
+    process_launcher: Callable[[Path, Path, str], ManagedProcess] = launch_lumenvec,
+) -> ManagedProcess | None:
+    if health_check(options.lumenvec_url, 1.0):
+        print(f"[ok] Reusing LumenVec at {options.lumenvec_url}")
+        return None
+    if options.external_lumenvec:
+        raise LauncherError(f"LumenVec is not reachable at {options.lumenvec_url}.")
+
+    binary = discover_lumenvec_binary(options.lumenvec_binary)
+    managed = process_launcher(binary, options.workspace, options.lumenvec_url)
+    try:
+        wait_until_healthy(
+            options.lumenvec_url,
+            managed.process,
+            options.startup_timeout,
+            health_check=health_check,
+        )
+    except Exception:
+        managed.stop()
+        raise
+    print(f"[ok] LumenVec started at {options.lumenvec_url}")
+    return managed
+
+
+def _open_browser_when_ready(url: str) -> None:
+    for _ in range(80):
+        if is_url_ready(url, 0.5):
+            webbrowser.open(url)
+            return
+        time.sleep(0.1)
+
+
+def _run_studio(options: StartOptions) -> None:
+    import uvicorn
+
+    server = uvicorn.Server(
+        uvicorn.Config(
+            "rag_lumenvec.api.app:app",
+            host=options.host,
+            port=options.port,
+            log_level="info",
+        )
+    )
+    server.capture_signals = nullcontext
+
+    watched_signals = [signal.SIGINT, signal.SIGTERM]
+    if os.name == "nt" and hasattr(signal, "SIGBREAK"):
+        watched_signals.append(signal.SIGBREAK)
+    previous_handlers: dict[int, object] = {}
+
+    def request_shutdown(_signum: int, _frame: object) -> None:
+        server.should_exit = True
+
+    try:
+        for watched_signal in watched_signals:
+            previous_handlers[watched_signal] = signal.getsignal(watched_signal)
+            signal.signal(watched_signal, request_shutdown)
+        server.run()
+    finally:
+        for watched_signal, previous_handler in previous_handlers.items():
+            signal.signal(watched_signal, previous_handler)
+
+
+def start(options: StartOptions) -> None:
+    if not 1 <= options.port <= 65535:
+        raise LauncherError("Studio port must be between 1 and 65535.")
+    options.workspace.mkdir(parents=True, exist_ok=True)
+    os.environ["LUMENVEC_BASE_URL"] = options.lumenvec_url
+    os.environ["RAG_DATA_DIR"] = str(options.workspace / "rag_data")
+    if not os.getenv("LUMENRAG_FRONTEND_DIST"):
+        try:
+            studio = bundled_studio()
+        except BundledAssetError as exc:
+            raise LauncherError(str(exc)) from exc
+        if studio is not None:
+            os.environ["LUMENRAG_FRONTEND_DIST"] = str(studio)
+
+    managed = ensure_lumenvec(options)
+    studio_url = f"http://{options.host}:{options.port}"
+    try:
+        if options.open_browser:
+            threading.Thread(
+                target=_open_browser_when_ready,
+                args=(studio_url,),
+                daemon=True,
+            ).start()
+        print(f"[ok] Workspace: {options.workspace}")
+        print(f"[ok] LumenRAG Studio: {studio_url}")
+        print("Press Ctrl+C to stop.")
+
+        _run_studio(options)
+    finally:
+        if managed is not None:
+            print("Stopping managed LumenVec...")
+            managed.stop()

lumenrag-0.1.2/lumenrag.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: lumenrag
+Version: 0.1.2
+Summary: Local-first RAG studio powered by LumenVec
+Author: brma-tech
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/brma-tech/lumenrag
+Project-URL: Repository, https://github.com/brma-tech/lumenrag
+Project-URL: Issues, https://github.com/brma-tech/lumenrag/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Requires-Dist: openai<3,>=1.99.0
+Requires-Dist: pypdf>=5.0.0
+Requires-Dist: python-docx>=1.1.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: python-multipart>=0.0.9
+Dynamic: license-file
+
+LumenRAG is a local-first RAG studio powered by LumenVec.

lumenrag-0.1.2/lumenrag.egg-info/SOURCES.txt

@@ -0,0 +1,45 @@
+LICENSE
+pyproject.toml
+setup.py
+lumenrag/__init__.py
+lumenrag/__main__.py
+lumenrag/bundled.py
+lumenrag/cli.py
+lumenrag/launcher.py
+lumenrag.egg-info/PKG-INFO
+lumenrag.egg-info/SOURCES.txt
+lumenrag.egg-info/dependency_links.txt
+lumenrag.egg-info/entry_points.txt
+lumenrag.egg-info/requires.txt
+lumenrag.egg-info/top_level.txt
+rag_lumenvec/__init__.py
+rag_lumenvec/models.py
+rag_lumenvec/schemas.py
+rag_lumenvec/api/__init__.py
+rag_lumenvec/api/app.py
+rag_lumenvec/api/routes/__init__.py
+rag_lumenvec/api/routes/ai.py
+rag_lumenvec/api/routes/chat.py
+rag_lumenvec/api/routes/documents.py
+rag_lumenvec/api/routes/errors.py
+rag_lumenvec/api/routes/evaluation.py
+rag_lumenvec/api/routes/health.py
+rag_lumenvec/api/routes/status.py
+rag_lumenvec/core/__init__.py
+rag_lumenvec/core/config.py
+rag_lumenvec/core/logging.py
+rag_lumenvec/repositories/__init__.py
+rag_lumenvec/repositories/files.py
+rag_lumenvec/services/__init__.py
+rag_lumenvec/services/ai.py
+rag_lumenvec/services/chat.py
+rag_lumenvec/services/evaluation.py
+rag_lumenvec/services/ingestion.py
+rag_lumenvec/services/lumenvec.py
+rag_lumenvec/services/network.py
+rag_lumenvec/services/retrieval.py
+tests/test_api.py
+tests/test_bundled.py
+tests/test_launcher.py
+tests/test_network.py
+tests/test_rag_service.py

lumenrag-0.1.2/lumenrag.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lumenrag-0.1.2/lumenrag.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lumenrag = lumenrag.cli:main

lumenrag-0.1.2/lumenrag.egg-info/requires.txt

@@ -0,0 +1,7 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+openai<3,>=1.99.0
+pypdf>=5.0.0
+python-docx>=1.1.0
+python-dotenv>=1.0.1
+python-multipart>=0.0.9

lumenrag-0.1.2/lumenrag.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+lumenrag
+rag_lumenvec

lumenrag-0.1.2/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=75", "wheel>=0.45"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lumenrag"
+version = "0.1.2"
+description = "Local-first RAG studio powered by LumenVec"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "brma-tech"}]
+readme = {text = "LumenRAG is a local-first RAG studio powered by LumenVec.", content-type = "text/markdown"}
+requires-python = ">=3.11"
+dependencies = [
+  "fastapi>=0.115.0",
+  "uvicorn[standard]>=0.30.0",
+  "openai>=1.99.0,<3",
+  "pypdf>=5.0.0",
+  "python-docx>=1.1.0",
+  "python-dotenv>=1.0.1",
+  "python-multipart>=0.0.9",
+]
+
+[project.scripts]
+lumenrag = "lumenrag.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/brma-tech/lumenrag"
+Repository = "https://github.com/brma-tech/lumenrag"
+Issues = "https://github.com/brma-tech/lumenrag/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["lumenrag*", "rag_lumenvec*"]
+
+[tool.setuptools.package-data]
+lumenrag = ["assets/**/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+addopts = "-q"
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = [
+  "E",
+  "F",
+  "I",
+  "UP",
+  "B",
+]
+ignore = [
+  "B008",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"