partial-backup 0.0.1__py3-none-any.whl

partial_backup/__main__.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+import typer
+from rich import print
+
+from partial_backup.backup import Backup
+
+
+def create_backup_directory(source: Path, output: Path) -> None:
+    """
+    Construct a backup directory from a given source directory given in an `unback` format
+    """
+    output.mkdir(parents=True, exist_ok=True)
+    backup = Backup.create_backup_from_directory(source)
+    print(f"Constructing the following backup structure into: {output}")
+    print(backup)
+    backup.write_to_directory(output)
+    print("[bold][green]Done![/green][/bold]")
+    print("[bold]Consider restoring this backup using:[/bold]")
+    print(f"[magenta]pymobiledevice3 backup2 restore {output} --source . --no-copy --system[/magenta]")
+
+
+def cli() -> None:
+    typer.run(create_backup_directory)
+
+
+if __name__ == "__main__":
+    cli()

partial_backup/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

partial_backup/backup.py

@@ -0,0 +1,288 @@
+import plistlib
+import re
+from base64 import b64decode
+from dataclasses import dataclass
+from datetime import datetime
+from hashlib import sha1
+from pathlib import Path
+from random import randbytes
+from typing import Optional
+
+from . import mbdb
+from .mbdb import FileMode
+
+# RWX:RX:RX
+DEFAULT = (FileMode.S_IRUSR | FileMode.S_IWUSR | FileMode.S_IXUSR | FileMode.S_IRGRP | FileMode.S_IXGRP |
+           FileMode.S_IROTH | FileMode.S_IXOTH)
+
+IGNORED_NAMES = {".DS_Store", "Thumbs.db", "desktop.ini", ".Spotlight-V100", ".Trashes"}
+
+
+@dataclass
+class Metadata:
+    owner: Optional[int] = None
+    group: Optional[int] = None
+    mode: Optional[int] = None
+
+
+META_PATTERN = re.compile(
+    r"(user_(?P<user>\d+))?"
+    r"_?"
+    r"(group_(?P<group>\d+))?"
+    r"_?"
+    r"(mode_(?P<mode>[0-7]{3}))?"
+)
+
+DEFAULT_USER = {
+    'HomeDomain': 501
+}
+
+DEFAULT_GROUP = {
+    'HomeDomain': 501
+}
+
+
+@dataclass
+class BackupFile:
+    path: str
+    domain: str
+
+    def to_record(self) -> mbdb.MbdbRecord:
+        raise NotImplementedError()
+
+
+@dataclass
+class ConcreteFile(BackupFile):
+    contents: bytes
+    owner: int = 0
+    group: int = 0
+    inode: Optional[int] = None
+    mode: FileMode = DEFAULT
+
+    def to_record(self) -> mbdb.MbdbRecord:
+        if self.inode is None:
+            self.inode = int.from_bytes(randbytes(8), "big")
+        return mbdb.MbdbRecord(
+            domain=self.domain,
+            filename=self.path,
+            link="",
+            hash=sha1(self.contents).digest(),
+            key=b"",
+            mode=self.mode | FileMode.S_IFREG,
+            # unknown2=0,
+            # unknown3=0,
+            inode=self.inode,
+            user_id=self.owner,
+            group_id=self.group,
+            mtime=int(datetime.now().timestamp()),
+            atime=int(datetime.now().timestamp()),
+            ctime=int(datetime.now().timestamp()),
+            size=len(self.contents),
+            flags=4,
+            properties=[]
+        )
+
+    def __repr__(self) -> str:
+        return (f"ConcreteFile(path='{self.path}', domain='{self.domain}', "
+                f"contents=b'<... lenngth: {len(self.contents)}>', owner={self.owner}, "
+                f"group={self.group}, inode={self.inode}, mode={self.mode})")
+
+
+@dataclass
+class Directory(BackupFile):
+    owner: int = 0
+    group: int = 0
+    mode: FileMode = DEFAULT
+
+    def to_record(self) -> mbdb.MbdbRecord:
+        return mbdb.MbdbRecord(
+            domain=self.domain,
+            filename=self.path,
+            link="",
+            hash=b"",
+            key=b"",
+            mode=self.mode | FileMode.S_IFDIR,
+            # unknown2=0,
+            # unknown3=0,
+            inode=0,  # inode is not respected for directories
+            user_id=self.owner,
+            group_id=self.group,
+            mtime=int(datetime.now().timestamp()),
+            atime=int(datetime.now().timestamp()),
+            ctime=int(datetime.now().timestamp()),
+            size=0,
+            flags=4,
+            properties=[]
+        )
+
+
+@dataclass
+class SymbolicLink(BackupFile):
+    target: str
+    owner: int = 0
+    group: int = 0
+    inode: Optional[int] = None
+    mode: FileMode = DEFAULT
+
+    def to_record(self) -> mbdb.MbdbRecord:
+        if self.inode is None:
+            self.inode = int.from_bytes(randbytes(8), "big")
+        return mbdb.MbdbRecord(
+            domain=self.domain,
+            filename=self.path,
+            link=self.target,
+            hash=b"",
+            key=b"",
+            mode=self.mode | FileMode.S_IFLNK,
+            # unknown2=0,
+            # unknown3=0,
+            inode=self.inode,
+            user_id=self.owner,
+            group_id=self.group,
+            mtime=int(datetime.now().timestamp()),
+            atime=int(datetime.now().timestamp()),
+            ctime=int(datetime.now().timestamp()),
+            size=0,
+            flags=4,
+            properties=[]
+        )
+
+
+def extract_metadata_and_clean(parts: list[str]) -> tuple[list[str], Metadata]:
+    cleaned_parts = []
+    meta = Metadata()
+
+    for part in parts:
+        if part in IGNORED_NAMES:
+            continue  # skip ignored segments entirely
+
+        match = META_PATTERN.fullmatch(part)
+        if match and any(match.group(k) for k in ("user", "group", "mode")):
+            if match.group("user"):
+                meta.owner = int(match.group("user"))
+            if match.group("group"):
+                meta.group = int(match.group("group"))
+            if match.group("mode"):
+                meta.mode = int(match.group("mode"), 8)
+            continue  # skip from cleaned path
+        cleaned_parts.append(part)
+
+    return cleaned_parts, meta
+
+
+@dataclass
+class Backup:
+    files: list[BackupFile]
+
+    @classmethod
+    def create_backup_from_directory(cls, root: Path) -> 'Backup':
+        files: list[Directory | ConcreteFile] = []
+        seen_dirs = set()
+        root = root.resolve()
+
+        for domain_dir in root.iterdir():
+            if not domain_dir.is_dir():
+                continue
+            domain = domain_dir.name
+
+            for path in sorted(domain_dir.rglob("*")):
+                if path.name in IGNORED_NAMES or path == domain_dir:
+                    continue
+
+                rel_path = path.relative_to(domain_dir)
+                cleaned_parts, meta = extract_metadata_and_clean(list(rel_path.parts))
+                cleaned_rel_path = Path(*cleaned_parts)
+
+                if cleaned_rel_path == Path():
+                    continue  # path was only metadata or ignored
+
+                # Ensure parent directories are created first
+                for i in range(1, len(cleaned_parts)):
+                    parent = Path(*cleaned_parts[:i])
+                    if parent not in seen_dirs:
+                        files.append(Directory(str(parent), domain))
+                        seen_dirs.add(parent)
+
+                mode = meta.mode if meta.mode is not None else DEFAULT
+                owner = meta.owner if meta.owner is not None else DEFAULT_USER.get(domain, 0)
+                group = meta.group if meta.group is not None else DEFAULT_GROUP.get(domain, 0)
+
+                if path.is_dir():
+                    if cleaned_rel_path not in seen_dirs:
+                        files.append(Directory(str(cleaned_rel_path), domain, owner=owner, group=group, mode=mode))
+                        seen_dirs.add(cleaned_rel_path)
+                elif path.is_file():
+                    contents = path.read_bytes()
+                    files.append(
+                        ConcreteFile(str(cleaned_rel_path), domain, contents, owner=owner, group=group, mode=mode))
+
+        return cls(files)
+
+    def write_to_directory(self, directory: Path):
+        for file in self.files:
+            if isinstance(file, ConcreteFile):
+                with open(directory / sha1((file.domain + "-" + file.path).encode()).digest().hex(), "wb") as f:
+                    f.write(file.contents)
+
+        with open(directory / "Manifest.mbdb", "wb") as f:
+            f.write(self.generate_manifest_db().to_bytes())
+
+        with open(directory / "Status.plist", "wb") as f:
+            f.write(self.generate_status())
+
+        with open(directory / "Manifest.plist", "wb") as f:
+            f.write(self.generate_manifest())
+
+        with open(directory / "Info.plist", "wb") as f:
+            f.write(plistlib.dumps({}))
+
+    def generate_manifest_db(self):  # Manifest.mbdb
+        records = []
+        for file in self.files:
+            records.append(file.to_record())
+        return mbdb.Mbdb(records=records)
+
+    def generate_status(self) -> bytes:  # Status.plist
+        return plistlib.dumps({
+            "BackupState": "new",
+            "Date": datetime.fromisoformat("1970-01-01T00:00:00+00:00"),
+            "IsFullBackup": False,
+            "SnapshotState": "finished",
+            "UUID": "00000000-0000-0000-0000-000000000000",
+            "Version": "2.4"
+        })
+
+    def generate_manifest(self) -> bytes:  # Manifest.plist
+        return plistlib.dumps({
+            "BackupKeyBag": b64decode("""
+    VkVSUwAAAAQAAAAFVFlQRQAAAAQAAAABVVVJRAAAABDud41d1b9NBICR1BH9JfVtSE1D
+    SwAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV1JBUAAA
+    AAQAAAAAU0FMVAAAABRY5Ne2bthGQ5rf4O3gikep1e6tZUlURVIAAAAEAAAnEFVVSUQA
+    AAAQB7R8awiGR9aba1UuVahGPENMQVMAAAAEAAAAAVdSQVAAAAAEAAAAAktUWVAAAAAE
+    AAAAAFdQS1kAAAAoN3kQAJloFg+ukEUY+v5P+dhc/Welw/oucsyS40UBh67ZHef5ZMk9
+    UVVVSUQAAAAQgd0cg0hSTgaxR3PVUbcEkUNMQVMAAAAEAAAAAldSQVAAAAAEAAAAAktU
+    WVAAAAAEAAAAAFdQS1kAAAAoMiQTXx0SJlyrGJzdKZQ+SfL124w+2Tf/3d1R2i9yNj9z
+    ZCHNJhnorVVVSUQAAAAQf7JFQiBOS12JDD7qwKNTSkNMQVMAAAAEAAAAA1dSQVAAAAAE
+    AAAAAktUWVAAAAAEAAAAAFdQS1kAAAAoSEelorROJA46ZUdwDHhMKiRguQyqHukotrxh
+    jIfqiZ5ESBXX9txi51VVSUQAAAAQfF0G/837QLq01xH9+66vx0NMQVMAAAAEAAAABFdS
+    QVAAAAAEAAAAAktUWVAAAAAEAAAAAFdQS1kAAAAol0BvFhd5bu4Hr75XqzNf4g0fMqZA
+    ie6OxI+x/pgm6Y95XW17N+ZIDVVVSUQAAAAQimkT2dp1QeadMu1KhJKNTUNMQVMAAAAE
+    AAAABVdSQVAAAAAEAAAAA0tUWVAAAAAEAAAAAFdQS1kAAAAo2N2DZarQ6GPoWRgTiy/t
+    djKArOqTaH0tPSG9KLbIjGTOcLodhx23xFVVSUQAAAAQQV37JVZHQFiKpoNiGmT6+ENM
+    QVMAAAAEAAAABldSQVAAAAAEAAAAA0tUWVAAAAAEAAAAAFdQS1kAAAAofe2QSvDC2cV7
+    Etk4fSBbgqDx5ne/z1VHwmJ6NdVrTyWi80Sy869DM1VVSUQAAAAQFzkdH+VgSOmTj3yE
+    cfWmMUNMQVMAAAAEAAAAB1dSQVAAAAAEAAAAA0tUWVAAAAAEAAAAAFdQS1kAAAAo7kLY
+    PQ/DnHBERGpaz37eyntIX/XzovsS0mpHW3SoHvrb9RBgOB+WblVVSUQAAAAQEBpgKOz9
+    Tni8F9kmSXd0sENMQVMAAAAEAAAACFdSQVAAAAAEAAAAA0tUWVAAAAAEAAAAAFdQS1kA
+    AAAo5mxVoyNFgPMzphYhm1VG8Fhsin/xX+r6mCd9gByF5SxeolAIT/ICF1VVSUQAAAAQ
+    rfKB2uPSQtWh82yx6w4BoUNMQVMAAAAEAAAACVdSQVAAAAAEAAAAA0tUWVAAAAAEAAAA
+    AFdQS1kAAAAo5iayZBwcRa1c1MMx7vh6lOYux3oDI/bdxFCW1WHCQR/Ub1MOv+QaYFVV
+    SUQAAAAQiLXvK3qvQza/mea5inss/0NMQVMAAAAEAAAACldSQVAAAAAEAAAAA0tUWVAA
+    AAAEAAAAAFdQS1kAAAAoD2wHX7KriEe1E31z7SQ7/+AVymcpARMYnQgegtZD0Mq2U55u
+    xwNr2FVVSUQAAAAQ/Q9feZxLS++qSe/a4emRRENMQVMAAAAEAAAAC1dSQVAAAAAEAAAA
+    A0tUWVAAAAAEAAAAAFdQS1kAAAAocYda2jyYzzSKggRPw/qgh6QPESlkZedgDUKpTr4Z
+    Z8FDgd7YoALY1g=="""),
+            "Lockdown": {},
+            "SystemDomainsVersion": "20.0",
+            "Version": "9.1"
+        })

partial_backup/mbdb.py

@@ -0,0 +1,172 @@
+from dataclasses import dataclass
+# Mode bitfield
+from enum import IntFlag
+from io import BytesIO
+
+
+class FileMode(IntFlag):
+    S_IFMT = 0o0170000
+    S_IFIFO = 0o0010000
+    S_IFCHR = 0o0020000
+    S_IFDIR = 0o0040000
+    S_IFBLK = 0o0060000
+    S_IFREG = 0o0100000
+    S_IFLNK = 0o0120000
+    S_IFSOCK = 0o0140000
+
+    # S_IRWXU  = 0o0000700
+    S_IRUSR = 0o0000400
+    S_IWUSR = 0o0000200
+    S_IXUSR = 0o0000100
+
+    # S_IRWXG  = 0o0000070
+    S_IRGRP = 0o0000040
+    S_IWGRP = 0o0000020
+    S_IXGRP = 0o0000010
+
+    # S_IRWXO  = 0o0000007
+    S_IROTH = 0o0000004
+    S_IWOTH = 0o0000002
+    S_IXOTH = 0o0000001
+
+    S_ISUID = 0o0004000
+    S_ISGID = 0o0002000
+    S_ISVTX = 0o0001000
+
+
+@dataclass
+class MbdbRecord:
+    domain: str
+    filename: str
+    link: str
+    hash: bytes
+    key: bytes
+    mode: FileMode
+    inode: int
+    user_id: int
+    group_id: int
+    mtime: int
+    atime: int
+    ctime: int
+    size: int
+    flags: int
+    properties: list
+
+    @classmethod
+    def from_stream(cls, d: BytesIO):
+        # d = BytesIO(data)
+
+        domain_len = int.from_bytes(d.read(2), "big")
+        domain = d.read(domain_len).decode("utf-8")
+
+        filename_len = int.from_bytes(d.read(2), "big")
+        filename = d.read(filename_len).decode("utf-8")
+
+        link_len = int.from_bytes(d.read(2), "big")
+        link = d.read(link_len).decode("utf-8") if link_len != 0xffff else ""
+
+        hash_len = int.from_bytes(d.read(2), "big")
+        hash = d.read(hash_len) if hash_len != 0xffff else b""
+
+        key_len = int.from_bytes(d.read(2), "big")
+        key = d.read(key_len) if key_len != 0xffff else b""
+
+        mode = FileMode(int.from_bytes(d.read(2), "big"))
+        # unknown2 = int.from_bytes(d.read(4), "big")
+        # unknown3 = int.from_bytes(d.read(4), "big")
+        inode = int.from_bytes(d.read(8), "big")
+        user_id = int.from_bytes(d.read(4), "big")
+        group_id = int.from_bytes(d.read(4), "big")
+        mtime = int.from_bytes(d.read(4), "big")
+        atime = int.from_bytes(d.read(4), "big")
+        ctime = int.from_bytes(d.read(4), "big")
+        size = int.from_bytes(d.read(8), "big")
+        flags = int.from_bytes(d.read(1), "big")
+
+        properties_count = int.from_bytes(d.read(1), "big")
+        properties = []
+
+        for _ in range(properties_count):
+            name_len = int.from_bytes(d.read(2), "big")
+            name = d.read(name_len).decode("utf-8") if name_len != 0xffff else ""
+
+            value_len = int.from_bytes(d.read(2), "big")
+            value = d.read(value_len).decode("utf-8") if value_len != 0xffff else ""
+
+            properties.append((name, value))
+
+        return cls(domain, filename, link, hash, key, mode, inode, user_id, group_id, mtime, atime, ctime, size, flags,
+                   properties)
+
+    def to_bytes(self) -> bytes:
+        d = BytesIO()
+
+        d.write(len(self.domain).to_bytes(2, "big"))
+        d.write(self.domain.encode("utf-8"))
+
+        d.write(len(self.filename).to_bytes(2, "big"))
+        d.write(self.filename.encode("utf-8"))
+
+        d.write(len(self.link).to_bytes(2, "big"))
+        d.write(self.link.encode("utf-8"))
+
+        d.write(len(self.hash).to_bytes(2, "big"))
+        d.write(self.hash)
+
+        d.write(len(self.key).to_bytes(2, "big"))
+        d.write(self.key)
+
+        d.write(self.mode.to_bytes(2, "big"))
+        # d.write(self.unknown2.to_bytes(4, "big"))
+        # d.write(self.unknown3.to_bytes(4, "big"))
+        d.write(self.inode.to_bytes(8, "big"))
+        d.write(self.user_id.to_bytes(4, "big"))
+        d.write(self.group_id.to_bytes(4, "big"))
+        d.write(self.mtime.to_bytes(4, "big"))
+        d.write(self.atime.to_bytes(4, "big"))
+        d.write(self.ctime.to_bytes(4, "big"))
+        d.write(self.size.to_bytes(8, "big"))
+        d.write(self.flags.to_bytes(1, "big"))
+
+        d.write(len(self.properties).to_bytes(1, "big"))
+
+        for name, value in self.properties:
+            d.write(len(name).to_bytes(2, "big"))
+            d.write(name.encode("utf-8"))
+
+            d.write(len(value).to_bytes(2, "big"))
+            d.write(value.encode("utf-8"))
+
+        return d.getvalue()
+
+
+@dataclass
+class Mbdb:
+    records: list[MbdbRecord]
+
+    @classmethod
+    def from_bytes(cls, data: bytes):
+        d = BytesIO(data)
+
+        if d.read(4) != b"mbdb":
+            raise ValueError("Invalid MBDB file")
+
+        if d.read(2) != b"\x05\x00":
+            raise ValueError("Invalid MBDB version")
+
+        records = []
+        while d.tell() < len(data):
+            records.append(MbdbRecord.from_stream(d))
+
+        return cls(records)
+
+    def to_bytes(self) -> bytes:
+        d = BytesIO()
+
+        d.write(b"mbdb")
+        d.write(b"\x05\x00")
+
+        for record in self.records:
+            d.write(record.to_bytes())
+
+        return d.getvalue()

partial_backup-0.0.1.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: partial-backup
+Version: 0.0.1
+Summary: Metadata-Aware Partial Backup Creator
+Project-URL: Homepage, https://github.com/doronz88/partial-backup
+Project-URL: Bug Reports, https://github.com/doronz88/partial-backup/issues
+Keywords: ios,backup,partial-backup
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pymobiledevice3>4.14.14
+Requires-Dist: bpylist2
+Requires-Dist: rich
+Requires-Dist: click
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+
+# 🗂️ partial-backup: Metadata-Aware Partial Backup Creator
+
+This utility scans a given directory in a structured *"unbacked"* format and generates a `Backup` object that can be
+written back as a valid backup. It preserves directory and file metadata such as ownership (`user_`), group (`group_`),
+and file mode (`mode_`), and skips common junk files.
+
+---
+
+## 📦 Features
+
+- Recursively scans a directory organized by *domain* (e.g., `HomeDomain`)
+- Supports embedded metadata in directory names (`user_501_group_0_mode_755`)
+- Preserves and serializes:
+  - File contents
+  - Directory structure
+  - Ownership and permissions
+- Skips system-specific noise like `.DS_Store` and `Thumbs.db`
+- Outputs a fully reconstructable `Backup` object
+- Simple CLI using [Typer](https://typer.tiangolo.com/)
+
+---
+
+## 🛠️ Installation
+
+```bash
+pip install partial-backup
+```
+
+## 🧪 Example Usage
+
+Assume your source directory is structured like this:
+
+```none
+unback/HomeDomain/
+├── user_501_group_0_mode_777/Library
+│   └── Preferences/
+│       └── com.example.settings.plist
+```
+
+To generate the backup:
+
+```shell
+partial-backup unback/ output/
+```
+
+It will:
+
+- Detect `HomeDomain`
+- Extract user/group/mode from directories like `user_501_group_0_mode_777`
+- Generate a Backup object
+- Save the reconstructed backup to `output/`
+
+## ♻️ Restore the Backup
+
+The generated backup is compatible with [pymobiledevice3](https://github.com/doronz88/pymobiledevice3), and can be
+restored to an iOS device using:
+
+```shell
+pymobiledevice3 backup2 restore /path/to/backup --source . --no-copy --system
+```
+
+## 📁 Metadata Syntax
+
+This tool supports optional metadata hints in folder names:
+
+| Syntax                       | Meaning ---                |
+|------------------------------|----------------------------|
+| `user_501`                   | File owned by user `501`   |
+| `group_20`                   | File belongs to group `20` |
+| `mode_755`                   | File or directory mode     |
+| `user_501_group_20_mode_644` | All of the above           |
+
+These metadata markers are automatically removed from paths and applied to the appropriate file or directory entry.
+
+## ⛔ Ignored Files
+
+The following files and folders are skipped automatically:
+
+- `.DS_Store`
+- `Thumbs.db`
+- `desktop.ini`
+- `.Spotlight-V100`
+- `.Trashes`
+
+## API Overview
+
+```python
+from pathlib import Path
+from partial_backup.backup import Backup
+
+backup = Backup.create_backup_from_directory(Path('/path/to/unback'))
+backup.write_to_directory(Path('/path/to/output'))
+```
+
+## 🙏 Acknowledgments
+
+Huge thanks to [@JJTech0130](https://github.com/JJTech0130) for his insights and foundational work on the backup DB
+implementation.

partial_backup-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+partial_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+partial_backup/__main__.py,sha256=55Wa8JyApyq32kLFLkj_UJJ_FlzRrRx__F84nYjZG60,824
+partial_backup/_version.py,sha256=qf6R-J7-UyuABBo8c0HgaquJ8bejVbf07HodXgwAwgQ,704
+partial_backup/backup.py,sha256=zHOyxSwnCNHRHp7f91lqIJhIFUEKn1re-F4dCspvOWU,10076
+partial_backup/mbdb.py,sha256=I_2G0c-koTJy70pfc1_SWwRFkB-DOVvYb5f9VorpRgo,4825
+partial_backup-0.0.1.dist-info/METADATA,sha256=ZZ9w8w1yqF0jfEQNJEG8T-L8M7V-sWRk9cCpuFy7Z90,3710
+partial_backup-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+partial_backup-0.0.1.dist-info/entry_points.txt,sha256=4fiwhi1tgXBA3otEAJ-RsUPVfjG0JKX22wp6r4cwESo,63
+partial_backup-0.0.1.dist-info/top_level.txt,sha256=loovO1qKYxTvcgAE9Vy12UABh1M_Ly32qKXIbG3By_E,15
+partial_backup-0.0.1.dist-info/RECORD,,

partial_backup-0.0.1.dist-info/WHEEL

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

partial_backup-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+partial-backup = partial_backup.__main__:cli

partial_backup-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+partial_backup