tmjlite 0.2.8__py3-none-win_amd64.whl

tmjlite/__init__.py

@@ -0,0 +1,37 @@
+"""
+TMJLite Python Driver
+Cross-platform embedded database engine
+
+Usage:
+    import tmjlite
+
+    db = tmjlite.connect("mydb.tmjp")
+    db.execute("CREATE TABLE users (name TEXT, age INT);")
+    db.execute("INSERT INTO users VALUES ('Alice', 30);")
+
+    for row in db.query("SELECT * FROM users;"):
+        print(row["name"], row["age"])
+
+    with db.transaction():
+        db.execute("INSERT INTO users VALUES ('Bob', 25);")
+
+    db.close()
+"""
+
+from tmjlite.driver import (
+    connect,
+    connect_shadow,
+    connect_shared,
+    open_branch,
+    Connection,
+    QueryResult,
+    Row,
+    ShadowConnection,
+    SharedConnection,
+)
+
+__version__ = "0.2.8"
+__all__ = [
+    "connect", "connect_shared", "connect_shadow", "open_branch",
+    "Connection", "SharedConnection", "ShadowConnection", "QueryResult", "Row",
+]

tmjlite/driver.py

@@ -0,0 +1,595 @@
+"""
+TMJLite Python driver — loads libtmjlite_ffi via ctypes.
+"""
+
+import ctypes
+import os
+import platform
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+
+def _find_library():
+    """Locate the TMJLite shared library."""
+    system = platform.system()
+    if system == "Darwin":
+        name = "libtmjlite_ffi.dylib"
+    elif system == "Linux":
+        name = "libtmjlite_ffi.so"
+    elif system == "Windows":
+        name = "tmjlite_ffi.dll"
+    else:
+        raise OSError(f"unsupported platform: {system}")
+
+    search_paths = []
+
+    env_path = os.environ.get("TMJLITE_LIB_PATH")
+    if env_path:
+        search_paths.append(Path(env_path))
+
+    driver_dir = Path(__file__).resolve().parent
+
+    # Lib nativa embutida no pacote (_lib/<os>-<arch>/)
+    machine = platform.machine().lower()
+    arch = "arm64" if machine in ("arm64", "aarch64") else \
+        "x64" if machine in ("x86_64", "amd64") else machine
+    os_slug = {"Darwin": "darwin", "Linux": "linux", "Windows": "win32"}.get(system, system.lower())
+    search_paths.append(driver_dir / "_lib" / f"{os_slug}-{arch}" / name)
+
+    search_paths.extend([
+        driver_dir / name,
+        driver_dir.parent / name,
+        driver_dir.parent / "lib" / name,
+    ])
+
+    repo_root = driver_dir.parent.parent.parent
+    search_paths.extend([
+        repo_root / "target" / "release" / name,
+        repo_root / "target" / "debug" / name,
+    ])
+
+    for p in search_paths:
+        if p.is_file():
+            return str(p)
+
+    raise OSError(
+        f"cannot find {name}. Set TMJLITE_LIB_PATH or build with: "
+        f"cargo build --release -p tmjlite-ffi"
+    )
+
+
+def _load_lib():
+    path = _find_library()
+    lib = ctypes.cdll.LoadLibrary(path)
+
+    # Lifecycle
+    lib.tmjlite_open.argtypes = [ctypes.c_char_p]
+    lib.tmjlite_open.restype = ctypes.c_void_p
+
+    lib.tmjlite_open_memory.argtypes = []
+    lib.tmjlite_open_memory.restype = ctypes.c_void_p
+
+    lib.tmjlite_close.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_close.restype = None
+
+    # Execute
+    lib.tmjlite_exec.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_exec.restype = ctypes.c_int
+
+    # Query
+    lib.tmjlite_query.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_query.restype = ctypes.c_void_p
+
+    # Result accessors
+    lib.tmjlite_result_column_count.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_result_column_count.restype = ctypes.c_int
+
+    lib.tmjlite_result_column_name.argtypes = [ctypes.c_void_p, ctypes.c_int]
+    lib.tmjlite_result_column_name.restype = ctypes.c_char_p
+
+    lib.tmjlite_result_row_count.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_result_row_count.restype = ctypes.c_int
+
+    lib.tmjlite_result_value.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int]
+    lib.tmjlite_result_value.restype = ctypes.c_char_p
+
+    lib.tmjlite_result_message.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_result_message.restype = ctypes.c_char_p
+
+    lib.tmjlite_result_free.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_result_free.restype = None
+
+    # Error
+    lib.tmjlite_errmsg.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_errmsg.restype = ctypes.c_char_p
+
+    # Save
+    lib.tmjlite_save.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_save.restype = ctypes.c_int
+
+    lib.tmjlite_save_as.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_save_as.restype = ctypes.c_int
+
+    # Shared (thread-safe) API
+    lib.tmjlite_open_shared.argtypes = [ctypes.c_char_p]
+    lib.tmjlite_open_shared.restype = ctypes.c_void_p
+
+    lib.tmjlite_close_shared.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_close_shared.restype = None
+
+    lib.tmjlite_exec_shared.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_exec_shared.restype = ctypes.c_int
+
+    lib.tmjlite_query_shared.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_query_shared.restype = ctypes.c_void_p
+
+    lib.tmjlite_errmsg_shared.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_errmsg_shared.restype = ctypes.c_char_p
+
+    # Version
+    lib.tmjlite_version.argtypes = []
+    lib.tmjlite_version.restype = ctypes.c_char_p
+
+    # Shadow / branch (git-merge) API
+    lib.tmjlite_shadow_open.argtypes = [ctypes.c_char_p]
+    lib.tmjlite_shadow_open.restype = ctypes.c_void_p
+    lib.tmjlite_shadow_open_branch.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+    lib.tmjlite_shadow_open_branch.restype = ctypes.c_void_p
+    lib.tmjlite_shadow_close.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_close.restype = None
+    lib.tmjlite_shadow_exec.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_shadow_exec.restype = ctypes.c_int
+    lib.tmjlite_shadow_query.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.tmjlite_shadow_query.restype = ctypes.c_void_p
+    lib.tmjlite_shadow_commit.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_commit.restype = ctypes.c_longlong
+    lib.tmjlite_shadow_refresh.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_refresh.restype = ctypes.c_int
+    lib.tmjlite_shadow_pending.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_pending.restype = ctypes.c_longlong
+    lib.tmjlite_shadow_seal.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+    lib.tmjlite_shadow_seal.restype = ctypes.c_longlong
+    lib.tmjlite_shadow_unsealed.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_unsealed.restype = ctypes.c_longlong
+    lib.tmjlite_shadow_set_merge_policy.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+    lib.tmjlite_shadow_set_merge_policy.restype = ctypes.c_int
+    lib.tmjlite_shadow_conflicts.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_conflicts.restype = ctypes.c_longlong
+    lib.tmjlite_shadow_errmsg.argtypes = [ctypes.c_void_p]
+    lib.tmjlite_shadow_errmsg.restype = ctypes.c_char_p
+
+    return lib
+
+
+_lib = None
+
+
+def _get_lib():
+    global _lib
+    if _lib is None:
+        _lib = _load_lib()
+    return _lib
+
+
+class TMJLiteError(Exception):
+    """Error from the TMJLite engine."""
+    pass
+
+
+class Row:
+    """A single row from a query result."""
+
+    __slots__ = ("_columns", "_values")
+
+    def __init__(self, columns, values):
+        self._columns = columns
+        self._values = values
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self._values[key]
+        if isinstance(key, str):
+            try:
+                idx = self._columns.index(key)
+            except ValueError:
+                raise KeyError(f"column '{key}' not found")
+            return self._values[idx]
+        raise TypeError(f"indices must be int or str, not {type(key).__name__}")
+
+    def __len__(self):
+        return len(self._values)
+
+    def __repr__(self):
+        pairs = ", ".join(f"{c}={v!r}" for c, v in zip(self._columns, self._values))
+        return f"Row({pairs})"
+
+    def keys(self):
+        return list(self._columns)
+
+    def values(self):
+        return list(self._values)
+
+    def items(self):
+        return list(zip(self._columns, self._values))
+
+    def to_dict(self):
+        return dict(zip(self._columns, self._values))
+
+
+class QueryResult:
+    """Result of a SELECT query."""
+
+    __slots__ = ("columns", "rows")
+
+    def __init__(self, columns, rows):
+        self.columns = columns
+        self.rows = rows
+
+    def __len__(self):
+        return len(self.rows)
+
+    def __iter__(self):
+        return iter(self.rows)
+
+    def __getitem__(self, index):
+        return self.rows[index]
+
+    def __bool__(self):
+        return len(self.rows) > 0
+
+    def __repr__(self):
+        return f"QueryResult(columns={self.columns}, rows={len(self.rows)})"
+
+    def to_dicts(self):
+        return [row.to_dict() for row in self.rows]
+
+
+def _parse_value(raw_str):
+    """Convert a string value from the C API to a Python type."""
+    if raw_str is None or raw_str == "NULL":
+        return None
+    if raw_str == "true":
+        return True
+    if raw_str == "false":
+        return False
+    try:
+        return int(raw_str)
+    except ValueError:
+        pass
+    try:
+        return float(raw_str)
+    except ValueError:
+        pass
+    return raw_str
+
+
+class Connection:
+    """Connection to a TMJLite database."""
+
+    def __init__(self, handle):
+        self._lib = _get_lib()
+        self._handle = handle
+
+    def execute(self, sql):
+        """Execute a non-query SQL statement. Returns rows affected info as a string."""
+        rc = self._lib.tmjlite_exec(self._handle, sql.encode("utf-8"))
+        if rc != 0:
+            err = self._lib.tmjlite_errmsg(self._handle)
+            msg = err.decode("utf-8") if err else "unknown error"
+            raise TMJLiteError(msg)
+
+    def query(self, sql):
+        """Execute a SELECT and return a QueryResult."""
+        result_ptr = self._lib.tmjlite_query(self._handle, sql.encode("utf-8"))
+        if not result_ptr:
+            err = self._lib.tmjlite_errmsg(self._handle)
+            msg = err.decode("utf-8") if err else "unknown error"
+            raise TMJLiteError(msg)
+
+        try:
+            col_count = self._lib.tmjlite_result_column_count(result_ptr)
+            row_count = self._lib.tmjlite_result_row_count(result_ptr)
+
+            columns = []
+            for i in range(col_count):
+                name = self._lib.tmjlite_result_column_name(result_ptr, i)
+                columns.append(name.decode("utf-8") if name else "")
+
+            rows = []
+            for r in range(row_count):
+                values = []
+                for c in range(col_count):
+                    raw = self._lib.tmjlite_result_value(result_ptr, r, c)
+                    val_str = raw.decode("utf-8") if raw else None
+                    values.append(_parse_value(val_str))
+                rows.append(Row(columns, values))
+
+            return QueryResult(columns, rows)
+        finally:
+            self._lib.tmjlite_result_free(result_ptr)
+
+    def begin(self):
+        """Start a transaction."""
+        self.execute("BEGIN")
+
+    def commit(self):
+        """Commit the current transaction."""
+        self.execute("COMMIT")
+
+    def rollback(self):
+        """Roll back the current transaction."""
+        self.execute("ROLLBACK")
+
+    @contextmanager
+    def transaction(self):
+        """Context manager: auto-commits on success, rolls back on exception."""
+        self.begin()
+        try:
+            yield
+            self.commit()
+        except Exception:
+            self.rollback()
+            raise
+
+    def save(self):
+        """Explicitly save to the database file."""
+        rc = self._lib.tmjlite_save(self._handle)
+        if rc != 0:
+            err = self._lib.tmjlite_errmsg(self._handle)
+            msg = err.decode("utf-8") if err else "unknown error"
+            raise TMJLiteError(msg)
+
+    def save_as(self, path):
+        """Save to a new file path."""
+        rc = self._lib.tmjlite_save_as(self._handle, path.encode("utf-8"))
+        if rc != 0:
+            err = self._lib.tmjlite_errmsg(self._handle)
+            msg = err.decode("utf-8") if err else "unknown error"
+            raise TMJLiteError(msg)
+
+    def close(self):
+        """Close the database connection."""
+        if self._handle:
+            self._lib.tmjlite_close(self._handle)
+            self._handle = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+
+def _read_query_result(lib, result_ptr):
+    """Materializa um TmjResult* em QueryResult e libera o ponteiro."""
+    try:
+        col_count = lib.tmjlite_result_column_count(result_ptr)
+        row_count = lib.tmjlite_result_row_count(result_ptr)
+        columns = []
+        for i in range(col_count):
+            name = lib.tmjlite_result_column_name(result_ptr, i)
+            columns.append(name.decode("utf-8") if name else "")
+        rows = []
+        for r in range(row_count):
+            values = []
+            for c in range(col_count):
+                raw = lib.tmjlite_result_value(result_ptr, r, c)
+                val_str = raw.decode("utf-8") if raw else None
+                values.append(_parse_value(val_str))
+            rows.append(Row(columns, values))
+        return QueryResult(columns, rows)
+    finally:
+        lib.tmjlite_result_free(result_ptr)
+
+
+class SharedConnection:
+    """
+    Conexão thread-safe (MVCC): um único handle pode ser usado por N threads —
+    SELECTs rodam em snapshot em paralelo entre si e com o escritor; escritas
+    serializam e são duráveis ao retornar. Cada statement é auto-commit
+    (BEGIN/COMMIT não são suportados aqui; use Connection para transações).
+
+    Multi-processo continua exclusivo: abrir o mesmo arquivo em outro processo
+    falha com "database is locked by another process".
+
+        db = tmjlite.connect_shared("app.tmjp")
+        with ThreadPoolExecutor(8) as pool:
+            pool.map(lambda a: db.execute(...), agencies)
+    """
+
+    def __init__(self, handle):
+        self._lib = _get_lib()
+        self._handle = handle
+
+    def _raise_last(self):
+        err = self._lib.tmjlite_errmsg_shared(self._handle)
+        raise TMJLiteError(err.decode("utf-8") if err else "unknown error")
+
+    def execute(self, sql):
+        rc = self._lib.tmjlite_exec_shared(self._handle, sql.encode("utf-8"))
+        if rc != 0:
+            self._raise_last()
+
+    def query(self, sql):
+        result_ptr = self._lib.tmjlite_query_shared(self._handle, sql.encode("utf-8"))
+        if not result_ptr:
+            self._raise_last()
+        return _read_query_result(self._lib, result_ptr)
+
+    def close(self):
+        if self._handle:
+            self._lib.tmjlite_close_shared(self._handle)
+            self._handle = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+
+def connect_shared(path):
+    """Abre uma SharedConnection (thread-safe) para um arquivo .tmjp."""
+    lib = _get_lib()
+    handle = lib.tmjlite_open_shared(path.encode("utf-8"))
+    if not handle:
+        raise TMJLiteError(
+            f"failed to open database: {path} (em uso por outro processo?)"
+        )
+    return SharedConnection(handle)
+
+
+class ShadowConnection:
+    """
+    Sessão shadow (git-merge): SQL normal sobre um snapshot do banco + as
+    próprias escritas; cada INSERT/UPDATE/DELETE vira uma op num `.tmjv` ao
+    lado do arquivo, e `commit()` faz o merge por chave primária no banco
+    principal (lock de milissegundos). N processos coexistem no mesmo arquivo
+    sem se bloquear — o que os vizinhos gravaram aparece após o merge deles
+    e um `refresh()`. DML-only: DDL e BEGIN/COMMIT são rejeitados.
+
+    Aberta com `open_branch(path, nome)` vira uma **branch nomeada** e
+    persistente (`.tmjb`): `seal()` grava um commit (autor/mensagem); só ops
+    seladas entram no `commit()`, que consome a branch.
+
+        with tmjlite.connect_shadow("app.tmjp") as sess:
+            sess.execute("INSERT INTO listing (agency_id, external_id) VALUES ('ag', 'e1');")
+            applied = sess.commit()          # merge no main
+
+        br = tmjlite.open_branch("app.tmjp", "import-2026-09")
+        br.execute("UPDATE listing SET seen = 1 WHERE external_id = 'e1';")
+        br.seal("primeira leva", author="thiago")
+        br.commit()
+    """
+
+    def __init__(self, handle):
+        self._lib = _get_lib()
+        self._handle = handle
+
+    def _raise_last(self):
+        err = self._lib.tmjlite_shadow_errmsg(self._handle)
+        raise TMJLiteError(err.decode("utf-8") if err else "unknown error")
+
+    def execute(self, sql):
+        """INSERT/UPDATE/DELETE viram ops da sessão; SELECT roda no overlay."""
+        if self._lib.tmjlite_shadow_exec(self._handle, sql.encode("utf-8")) != 0:
+            self._raise_last()
+
+    def query(self, sql):
+        """SELECT sobre snapshot + próprias escritas."""
+        result_ptr = self._lib.tmjlite_shadow_query(self._handle, sql.encode("utf-8"))
+        if not result_ptr:
+            self._raise_last()
+        return _read_query_result(self._lib, result_ptr)
+
+    def commit(self):
+        """Merge no banco principal. Retorna o nº de ops aplicadas. Numa
+        branch, só ops seladas; ops soltas depois do último `seal` → erro."""
+        n = self._lib.tmjlite_shadow_commit(self._handle)
+        if n < 0:
+            self._raise_last()
+        return n
+
+    def refresh(self):
+        """Re-snapshota o main (vê merges dos vizinhos) mantendo as próprias ops."""
+        if self._lib.tmjlite_shadow_refresh(self._handle) != 0:
+            self._raise_last()
+
+    @property
+    def pending_ops(self):
+        """Ops registradas e ainda não mergeadas."""
+        return self._lib.tmjlite_shadow_pending(self._handle)
+
+    def seal(self, message, author=None):
+        """Branch nomeada: sela as ops não commitadas num commit. Retorna o nº de ops."""
+        author = author or os.environ.get("TMJLITE_AUTHOR") or os.environ.get("USER") or "python"
+        n = self._lib.tmjlite_shadow_seal(
+            self._handle, author.encode("utf-8"), (message or "").encode("utf-8")
+        )
+        if n < 0:
+            self._raise_last()
+        return n
+
+    @property
+    def unsealed_ops(self):
+        """Ops registradas depois do último `seal` (0 em sessão anônima)."""
+        return self._lib.tmjlite_shadow_unsealed(self._handle)
+
+    def set_merge_policy(self, policy, table=None):
+        """Política de conflito do commit: 'lww' | 'error' | 'field_merge' | 'manual'.
+        `table=None` define o default da sessão; senão só aquela tabela."""
+        t = table.encode("utf-8") if table else None
+        if self._lib.tmjlite_shadow_set_merge_policy(self._handle, t, policy.encode("utf-8")) != 0:
+            self._raise_last()
+
+    def conflicts(self):
+        """Dry-run do commit: descrição dos conflitos que o merge encontraria."""
+        n = self._lib.tmjlite_shadow_conflicts(self._handle)
+        if n < 0:
+            self._raise_last()
+        if n == 0:
+            return []
+        err = self._lib.tmjlite_shadow_errmsg(self._handle)
+        return err.decode("utf-8").split("\n") if err else []
+
+    def close(self):
+        """Fecha a sessão. Ops não mergeadas ficam no disco (mergeáveis depois)."""
+        if self._handle:
+            self._lib.tmjlite_shadow_close(self._handle)
+            self._handle = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+
+def connect_shadow(path):
+    """Abre uma sessão shadow anônima (escrita multi-processo por merge)."""
+    lib = _get_lib()
+    handle = lib.tmjlite_shadow_open(path.encode("utf-8"))
+    if not handle:
+        raise TMJLiteError(f"failed to open shadow session on: {path}")
+    return ShadowConnection(handle)
+
+
+def open_branch(path, name):
+    """Abre (ou cria) a branch nomeada `name` em `<path>.shadows/<name>.tmjb`."""
+    lib = _get_lib()
+    handle = lib.tmjlite_shadow_open_branch(path.encode("utf-8"), name.encode("utf-8"))
+    if not handle:
+        raise TMJLiteError(f"failed to open branch '{name}' on: {path}")
+    return ShadowConnection(handle)
+
+
+def connect(path=":memory:"):
+    """
+    Open a TMJLite database connection.
+
+    Args:
+        path: File path, or ":memory:" for an in-memory database.
+
+    Returns:
+        Connection object.
+    """
+    lib = _get_lib()
+    if path == ":memory:":
+        handle = lib.tmjlite_open_memory()
+    else:
+        handle = lib.tmjlite_open(path.encode("utf-8"))
+
+    if not handle:
+        raise TMJLiteError(f"failed to open database: {path}")
+
+    return Connection(handle)

tmjlite-0.2.8.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: tmjlite
+Version: 0.2.8
+Summary: TMJLite embedded SQL database driver — git-native branches, single-file .tmjp, native engine included
+Home-page: https://tmjlite.com.br
+Author: TMJ Sistemas de Informação
+License: MIT
+Project-URL: Homepage, https://tmjlite.com.br
+Project-URL: Documentation, https://tmjlite.com.br/manual.html
+Project-URL: Repository, https://github.com/TMJacometti/TMJPlatform
+Project-URL: Changelog, https://github.com/TMJacometti/TMJPlatform/blob/main/CHANGELOG.md
+Keywords: database,embedded,sql,tmjlite,branches
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: home-page
+Dynamic: requires-python
+
+# tmjlite (Python)
+
+Driver Python do **TMJLite** — banco de dados SQL embarcado, em um único
+arquivo `.tmjp`, com **branches de dados git-native**. O motor nativo (Rust)
+já vem dentro do wheel: nada para instalar além do `pip`.
+
+```bash
+pip install tmjlite
+```
+
+Plataformas: macOS (Apple Silicon), Linux x86-64, Windows x86-64 · Python ≥ 3.8.
+
+```python
+import tmjlite
+
+db = tmjlite.connect("app.tmjp")
+db.execute("CREATE TABLE users (id PK, name TEXT, age INT);")
+db.execute("INSERT INTO users (name, age) VALUES ('Alice', 30);")
+for row in db.query("SELECT name, age FROM users WHERE age > 18;"):
+    print(row["name"], row["age"])
+
+with db.transaction():
+    db.execute("INSERT INTO users (name, age) VALUES ('Bob', 25);")
+db.close()
+```
+
+Branches — trabalhe numa cópia lógica e faça merge no arquivo principal,
+enquanto a aplicação continua enxergando o banco intocado:
+
+```python
+b = tmjlite.open_branch("app.tmjp", "importacao")
+b.execute("INSERT INTO users (name, age) VALUES ('Carol', 41);")
+b.seal("primeira leva", author="thiago")   # commit na branch
+applied = b.commit()                        # merge no app.tmjp
+print(f"{applied} linha(s) aplicadas")
+```
+
+Vários processos ao mesmo tempo? `tmjlite.connect_shadow(path)` dá a cada
+worker uma sessão própria; `commit()` mergeia por chave primária.
+
+- Manual: <https://tmjlite.com.br/manual.html>
+- Branches e concorrência (guia + FAQ): <https://tmjlite.com.br/branches.html>
+- Exemplo completo (sistema de cadastro): <https://tmjlite.com.br/examples.html>
+- Changelog: <https://github.com/TMJacometti/TMJPlatform/blob/main/CHANGELOG.md>
+
+Licença MIT · TMJ Sistemas de Informação.

tmjlite-0.2.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+tmjlite/__init__.py,sha256=YWXB2_j2AV3pnykwDadBgylZ8qd1h905IHXEt-NUsqY,817
+tmjlite/driver.py,sha256=dNZ0HCZb1IY7Iyr-0SobkDpCB0qyNxPDaX5LtMiC-_8,19636
+tmjlite/_lib/win32-x64/tmjlite_ffi.dll,sha256=jXB3FJR17biXfpeMTqaT08lZ_aRviViNlbfdhOvHS0k,1639936
+tmjlite-0.2.8.dist-info/METADATA,sha256=0bVNsAcvMZ8OpUatATkS8bUezW10v-N3lezKeDkBYDg,2792
+tmjlite-0.2.8.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+tmjlite-0.2.8.dist-info/top_level.txt,sha256=XZC3Qcm1WAGoYeD6HoglS68FZFLPpPfqhb-m7kxsfWk,8
+tmjlite-0.2.8.dist-info/RECORD,,

tmjlite-0.2.8.dist-info/WHEEL

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

tmjlite-0.2.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+tmjlite