titto 0.1.0__py3-none-any.whl

titto/__init__.py

@@ -0,0 +1,629 @@
+import collections
+import contextlib
+import dataclasses
+import json
+import pathlib
+import typing as t
+import urllib.parse
+
+import cyclopts
+import pydantic
+from myrtille.lib import cfg as myrtille_cfg
+from myrtille.lib import db
+from myrtille.mysql import export, parser
+from myrtille.mysql import types as myrtille_types
+
+from . import util
+
+CACHE_VERSION = 1
+TABLES_ADAPTER = pydantic.TypeAdapter(dict[str, myrtille_types.Table])
+
+
+type Ddls = t.Sequence[str]
+type TableNameMap = t.Mapping[str, myrtille_types.Table]
+type Row = dict[str, t.Any]
+type RowKey = tuple[t.Hashable, ...]
+type TableRows = dict[str, dict[RowKey, Row]]
+type RefId = tuple[str, str]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Ref:
+    src: myrtille_types.Table
+    dst: myrtille_types.Table
+    constraint: myrtille_types.ForeignConstraint
+
+    @property
+    def id(self):
+        return f'{self.src.name},{self.constraint.name or ""}'
+
+
+type TableNameRefMap = t.Mapping[str, t.Sequence[Ref]]
+type TableRefPathMap = t.Mapping[str, t.Sequence[Ref]]
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class TableNameRefMaps:
+    forward: TableNameRefMap
+    reverse: TableNameRefMap
+
+
+def quote_identifier(identifier: str) -> str:
+    return f'`{identifier.replace("`", "``")}`'
+
+
+def quote_table(schema_name: str, table_name: str) -> str:
+    return f'{quote_identifier(schema_name)}.{quote_identifier(table_name)}'
+
+
+def column_list(columns: t.Iterable[str]) -> str:
+    return ', '.join(quote_identifier(column) for column in columns)
+
+
+def qualified_column(alias: str, column: str) -> str:
+    return f'{quote_identifier(alias)}.{quote_identifier(column)}'
+
+
+def placeholders(count: int) -> str:
+    return ', '.join('%s' for _ in range(count))
+
+
+def is_ref_required(ref: Ref):
+    column_name_map = {column.name: column for column in ref.src.columns}
+    return all(column_name_map[column_name].non_nullable for column_name in ref.constraint.columns)
+
+
+def has_unique_key(table: myrtille_types.Table):
+    return any(
+        isinstance(constraint, myrtille_types.UniqueConstraint) for constraint in table.constraints
+    )
+
+
+def parse_count(result: t.Sequence[object]) -> int:
+    count = result[0]
+    if not isinstance(count, int):
+        raise TypeError(f'Expected count to be an int, got {type(count).__name__}')
+    return count
+
+
+def get_primary_key(table: myrtille_types.Table):
+    for constraint in table.constraints:
+        if isinstance(constraint, myrtille_types.PrimaryConstraint):
+            return constraint
+    raise ValueError(f'Table {table.name!r} has no primary key')
+
+
+def get_shortest_ref_path(
+    ref_maps: TableNameRefMaps, *, src_table_name: str, dst_table_name: str
+) -> list[Ref]:
+    if src_table_name == dst_table_name:
+        return []
+
+    visited = {src_table_name}
+    queue = collections.deque[tuple[str, list[Ref]]]([(src_table_name, [])])
+    while queue:
+        table_name, path = queue.popleft()
+        for ref in ref_maps.forward.get(table_name, []):
+            next_table_name = ref.dst.name
+            if next_table_name in visited:
+                continue
+            next_path = [*path, ref]
+            if next_table_name == dst_table_name:
+                return next_path
+            visited.add(next_table_name)
+            queue.append((next_table_name, next_path))
+
+    raise ValueError(
+        f'Table {src_table_name!r} has no forward foreign-key path '
+        f'to tenant table {dst_table_name!r}'
+    )
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Context:
+    cnx: db.Connection
+    schema_name: str
+    tenant_table_name: str
+    tenant_pk_value: t.Sequence[object]
+    commit: bool
+    cache: pathlib.Path | None
+
+    @contextlib.asynccontextmanager
+    @staticmethod
+    async def create(
+        db_config: myrtille_cfg.Database,
+        *,
+        schema_name: str,
+        tenant_table_name: str,
+        tenant_pk_value: t.Sequence[object],
+        commit: bool | None,
+        cache: pathlib.Path | None,
+    ):
+
+        async with db.make_database(db_config) as database, database.acquire() as cnx:
+            await cnx.execute(f'USE {quote_identifier(schema_name)}')
+            yield Context(
+                cnx,
+                schema_name=schema_name,
+                tenant_table_name=tenant_table_name,
+                tenant_pk_value=tenant_pk_value,
+                commit=commit or False,
+                cache=cache,
+            )
+
+    async def get_ddls(self) -> Ddls:
+        return await export.export(schema_name=self.schema_name, config=self.cnx.database.config)
+
+    async def load_tables(self) -> TableNameMap:
+        if self.cache is not None and self.cache.exists():
+            cached_tables = self.load_tables_cache(self.cache)
+            if cached_tables is not None:
+                return cached_tables
+
+        tables = self.get_tables(await self.get_ddls())
+        if self.cache is not None:
+            self.write_tables_cache(self.cache, tables)
+        return tables
+
+    def get_tables_cache_metadata(self) -> dict[str, str | int]:
+        config = self.cnx.database.config
+        return {
+            'version': CACHE_VERSION,
+            'host': config.host,
+            'port': config.port,
+            'schema': self.schema_name,
+        }
+
+    def load_tables_cache(self, cache_path: pathlib.Path) -> TableNameMap | None:
+        try:
+            payload = json.loads(cache_path.read_text(encoding='utf-8'))
+        except OSError, UnicodeDecodeError, json.JSONDecodeError:
+            return None
+
+        if not util.is_dict(payload):
+            return None
+
+        for key, value in self.get_tables_cache_metadata().items():
+            if payload.get(key) != value:
+                return None
+
+        try:
+            return TABLES_ADAPTER.validate_python(payload.get('tables'))
+        except pydantic.ValidationError:
+            return None
+
+    def write_tables_cache(self, cache_path: pathlib.Path, tables: TableNameMap) -> None:
+        payload: dict[str, object] = {
+            **self.get_tables_cache_metadata(),
+            'tables': TABLES_ADAPTER.dump_python(dict(tables), mode='json'),
+        }
+        cache_path.write_text(json.dumps(payload, sort_keys=True), encoding='utf-8')
+
+    def get_tables(self, ddls: t.Sequence[str]) -> TableNameMap:
+        ddl_parser = parser.DDLParser.make()
+        return {
+            table.name: table
+            for ddl in ddls
+            for table in [ddl_parser.parse(ddl, parser.Transformer)]
+        }
+
+    def validate_key_values(self, tables: TableNameMap) -> None:
+        table = tables[self.tenant_table_name]
+        primary_key = get_primary_key(table)
+        if len(self.tenant_pk_value) != len(primary_key.key_list):
+            joined_primary_key = ', '.join(part.identifier for part in primary_key.key_list)
+            raise ValueError(
+                f'{self.schema_name} needs {len(primary_key.key_list)} value(s) for '
+                f'{table.name}({joined_primary_key}), got {len(self.tenant_pk_value)}'
+            )
+
+    def get_ref_maps(self, tables: TableNameMap):
+        refs = [
+            Ref(src=table, dst=tables[constraint.references.ref_table], constraint=constraint)
+            for table in tables.values()
+            for constraint in table.constraints
+            if isinstance(constraint, myrtille_types.ForeignConstraint)
+        ]
+        return TableNameRefMaps(
+            forward=util.groupby(refs, lambda r: r.src.name),
+            reverse=util.groupby(refs, lambda r: r.dst.name),
+        )
+
+    def get_refs_to_tenant(
+        self, ref_maps: TableNameRefMaps, *, required_only: bool = True
+    ) -> TableRefPathMap:
+        refs_to_tenant: dict[str, list[Ref]] = {}
+        enqueued = {self.tenant_table_name}
+        queue = collections.deque[tuple[str, list[Ref]]]([(self.tenant_table_name, [])])
+        while queue:
+            table_name, path_to_tenant = queue.popleft()
+            refs_to_tenant[table_name] = path_to_tenant
+            for ref in ref_maps.reverse.get(table_name, []):
+                if required_only and not is_ref_required(ref):
+                    continue
+                next_table_name = ref.src.name
+                if next_table_name == table_name:
+                    continue
+                if next_table_name in refs_to_tenant or next_table_name in enqueued:
+                    if required_only:
+                        raise ValueError(
+                            f'Table {next_table_name!r} has multiple foreign-key paths '
+                            f'to tenant table {self.tenant_table_name!r}'
+                        )
+                    continue
+                enqueued.add(next_table_name)
+                queue.append((next_table_name, [ref, *path_to_tenant]))
+        return refs_to_tenant
+
+    def get_cleanup_tables(
+        self, tables: TableNameMap, ref_maps: TableNameRefMaps
+    ) -> list[myrtille_types.Table]:
+        refs_to_tenant = self.get_refs_to_tenant(ref_maps, required_only=False)
+        candidate_table_names = {
+            table_name
+            for table_name, _ in util.explore_all(
+                refs_to_tenant, lambda n: [ref.dst.name for ref in ref_maps.forward.get(n, [])]
+            )
+            if table_name not in refs_to_tenant and not has_unique_key(tables[table_name])
+        }
+        return [tables[table_name] for table_name in candidate_table_names]
+
+    def get_sorted_tables(self, tables: TableNameMap, ref_maps: TableNameRefMaps):
+        return list(
+            reversed(
+                list(
+                    util.topological_sort(
+                        tables,
+                        lambda n: [
+                            ref.dst.name
+                            for ref in ref_maps.forward.get(n, [])
+                            if is_ref_required(ref)
+                        ],
+                    )
+                )
+            )
+        )
+
+    def get_tenant_table_for_path(
+        self, table: myrtille_types.Table, path_to_tenant: t.Sequence[Ref]
+    ) -> myrtille_types.Table:
+        current = table
+        for ref in path_to_tenant:
+            if ref.src.name != current.name:
+                raise ValueError(
+                    f'Path from table {table.name!r} uses foreign key '
+                    f'{ref.constraint.name!r} from {ref.src.name!r} '
+                    f'after {current.name!r}'
+                )
+            current = ref.dst
+        if current.name != self.tenant_table_name:
+            raise ValueError(
+                f'Path from table {table.name!r} ends at {current.name!r}, '
+                f'not tenant table {self.tenant_table_name!r}'
+            )
+        return current
+
+    def get_tenant_filter(
+        self, path: t.Sequence[Ref], tenant_table: myrtille_types.Table
+    ) -> tuple[list[str], str, t.Sequence[object]]:
+        if tenant_table.name != self.tenant_table_name:
+            raise ValueError(
+                f'Expected tenant table {self.tenant_table_name!r}, got {tenant_table.name!r}'
+            )
+
+        primary_key = get_primary_key(tenant_table)
+        tenant_pk_columns = tuple(part.identifier for part in primary_key.key_list)
+
+        query_path = path
+        where_values: t.Sequence[object] = self.tenant_pk_value
+        if path:
+            last_ref = path[-1]
+            last_ref_columns = tuple(last_ref.constraint.references.ref_columns)
+            if set(last_ref_columns) == set(tenant_pk_columns) and len(last_ref_columns) == len(
+                tenant_pk_columns
+            ):
+                query_path = path[:-1]
+                tenant_key_by_column = dict(
+                    zip(tenant_pk_columns, self.tenant_pk_value, strict=True)
+                )
+                tenant_alias = f't{len(query_path)}'
+                where_columns = last_ref.constraint.columns
+                where_values = tuple(tenant_key_by_column[column] for column in last_ref_columns)
+            else:
+                tenant_alias = f't{len(path)}'
+                where_columns = tenant_pk_columns
+        else:
+            tenant_alias = 't0'
+            where_columns = tenant_pk_columns
+
+        joins: list[str] = []
+        for i, ref in enumerate(query_path, start=1):
+            src_alias = f't{i - 1}'
+            dst_alias = f't{i}'
+            join_condition = ' AND '.join(
+                f'{qualified_column(src_alias, src_column)} = '
+                f'{qualified_column(dst_alias, dst_column)}'
+                for src_column, dst_column in zip(
+                    ref.constraint.columns, ref.constraint.references.ref_columns, strict=True
+                )
+            )
+            joins.append(
+                f'JOIN {quote_table(self.schema_name, ref.dst.name)} '
+                f'AS {quote_identifier(dst_alias)} ON {join_condition}'
+            )
+
+        where = ' AND '.join(
+            f'{qualified_column(tenant_alias, column)} = %s' for column in where_columns
+        )
+        return joins, where, where_values
+
+    async def delete_by_tenant(
+        self, table: myrtille_types.Table, path_to_tenant: t.Sequence[Ref]
+    ) -> None:
+        tenant_table = self.get_tenant_table_for_path(table, path_to_tenant)
+        joins, where, where_values = self.get_tenant_filter(path_to_tenant, tenant_table)
+        root_alias_prefix = f'{quote_identifier("t0")}.'
+        if joins:
+            stmt = ' '.join(
+                [
+                    f'DELETE {quote_identifier("t0")}',
+                    f'FROM {quote_table(self.schema_name, table.name)} AS {quote_identifier("t0")}',
+                    *joins,
+                    f'WHERE {where}',
+                ]
+            )
+        else:
+            stmt = ' '.join(
+                [
+                    f'DELETE FROM {quote_table(self.schema_name, table.name)}',
+                    f'WHERE {where.replace(root_alias_prefix, "")}',
+                ]
+            )
+        await self.cnx.execute(stmt, params=where_values)
+
+    async def count_by_tenant(
+        self, table: myrtille_types.Table, path_to_tenant: t.Sequence[Ref]
+    ) -> int:
+        tenant_table = self.get_tenant_table_for_path(table, path_to_tenant)
+        joins, where, where_values = self.get_tenant_filter(path_to_tenant, tenant_table)
+        result = t.cast(
+            t.Sequence[object],
+            await self.cnx.fetch_optional(
+                ' '.join(
+                    [
+                        'SELECT COUNT(*)',
+                        f'FROM {quote_table(self.schema_name, table.name)}',
+                        f'AS {quote_identifier("t0")}',
+                        *joins,
+                        f'WHERE {where}',
+                    ]
+                ),
+                where_values,
+            ),
+        )
+        return parse_count(result)
+
+    def get_unreferenced_filter(self, refs: t.Sequence[Ref]) -> str:
+        if not refs:
+            return 'TRUE'
+        conditions: list[str] = []
+        for i, ref in enumerate(refs):
+            ref_alias = f'r{i}'
+            join_condition = ' AND '.join(
+                f'{qualified_column(ref_alias, src_column)} = {qualified_column("t0", dst_column)}'
+                for src_column, dst_column in zip(
+                    ref.constraint.columns, ref.constraint.references.ref_columns, strict=True
+                )
+            )
+            conditions.append(
+                ' '.join(
+                    [
+                        'NOT EXISTS (',
+                        'SELECT 1',
+                        f'FROM {quote_table(self.schema_name, ref.src.name)}',
+                        f'AS {quote_identifier(ref_alias)}',
+                        f'WHERE {join_condition}',
+                        ')',
+                    ]
+                )
+            )
+        return ' AND '.join(conditions)
+
+    async def count_unreferenced_rows(
+        self, table: myrtille_types.Table, ref_maps: TableNameRefMaps
+    ) -> int:
+        where = self.get_unreferenced_filter(ref_maps.reverse.get(table.name, []))
+        result = t.cast(
+            t.Sequence[object],
+            await self.cnx.fetch_optional(
+                ' '.join(
+                    [
+                        'SELECT COUNT(*)',
+                        f'FROM {quote_table(self.schema_name, table.name)}',
+                        f'AS {quote_identifier("t0")}',
+                        f'WHERE {where}',
+                    ]
+                )
+            ),
+        )
+        return parse_count(result)
+
+    async def cleanup_unreferenced_rows(
+        self, table: myrtille_types.Table, ref_maps: TableNameRefMaps
+    ) -> int:
+        count = await self.count_unreferenced_rows(table, ref_maps)
+        if count == 0:
+            return 0
+
+        where = self.get_unreferenced_filter(ref_maps.reverse.get(table.name, []))
+        await self.cnx.execute(
+            ' '.join(
+                [
+                    f'DELETE {quote_identifier("t0")}',
+                    f'FROM {quote_table(self.schema_name, table.name)} AS {quote_identifier("t0")}',
+                    f'WHERE {where}',
+                ]
+            )
+        )
+        return count
+
+    async def set_optional_ref_to_null_by_tenant(
+        self, ref: Ref, path_to_tenant: t.Sequence[Ref]
+    ) -> None:
+        if is_ref_required(ref):
+            raise ValueError(
+                f'Foreign key {ref.constraint.name!r} on table {ref.src.name!r} is required'
+            )
+
+        tenant_table = self.get_tenant_table_for_path(ref.dst, path_to_tenant)
+        path = [ref, *path_to_tenant]
+        joins, where, where_values = self.get_tenant_filter(path, tenant_table)
+        column_name_map = {column.name: column for column in ref.src.columns}
+        assignments = ', '.join(
+            f'{qualified_column("t0", column)} = NULL'
+            for column in ref.constraint.columns
+            if not column_name_map[column].non_nullable
+        )
+        await self.cnx.execute(
+            ' '.join(
+                [
+                    f'UPDATE {quote_table(self.schema_name, ref.src.name)}',
+                    f'AS {quote_identifier("t0")}',
+                    *joins,
+                    f'SET {assignments}',
+                    f'WHERE {where}',
+                ]
+            ),
+            params=where_values,
+        )
+
+
+APP = cyclopts.App()
+
+
+def parse_db_config(url: str, *, echo: bool | None):
+    parsed = urllib.parse.urlparse(url)
+    if parsed.hostname is None:
+        raise ValueError('Missing host in database URL')
+    schema_name = parsed.path.lstrip('/') if parsed.path else None
+    if not schema_name:
+        raise ValueError('Missing schema name in database URL')
+    user = urllib.parse.unquote(parsed.username) if parsed.username else None
+    if not user:
+        raise ValueError('Missing user in database URL')
+    password = urllib.parse.unquote(parsed.password) if parsed.password else None
+    if not password:
+        raise ValueError('Missing password in database URL')
+
+    return (
+        myrtille_cfg.Database(
+            user=user,
+            password=password,
+            host=parsed.hostname,
+            port=parsed.port or 3306,
+            echo=echo,
+            pool_size=1,
+        ),
+        schema_name,
+    )
+
+
+def parse_key_values(raw_key: str) -> t.Sequence[object]:
+    try:
+        value = json.loads(raw_key)
+    except json.JSONDecodeError:
+        return (raw_key,)
+    if util.is_list(value):
+        return tuple(value)
+    return (value,)
+
+
+@APP.command
+async def delete(
+    url: str,
+    tenant_table: str,
+    tenant_pk_value: str,
+    *,
+    skip: set[str] | None = None,
+    commit: bool | None = None,
+    cache: pathlib.Path | None = None,
+    echo: bool | None = None,
+) -> None:
+    db_config, schema_name = parse_db_config(url, echo=echo)
+    async with Context.create(
+        db_config,
+        schema_name=schema_name,
+        tenant_table_name=tenant_table,
+        tenant_pk_value=parse_key_values(tenant_pk_value),
+        commit=commit,
+        cache=cache,
+    ) as ctx:
+        tables = await ctx.load_tables()
+        ctx.validate_key_values(tables)
+        ref_maps = ctx.get_ref_maps(tables)
+        refs_to_tenant = ctx.get_refs_to_tenant(ref_maps)
+
+        for table_name in skip or list[str]():
+            path_to_tenant = refs_to_tenant.get(table_name)
+            if path_to_tenant is not None:
+                count = await ctx.count_by_tenant(tables[table_name], path_to_tenant)
+                if count != 0:
+                    raise RuntimeError(f'Expected 0 {table_name} in tenant but got {count}')
+
+        for refs in ref_maps.forward.values():
+            for ref in refs:
+                if (
+                    not is_ref_required(ref)
+                    and (path_to_tenant := refs_to_tenant.get(ref.dst.name)) is not None
+                ):
+                    await ctx.set_optional_ref_to_null_by_tenant(ref, path_to_tenant)
+
+        for table_name in ctx.get_sorted_tables(tables, ref_maps):
+            if (path_to_tenant := refs_to_tenant.get(table_name)) is not None:
+                await ctx.delete_by_tenant(tables[table_name], path_to_tenant)
+        if ctx.commit:
+            await ctx.cnx.commit()
+        else:
+            await ctx.cnx.execute('ROLLBACK')
+
+
+@APP.command
+async def cleanup(
+    url: str,
+    tenant_table: str,
+    *,
+    commit: bool | None = None,
+    cache: pathlib.Path | None = None,
+    echo: bool | None = None,
+) -> None:
+    db_config, schema_name = parse_db_config(url, echo=echo)
+    async with Context.create(
+        db_config,
+        schema_name=schema_name,
+        tenant_table_name=tenant_table,
+        tenant_pk_value=(),
+        commit=commit,
+        cache=cache,
+    ) as ctx:
+        tables = await ctx.load_tables()
+        if tenant_table not in tables:
+            raise ValueError(f'Unknown tenant table {tenant_table!r}')
+
+        ref_maps = ctx.get_ref_maps(tables)
+        cleanup_tables = ctx.get_cleanup_tables(tables, ref_maps)
+        while True:
+            deleted_count = 0
+            for table in cleanup_tables:
+                count = await ctx.cleanup_unreferenced_rows(table, ref_maps)
+                deleted_count += count
+            if deleted_count == 0:
+                break
+
+        if ctx.commit:
+            await ctx.cnx.commit()
+        else:
+            await ctx.cnx.execute('ROLLBACK')
+
+
+def main():
+    APP(print_error=True, exit_on_error=False)

titto/util.py

@@ -0,0 +1,63 @@
+import collections
+import graphlib
+import typing as t
+
+
+def explore_all[T: t.Hashable](
+    root: t.Iterable[T], explorer: t.Callable[[T], t.Iterable[T]]
+) -> t.Iterator[tuple[T, list[T]]]:
+    explored: set[T] = set()
+    enqueued: set[T] = set()
+    queue: collections.deque[tuple[T, list[T]]] = collections.deque()
+
+    for node in root:
+        if node in enqueued:
+            continue
+        enqueued.add(node)
+        queue.append((node, []))
+
+    while queue:
+        node, path_to_node = queue.popleft()
+        if node in explored:
+            continue
+        explored.add(node)
+        path_to_neighbor = [*path_to_node, node]
+        yield node, path_to_node
+        for neighbor in explorer(node):
+            if neighbor in explored or neighbor in enqueued:
+                continue
+            enqueued.add(neighbor)
+            queue.append((neighbor, path_to_neighbor))
+
+
+def topological_sort[T: t.Hashable](
+    root: t.Iterable[T], explorer: t.Callable[[T], t.Iterable[T]]
+) -> t.Iterable[T]:
+    sorter = graphlib.TopologicalSorter[T]()
+    visited = set[T]()
+    stack = list[T](root)
+    while stack:
+        node = stack.pop()
+        if node not in visited:
+            visited.add(node)
+            dependencies = list(explorer(node))
+            sorter.add(node, *dependencies)
+            stack.extend(dependencies)
+    return sorter.static_order()
+
+
+def groupby[T, K: t.Hashable](
+    values: t.Iterable[T], key: t.Callable[[T], K]
+) -> t.Mapping[K, t.Sequence[T]]:
+    key_values_map: collections.defaultdict[K, list[T]] = collections.defaultdict(list)
+    for value in values:
+        key_values_map[key(value)].append(value)
+    return dict(key_values_map)
+
+
+def is_list(o: object) -> t.TypeGuard[list[object]]:
+    return isinstance(o, list)
+
+
+def is_dict(o: object) -> t.TypeGuard[dict[object, object]]:
+    return isinstance(o, dict)

titto-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.3
+Name: titto
+Version: 0.1.0
+Summary: Delete tenant-scoped MySQL data by walking foreign-key relationships
+Author: Florian Daude
+Author-email: Florian Daude <floriandaude@hotmail.fr>
+Requires-Dist: cyclopts>=4.16.1
+Requires-Dist: myrtille>=0.1.3
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: slcfg>=0.3.4
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Titto
+
+Titto deletes tenant-scoped rows from a MySQL schema by reading table metadata,
+following foreign-key paths back to a tenant table, nulling optional references,
+and deleting rows in dependency order.
+
+## Warnings
+
+This is a destructive database tool. Run it against production only after testing
+the exact command against a restored copy or staging database.
+
+`--commit` permanently commits the deletes. Without `--commit`, Titto still runs
+the `UPDATE` and `DELETE` statements inside a transaction, then rolls them back.
+That dry run can still take locks, fire triggers, and affect non-transactional
+tables.
+
+Take a backup before any committed run. Prefer a database snapshot or logical dump
+that you have already tested restoring. Keep the backup until the tenant removal
+has been verified.
+
+## Usage
+
+Show commands:
+
+```sh
+uv run titto --help
+```
+
+Dry-run a single-column tenant key and cache table metadata as JSON:
+
+```sh
+uv run titto delete "$DB_URL" tenant 42 --cache .tables.json
+```
+
+Commit the delete:
+
+```sh
+uv run titto delete "$DB_URL" tenant 42 --cache .tables.json --commit
+```
+
+Use a composite tenant key by passing JSON:
+
+```sh
+uv run titto delete "$DB_URL" tenant '[42, "eu"]' --cache .tables.json
+```
+
+Require selected tables to be empty for the tenant before deleting anything:
+
+```sh
+uv run titto delete "$DB_URL" tenant 42 --skip invoice --skip payment
+```
+
+Clean up unreferenced rows in tables that are not directly tenant-scoped:
+
+```sh
+uv run titto cleanup "$DB_URL" tenant --cache .tables.json
+```
+
+`DB_URL` is a MySQL URL such as:
+
+```sh
+mysql://user:password@localhost:3306/app_schema
+```
+
+Avoid putting real passwords directly in shell history. Use an environment
+variable, secret manager, or another shell-safe mechanism appropriate for your
+environment.
+
+## Cache Notes
+
+`--cache` stores parsed table metadata as JSON. The recommended local cache path
+is `.tables.json`; it is ignored by Git.
+
+The cache is tied to the host, port, schema name, and cache format version. Titto
+rejects mismatched cache metadata and reparses the database schema. If the schema
+changes on the same host and schema name, delete `.tables.json` so Titto can
+refresh it.
+
+## Development
+
+Run the test suite:
+
+```sh
+uv run python -m unittest
+```

titto-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+titto/__init__.py,sha256=cxL--HBd5qRxOIyJgCUp_WU4qMZGKVIpxdnIF_mCAQQ,22362
+titto/util.py,sha256=hfT1rRh9WwXamTct4kNoPoQTV5VjeGzrIu7OJH8qWoQ,1870
+titto-0.1.0.dist-info/WHEEL,sha256=o6xtdofIa8Zz80kUveEHMWeAWtEyZSzYS1bbyKDCgzA,80
+titto-0.1.0.dist-info/entry_points.txt,sha256=HtCIaae-ZjDuOvzVeNvBXDuOuwtVlS2ds4otEz99fcg,38
+titto-0.1.0.dist-info/METADATA,sha256=BDz_1ZserQ9fHA1vCF4hQCsILmwtq8OVQ3fnTsniZ8o,2652
+titto-0.1.0.dist-info/RECORD,,

titto-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.10.4
+Root-Is-Purelib: true
+Tag: py3-none-any

titto-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+titto = titto:main
+