granite-sqlite-lfm 0.1.0__py3-none-any.whl

granite_sqlite_lfm/__init__.py

@@ -0,0 +1,3 @@
+"""SQLite-backed local Ollama cascade orchestrator."""
+
+__version__ = "0.1.0"

granite_sqlite_lfm/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

granite_sqlite_lfm/cli.py

@@ -0,0 +1,63 @@
+"""Command-line interface for granite-sqlite-lfm."""
+
+import argparse
+import logging
+from typing import List, Optional, Sequence
+
+from .config import DEFAULT_DB_PATH, DEFAULT_SESSION_ID, DEMO_PROMPTS
+from .database import ContextDatabaseManager
+from .orchestrator import CascadeOrchestrator
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="granite-sqlite-lfm",
+        description="Run a SQLite-backed local Ollama cascade orchestrator.",
+    )
+    parser.add_argument(
+        "--db-path",
+        default=DEFAULT_DB_PATH,
+        help=f"SQLite database path. Default: {DEFAULT_DB_PATH}",
+    )
+    parser.add_argument(
+        "--session-id",
+        default=DEFAULT_SESSION_ID,
+        help=f"Session identifier. Default: {DEFAULT_SESSION_ID}",
+    )
+    parser.add_argument(
+        "--prompt",
+        action="append",
+        dest="prompts",
+        help=(
+            "Prompt to process. May be passed multiple times. "
+            "When omitted, the original demo prompts are used."
+        ),
+    )
+    return parser
+
+
+def configure_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+        handlers=[logging.StreamHandler()],
+    )
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    configure_logging()
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    db_manager = ContextDatabaseManager(args.db_path)
+    orchestrator = CascadeOrchestrator(db_manager)
+
+    prompts: List[str] = list(args.prompts or DEMO_PROMPTS)
+
+    for prompt in prompts:
+        print(f"\n[USER PROMPT]: {prompt}")
+        result = orchestrator.run_pipeline(args.session_id, prompt)
+        print(f"[FINAL SYSTEM OUTPUT]:\n{result}\n")
+
+    return 0

granite_sqlite_lfm/config.py

@@ -0,0 +1,15 @@
+"""Default configuration values for granite-sqlite-lfm."""
+
+DEFAULT_DB_PATH = "cascade_context.db"
+DEFAULT_SESSION_ID = "enterprise_user_session_101"
+
+STAGE1_MODEL = "lfm2.5:230m"
+STAGE2_MODEL = "ibm-granite/granite-4.0-h-350m-instruct"
+FALLBACK_MODEL = "granite4.1:3b"
+
+DEMO_PROMPTS = (
+    "Book a conference package room for 15 attendees tomorrow at 3 PM named "
+    "'Project Kickoff'.",
+    "Change the attendee headcount for the Kickoff event to 45 people and "
+    "re-verify options.",
+)

granite_sqlite_lfm/database.py

@@ -0,0 +1,215 @@
+"""SQLite persistence layer for cascade context state."""
+
+import json
+import logging
+import sqlite3
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ContextDatabaseManager:
+    """Manages transactional CRUD operations against the relational state schema."""
+
+    def __init__(self, db_path: str = "cascade_context.db"):
+        self.db_path = db_path
+        self.initialize_schema()
+
+    def _get_connection(self) -> sqlite3.Connection:
+        """Create a connection and enforce WAL mode performance configurations."""
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("PRAGMA foreign_keys = ON;")
+        conn.execute("PRAGMA journal_mode = WAL;")
+        conn.execute("PRAGMA synchronous = NORMAL;")
+        return conn
+
+    def initialize_schema(self) -> None:
+        """Create the relational state tables and virtual full-text search indexes."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS session_state (
+                    session_id TEXT PRIMARY KEY NOT NULL,
+                    current_intent TEXT DEFAULT NULL,
+                    is_escalated INTEGER DEFAULT 0 CHECK (is_escalated IN (0, 1)),
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+                """
+            )
+
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS context_variables (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    variable_key TEXT NOT NULL,
+                    variable_value TEXT NOT NULL,
+                    confidence_score REAL DEFAULT 1.0,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY(session_id) REFERENCES session_state(session_id)
+                        ON DELETE CASCADE,
+                    UNIQUE(session_id, variable_key)
+                );
+                """
+            )
+
+            cursor.execute(
+                """
+                CREATE TABLE IF NOT EXISTS semantic_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+                    content TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY(session_id) REFERENCES session_state(session_id)
+                        ON DELETE CASCADE
+                );
+                """
+            )
+
+            cursor.execute(
+                "CREATE INDEX IF NOT EXISTS idx_vars_session "
+                "ON context_variables(session_id);"
+            )
+            cursor.execute(
+                "CREATE INDEX IF NOT EXISTS idx_history_session "
+                "ON semantic_history(session_id);"
+            )
+
+            cursor.execute(
+                """
+                CREATE VIRTUAL TABLE IF NOT EXISTS history_fts
+                USING fts5(session_id UNINDEXED, content);
+                """
+            )
+
+            cursor.execute(
+                """
+                CREATE TRIGGER IF NOT EXISTS after_history_insert
+                AFTER INSERT ON semantic_history
+                BEGIN
+                    INSERT INTO history_fts(session_id, content)
+                    VALUES (new.session_id, new.content);
+                END;
+                """
+            )
+
+            conn.commit()
+            logger.info("SQLite database schema initialized with WAL mode enabled.")
+
+    def create_or_get_session(self, session_id: str) -> Dict[str, Any]:
+        """Fetch or register an active execution session state."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT session_id, current_intent, is_escalated
+                FROM session_state
+                WHERE session_id = ?;
+                """,
+                (session_id,),
+            )
+            row = cursor.fetchone()
+
+            if not row:
+                cursor.execute(
+                    "INSERT INTO session_state (session_id) VALUES (?);",
+                    (session_id,),
+                )
+                conn.commit()
+                return {
+                    "session_id": session_id,
+                    "current_intent": None,
+                    "is_escalated": 0,
+                }
+
+            return {
+                "session_id": row[0],
+                "current_intent": row[1],
+                "is_escalated": row[2],
+            }
+
+    def update_session_state(
+        self,
+        session_id: str,
+        intent: Optional[str],
+        is_escalated: int,
+    ) -> None:
+        """Update the root state matrix for a tracking session."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                UPDATE session_state
+                SET current_intent = ?,
+                    is_escalated = ?,
+                    updated_at = CURRENT_TIMESTAMP
+                WHERE session_id = ?;
+                """,
+                (intent, is_escalated, session_id),
+            )
+            conn.commit()
+
+    def save_extracted_variables(
+        self,
+        session_id: str,
+        variables: Dict[str, Any],
+    ) -> None:
+        """Upsert key-value arguments extracted dynamically by the micro-model."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+
+            for key, val in variables.items():
+                val_str = json.dumps(val) if isinstance(val, (dict, list)) else str(val)
+                cursor.execute(
+                    """
+                    INSERT INTO context_variables
+                        (session_id, variable_key, variable_value)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(session_id, variable_key)
+                    DO UPDATE SET
+                        variable_value = excluded.variable_value,
+                        updated_at = CURRENT_TIMESTAMP;
+                    """,
+                    (session_id, key, val_str),
+                )
+
+            conn.commit()
+
+    def fetch_active_context(self, session_id: str) -> Dict[str, Any]:
+        """Compile clean variables into a native Python dictionary payload."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT variable_key, variable_value
+                FROM context_variables
+                WHERE session_id = ?;
+                """,
+                (session_id,),
+            )
+
+            context_dict: Dict[str, Any] = {}
+            for key, value in cursor.fetchall():
+                try:
+                    context_dict[key] = json.loads(value)
+                except json.JSONDecodeError:
+                    context_dict[key] = value
+
+            return context_dict
+
+    def append_chat_history(self, session_id: str, role: str, content: str) -> None:
+        """Commit dialogue entries into standard and virtual index layers."""
+        with self._get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                INSERT INTO semantic_history (session_id, role, content)
+                VALUES (?, ?, ?);
+                """,
+                (session_id, role, content),
+            )
+            conn.commit()

granite_sqlite_lfm/orchestrator.py

@@ -0,0 +1,190 @@
+"""Cascade orchestration logic for local Ollama models."""
+
+import json
+import logging
+import re
+from typing import Any, Dict, Optional, Tuple
+
+import ollama
+
+from .config import FALLBACK_MODEL, STAGE1_MODEL, STAGE2_MODEL
+from .database import ContextDatabaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class CascadeOrchestrator:
+    """Orchestrates structured task execution across a cascade of models."""
+
+    def __init__(
+        self,
+        db_manager: ContextDatabaseManager,
+        stage1_model: str = STAGE1_MODEL,
+        stage2_model: str = STAGE2_MODEL,
+        fallback_model: str = FALLBACK_MODEL,
+    ):
+        self.db = db_manager
+        self.stage1_model = stage1_model
+        self.stage2_model = stage2_model
+        self.fallback_model = fallback_model
+
+    def _extract_json_block(self, text: str) -> Dict[str, Any]:
+        """Isolate and extract raw JSON strings from wrapper prose."""
+        try:
+            match = re.search(r"\{.*\}", text, re.DOTALL)
+            if match:
+                return json.loads(match.group(0))
+            return json.loads(text)
+        except (json.JSONDecodeError, AttributeError) as exc:
+            logger.warning("JSON validation extraction block parsing error: %s", exc)
+            return {}
+
+    def invoke_stage1_extractor(
+        self,
+        user_prompt: str,
+    ) -> Tuple[Optional[str], Dict[str, Any]]:
+        """Use the LFM model to parse structural tokens and intents."""
+        system_instructions = (
+            "You are a structural parser. Extract the target 'intent' and all key "
+            "entities or arguments from the prompt. Respond strictly using valid "
+            "JSON configuration with keys: 'intent' (string) and 'variables' "
+            "(object). Do not output markdown sentences outside the JSON layout."
+        )
+
+        try:
+            logger.info("Invoking Stage 1 Routing Parser (%s)...", self.stage1_model)
+            response = ollama.generate(
+                model=self.stage1_model,
+                prompt=f"System: {system_instructions}\nUser Prompt: {user_prompt}",
+                options={"temperature": 0.0},
+            )
+            parsed_data = self._extract_json_block(response.get("response", ""))
+            intent = parsed_data.get("intent")
+            variables = parsed_data.get("variables", {})
+            return intent, variables
+        except Exception as exc:
+            logger.error("Stage 1 extraction pipeline failure: %s", exc)
+            return None, {}
+
+    def invoke_stage2_worker(
+        self,
+        session_id: str,
+        current_intent: str,
+        active_context: Dict[str, Any],
+    ) -> str:
+        """Execute the task with the specialized Granite worker model."""
+        del session_id
+
+        serialized_context = json.dumps(active_context)
+        system_instructions = (
+            f"You are a specialized worker model executing the following action: "
+            f"{current_intent}. Your state variables are loaded cleanly from "
+            f"external database cells: {serialized_context}. Formulate an exact, "
+            "localized solution based on these database records."
+        )
+
+        try:
+            logger.info("Invoking Stage 2 Local Worker (%s)...", self.stage2_model)
+            response = ollama.generate(
+                model=self.stage2_model,
+                prompt=(
+                    f"System: {system_instructions}\n"
+                    "Process the step based on active memory states."
+                ),
+                options={"temperature": 0.3},
+            )
+            output_text = response.get("response", "").strip()
+
+            if not output_text or len(output_text) < 5:
+                raise ValueError(
+                    "Stage 2 generation dropped below confidence threshold boundaries."
+                )
+
+            return output_text
+        except Exception as exc:
+            logger.warning(
+                "Stage 2 logic execution failed: %s. "
+                "Handing off execution to fallback engine.",
+                exc,
+            )
+            return "ESCALATE"
+
+    def escalate_to_3b(
+        self,
+        session_id: str,
+        user_prompt: str,
+        active_context: Dict[str, Any],
+    ) -> str:
+        """Handle complex or failed execution paths with the heavier Granite model."""
+        logger.info(
+            "Escalation triggered. Initializing Stage 3 Frontier Core (%s)...",
+            self.fallback_model,
+        )
+        self.db.update_session_state(
+            session_id,
+            intent="COMPLEX_FALLBACK",
+            is_escalated=1,
+        )
+
+        serialized_context = json.dumps(active_context)
+        system_instructions = (
+            "You are an enterprise coordinator processing an escalated edge case. "
+            "A fast sub-billion cascade pipeline was unable to resolve this task "
+            "safely. Review the user's prompt alongside the recovered database "
+            f"context states: {serialized_context}. Deliver a complete, "
+            "high-confidence response."
+        )
+
+        response = ollama.generate(
+            model=self.fallback_model,
+            prompt=f"System: {system_instructions}\nUser Request: {user_prompt}",
+        )
+        return response.get("response", "").strip()
+
+    def run_pipeline(self, session_id: str, user_prompt: str) -> str:
+        """Coordinate models and sync operational state."""
+        logger.info(
+            "--- Beginning Pipeline Processing Loop for Session: %s ---",
+            session_id,
+        )
+
+        session = self.db.create_or_get_session(session_id)
+        self.db.append_chat_history(session_id, "user", user_prompt)
+
+        if session["is_escalated"] == 1:
+            active_context = self.db.fetch_active_context(session_id)
+            final_output = self.escalate_to_3b(session_id, user_prompt, active_context)
+            self.db.append_chat_history(session_id, "assistant", final_output)
+            return final_output
+
+        intent, variables = self.invoke_stage1_extractor(user_prompt)
+
+        if intent:
+            logger.info(
+                "Stage 1 Success. Intent Extracted: '%s'. Variable Sync Count: %s",
+                intent,
+                len(variables),
+            )
+            self.db.update_session_state(session_id, intent=intent, is_escalated=0)
+            self.db.save_extracted_variables(session_id, variables)
+        else:
+            logger.warning(
+                "Stage 1 failed to interpret input safely. "
+                "Escalating straight to Stage 3."
+            )
+            active_context = self.db.fetch_active_context(session_id)
+            final_output = self.escalate_to_3b(session_id, user_prompt, active_context)
+            self.db.append_chat_history(session_id, "assistant", final_output)
+            return final_output
+
+        active_context = self.db.fetch_active_context(session_id)
+        worker_output = self.invoke_stage2_worker(session_id, intent, active_context)
+
+        if worker_output == "ESCALATE":
+            final_output = self.escalate_to_3b(session_id, user_prompt, active_context)
+        else:
+            logger.info("Stage 2 resolved task within safe confidence boundaries.")
+            final_output = worker_output
+
+        self.db.append_chat_history(session_id, "assistant", final_output)
+        return final_output

granite_sqlite_lfm-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: granite-sqlite-lfm
+Version: 0.1.0
+Summary: SQLite-backed local Ollama cascade orchestrator.
+Author: Author Name
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ollama
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# granite-sqlite-lfm
+
+SQLite-backed local Ollama cascade orchestrator.
+
+This project runs a local multi-stage model pipeline using Ollama and SQLite. It stores session state, extracted context variables, and conversation history in a local SQLite database, then routes user prompts through a lightweight extraction model, a worker model, and a fallback escalation model when needed.
+
+## Features
+
+* SQLite-backed session and context storage
+* Full-text searchable conversation history using SQLite FTS5
+* Local Ollama model orchestration
+* Stage 1 intent and variable extraction
+* Stage 2 task execution
+* Stage 3 fallback escalation
+* Import-safe package structure
+* CLI support with custom prompts and database paths
+
+## Requirements
+
+* Python 3.9+
+* Ollama installed and running locally
+* Local Ollama models available:
+
+  * `lfm2.5:230m`
+  * `ibm-granite/granite-4.0-h-350m-instruct`
+  * `granite4.1:3b`
+
+## Installation
+
+Create and activate a virtual environment:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+On Windows PowerShell:
+
+```powershell
+.venv\Scripts\Activate.ps1
+```
+
+Install the package in editable development mode:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+## Usage
+
+Run the package with the default demo prompts:
+
+```bash
+python -m granite_sqlite_lfm
+```
+
+Or use the console command:
+
+```bash
+granite-sqlite-lfm
+```
+
+Run a custom prompt:
+
+```bash
+granite-sqlite-lfm --prompt "Book a conference room for 15 attendees tomorrow at 3 PM."
+```
+
+Use a custom SQLite database path:
+
+```bash
+granite-sqlite-lfm --db-path ./local_context.db
+```
+
+Use a custom session ID:
+
+```bash
+granite-sqlite-lfm --session-id enterprise_user_session_101
+```
+
+Run multiple prompts in sequence:
+
+```bash
+granite-sqlite-lfm \
+  --prompt "Book a conference room for 15 attendees tomorrow." \
+  --prompt "Change the attendee count to 45."
+```
+
+## Project Structure
+
+```text
+granite-sqlite-lfm/
+├── pyproject.toml
+├── README.md
+├── LICENSE
+├── .gitignore
+├── src/
+│   └── granite_sqlite_lfm/
+│       ├── __init__.py
+│       ├── __main__.py
+│       ├── cli.py
+│       ├── config.py
+│       ├── database.py
+│       └── orchestrator.py
+├── tests/
+│   ├── test_database.py
+│   └── test_orchestrator.py
+└── examples/
+    └── demo.py
+```
+
+## Development
+
+Install development dependencies:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+pytest
+```
+
+Run Ruff linting:
+
+```bash
+ruff check .
+```
+
+Build the package:
+
+```bash
+python -m build
+```
+
+Check distribution artifacts:
+
+```bash
+twine check dist/*
+```
+
+## Publishing
+
+Before publishing, review the package metadata in `pyproject.toml`, including:
+
+* package name
+* author name
+* license
+* description
+* supported Python version
+* dependencies
+* console script name
+
+Then build and upload:
+
+```bash
+python -m build
+twine check dist/*
+twine upload dist/*
+```
+
+## Notes
+
+This project depends on a working local Ollama installation. The included tests should avoid real model calls and focus on package importability, SQLite behavior, JSON parsing, and CLI smoke behavior.
+
+The default SQLite database file is:
+
+```text
+cascade_context.db
+```
+
+This file is local runtime state and should not be committed to version control.

granite_sqlite_lfm-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+granite_sqlite_lfm/__init__.py,sha256=Y6r6RxuIOxtsbIL_1z0EOLxcevNv4rcTQrei1jkLZgg,79
+granite_sqlite_lfm/__main__.py,sha256=8hlUU2E35-HG7k9rIAvKgkXhHEg8UMlqDeLCUg_sLTc,81
+granite_sqlite_lfm/cli.py,sha256=7hJwF-kAlI1ZSwh6RvnLGe0exu9BNZs7nOF8MQ9e3SE,1854
+granite_sqlite_lfm/config.py,sha256=bSNKMSQHgNYdskQ5FXBDkwy1dOty0V4hbVMsH2DKGw0,509
+granite_sqlite_lfm/database.py,sha256=oRXIekU3S1nSzH_obXeklEnvGswLvH7mqt7lh8vdYUA,7893
+granite_sqlite_lfm/orchestrator.py,sha256=iR_xF8j_CEtUMvFVOq9RIVK6hvrrhSEqldjpy3nQwVE,7580
+granite_sqlite_lfm-0.1.0.dist-info/licenses/LICENSE,sha256=lNSfV6H9adn_yivkXZvLvJhSCFhUf5lC-5Z__FOWLvo,1094
+granite_sqlite_lfm-0.1.0.dist-info/METADATA,sha256=AJSmCK6dnda2GrqR_BLHrLsHRIefEO2phvUg5If40hA,3963
+granite_sqlite_lfm-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+granite_sqlite_lfm-0.1.0.dist-info/entry_points.txt,sha256=bJuscpx-RUBubQhwq7ZqW5t2t57lA3TkYvUYB42lKA0,67
+granite_sqlite_lfm-0.1.0.dist-info/top_level.txt,sha256=Bx_UdOLlt8b5LJD_FYl7apCABCcCHg5tGLzJkIF80Zs,19
+granite_sqlite_lfm-0.1.0.dist-info/RECORD,,

granite_sqlite_lfm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

granite_sqlite_lfm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+granite-sqlite-lfm = granite_sqlite_lfm.cli:main

granite_sqlite_lfm-0.1.0.dist-info/licenses/LICENSE

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

granite_sqlite_lfm-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+granite_sqlite_lfm