object-remove 0.1.0__py3-none-any.whl

object_remove/render/poisson_blender.py

@@ -0,0 +1,132 @@
+"""Poisson (gradient domain) blending — ``PoissonBlend`` / ``PoissonBlend2``.
+
+A first class alternative to multi band blending, not a fallback. Parameter
+surface:
+
+===========  =========  ==================================================
+parameter    range      meaning
+===========  =========  ==================================================
+``sigma``    0 to 10    sigma of the edge detector (edge aware guidance)
+``multiplier`` 0 to 10  gradient domain blend strength
+``algo_n``   1 or 2     selects which of two Poisson solver variants to run
+``selection`` n/a       region to blend
+===========  =========  ==================================================
+
+Variant 1 imports the *source* (filled) gradients; variant 2 uses *mixed*
+gradients (whichever of source/target is stronger per edge) — the two classic
+Poisson cloning modes, mapped onto ``algo_n``. ``sigma`` drives an edge detector
+that attenuates guidance across strong target edges; ``multiplier`` scales the
+imported gradient.
+
+Solves the sparse Poisson system ``L f = div(g)`` with Dirichlet boundary equal
+to the background, per channel, via ``scipy.sparse``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import scipy.sparse as sp
+import scipy.sparse.linalg as spla
+
+from ..pyramid.image_pyramid import gaussian_blur
+
+
+class PoissonBlend:
+    def __init__(self, sigma: float = 1.0, multiplier: float = 1.0, algo_n: int = 1):
+        self.sigma = float(np.clip(sigma, 0.0, 10.0))
+        self.multiplier = float(np.clip(multiplier, 0.0, 10.0))
+        self.algo_n = 2 if int(algo_n) == 2 else 1
+
+    def blend(self, foreground: np.ndarray, background: np.ndarray,
+              mask: np.ndarray) -> np.ndarray:
+        """Seamlessly clone ``foreground`` into ``background`` over ``mask``."""
+        fg = foreground.astype(np.float64)
+        bg = background.astype(np.float64)
+        region = np.ascontiguousarray(mask > 0)
+        H, W = region.shape
+        if not region.any():
+            return bg.copy()
+
+        idx = -np.ones((H, W), dtype=np.int64)
+        ys, xs = np.nonzero(region)
+        idx[ys, xs] = np.arange(len(ys))
+        N = len(ys)
+
+        edge_w = self._edge_weights(bg)
+
+        # sparse Laplacian: 4 on diagonal, -1 to in region neighbours
+        neighbours = ((-1, 0), (1, 0), (0, -1), (0, 1))
+        rows = [np.arange(N)]
+        cols = [np.arange(N)]
+        data = [np.full(N, 4.0)]
+        for dy, dx in neighbours:
+            ny, nx = ys + dy, xs + dx
+            inb = (ny >= 0) & (ny < H) & (nx >= 0) & (nx < W)
+            nin = np.zeros(N, dtype=bool)
+            nin[inb] = region[ny[inb], nx[inb]]
+            src = np.nonzero(nin)[0]
+            rows.append(src)
+            cols.append(idx[ny[src], nx[src]])
+            data.append(np.full(len(src), -1.0))
+        A = sp.csr_matrix((np.concatenate(data),
+                           (np.concatenate(rows), np.concatenate(cols))),
+                          shape=(N, N))
+        lu = spla.splu(sp.csc_matrix(A))
+
+        out = bg.copy()
+        for c in range(fg.shape[2]):
+            b = self._rhs(fg[:, :, c], bg[:, :, c], region, idx, ys, xs,
+                          neighbours, edge_w)
+            f = lu.solve(b)
+            out[ys, xs, c] = np.clip(f, 0.0, 1.0)
+        return out
+
+    def _edge_weights(self, bg: np.ndarray) -> np.ndarray:
+        """1 in flat areas, dropping to 0 across strong target edges (controlled by sigma)."""
+        if self.sigma <= 0:
+            return np.ones(bg.shape[:2])
+        gray = bg.mean(axis=2)
+        sm = gray
+        for _ in range(int(round(self.sigma))):
+            sm = gaussian_blur(sm)
+        gy, gx = np.gradient(sm)
+        mag = np.hypot(gx, gy)
+        scale = mag.mean() + 1e-6
+        return np.exp(-mag / (scale * (1.0 + self.sigma)))
+
+    def _rhs(self, fg_c, bg_c, region, idx, ys, xs, neighbours, edge_w):
+        H, W = region.shape
+        N = len(ys)
+        b = np.zeros(N)
+        for dy, dx in neighbours:
+            ny, nx = ys + dy, xs + dx
+            inb = (ny >= 0) & (ny < H) & (nx >= 0) & (nx < W)
+            # guidance gradient across this edge
+            grad_src = np.zeros(N)
+            grad_dst = np.zeros(N)
+            grad_src[inb] = fg_c[ys[inb], xs[inb]] - fg_c[ny[inb], nx[inb]]
+            grad_dst[inb] = bg_c[ys[inb], xs[inb]] - bg_c[ny[inb], nx[inb]]
+            if self.algo_n == 2:
+                # mixed gradients: keep whichever is steeper (variant 2)
+                use_dst = np.abs(grad_dst) > np.abs(grad_src)
+                edge_gradient = np.where(use_dst, grad_dst, grad_src)
+            else:
+                edge_gradient = grad_src
+            edge_gradient = edge_gradient * self.multiplier
+            # edge aware attenuation from the target
+            w = np.ones(N)
+            w[inb] = edge_w[ys[inb], xs[inb]]
+            edge_gradient = edge_gradient * w
+            b += edge_gradient
+            # Dirichlet: neighbours outside the region contribute background value
+            nin = np.zeros(N, dtype=bool)
+            nin[inb] = region[ny[inb], nx[inb]]
+            boundary = inb & ~nin
+            b[boundary] += bg_c[ny[boundary], nx[boundary]]
+        return b
+
+
+# ``PoissonBlend2`` — the tier 3 default (algo_n=2, mixed gradients).
+class PoissonBlend2(PoissonBlend):
+    def __init__(self, sigma: float = 1.0, multiplier: float = 1.0):
+        super().__init__(sigma=sigma, multiplier=multiplier, algo_n=2)

object_remove/session/__init__.py

@@ -0,0 +1,11 @@
+"""Stage F — session / undo persistence."""
+
+from .undo_session_manager import (
+    SessionManager, EditSession, EditStep, rle_encode, rle_decode,
+)
+from .empty_session_sweeper import EmptySessionSweeper
+
+__all__ = [
+    "SessionManager", "EditSession", "EditStep",
+    "rle_encode", "rle_decode", "EmptySessionSweeper",
+]

object_remove/session/empty_session_sweeper.py

@@ -0,0 +1,49 @@
+"""Orphaned empty session GC.
+
+A startup/periodic sweep, distinct from the explicit per session cleanup path,
+that removes session directories left behind by aborted or crashed edits (empty
+or with no valid recorded step). Deletions go through the same queued/locked
+delete task as explicit removal.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import List
+
+from .undo_session_manager import SessionManager, _RemoveTask
+
+
+class EmptySessionSweeper:
+    def __init__(self, manager: SessionManager):
+        self.manager = manager
+
+    def sweep(self) -> List[str]:
+        """Queue removal of empty/orphaned session dirs; return the ids swept."""
+        root = self.manager.root
+        swept: List[str] = []
+        if not os.path.isdir(root):
+            return swept
+        for name in os.listdir(root):
+            path = os.path.join(root, name)
+            if not os.path.isdir(path):
+                continue
+            if self._is_orphan(path):
+                self.manager._queue.submit(
+                    _RemoveTask("remove_session_directory", path))
+                swept.append(name)
+        return swept
+
+    @staticmethod
+    def _is_orphan(path: str) -> bool:
+        manifest = os.path.join(path, "manifest.json")
+        if not os.path.isfile(manifest):
+            # a directory with no manifest at all is an aborted/crashed edit
+            return True
+        try:
+            with open(manifest) as fh:
+                data = json.load(fh)
+        except Exception:
+            return True  # corrupt, so discard
+        return len(data.get("steps", [])) == 0

object_remove/session/undo_session_manager.py

@@ -0,0 +1,178 @@
+"""Session / undo persistence.
+
+* each edit gets a session id and a directory holding the mask history
+  (RLE encoded) and step metadata;
+* session directory removal is **not** an inline synchronous delete — it is
+  dispatched as a task onto a queue and run under an explicit lock, so the UI
+  thread never blocks on filesystem I/O and two removals can't race;
+* corrupt sessions are validated and discarded rather than trusted.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import shutil
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+import numpy as np
+
+
+# RLE mask codec (compact mask history)
+def rle_encode(mask: np.ndarray) -> dict:
+    flat = np.ascontiguousarray(mask > 0).ravel()
+    if flat.size == 0:
+        return {"h": 0, "w": 0, "runs": []}
+    changes = np.flatnonzero(np.diff(flat)) + 1
+    bounds = np.concatenate(([0], changes, [flat.size]))
+    runs = np.diff(bounds).tolist()
+    return {"h": int(mask.shape[0]), "w": int(mask.shape[1]),
+            "first": int(flat[0]), "runs": runs}
+
+
+def rle_decode(obj: dict) -> np.ndarray:
+    h, w = obj["h"], obj["w"]
+    flat = np.zeros(h * w, dtype=bool)
+    val = bool(obj.get("first", 0))
+    pos = 0
+    for run in obj["runs"]:
+        if val:
+            flat[pos:pos + run] = True
+        pos += run
+        val = not val
+    return flat.reshape(h, w)
+
+
+# background delete task queue
+@dataclass
+class _RemoveTask:
+    kind: str          # "remove_session_directory"
+    path: str
+
+
+class _TaskQueue:
+    """Serialises removals under a lock on a background worker thread."""
+
+    def __init__(self):
+        self._q: "queue.Queue[Optional[_RemoveTask]]" = queue.Queue()
+        self._lock = threading.Lock()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def submit(self, task: _RemoveTask) -> None:
+        self._q.put(task)
+
+    def _run(self) -> None:
+        while True:
+            task = self._q.get()
+            if task is None:
+                return
+            try:
+                with self._lock:
+                    if task.kind == "remove_session_directory" and os.path.isdir(task.path):
+                        shutil.rmtree(task.path, ignore_errors=True)
+            finally:
+                self._q.task_done()
+
+    def flush(self) -> None:
+        self._q.join()
+
+    def stop(self) -> None:
+        self._q.put(None)
+
+
+@dataclass
+class EditStep:
+    index: int
+    mask_rle: dict
+    note: str = ""
+    ts: float = field(default_factory=time.time)
+
+
+class SessionManager:
+    """One instance per app; owns the sessions root and the delete queue."""
+
+    def __init__(self, root: str):
+        self.root = root
+        os.makedirs(root, exist_ok=True)
+        self._queue = _TaskQueue()
+        self._sessions: dict[str, "EditSession"] = {}
+
+    def new_session(self) -> "EditSession":
+        session_id = uuid.uuid4().hex[:16]
+        path = os.path.join(self.root, session_id)
+        os.makedirs(path, exist_ok=True)
+        sess = EditSession(session_id, path)
+        self._sessions[session_id] = sess
+        return sess
+
+    # explicit per session cleanup (queued/locked, not inline)
+    def remove_session_directory(self, session: "EditSession") -> None:
+        """Queue removal of a specific (committed/exported) session."""
+        self._sessions.pop(session.session_id, None)
+        self._queue.submit(_RemoveTask("remove_session_directory", session.path))
+
+    def flush(self) -> None:
+        self._queue.flush()
+
+    def close(self) -> None:
+        self._queue.flush()
+        self._queue.stop()
+
+    @staticmethod
+    def validate_session(path: str) -> bool:
+        """A session is valid iff its manifest parses and its steps decode."""
+        manifest = os.path.join(path, "manifest.json")
+        if not os.path.isfile(manifest):
+            return False
+        try:
+            with open(manifest) as fh:
+                data = json.load(fh)
+            for step in data.get("steps", []):
+                rle_decode(step["mask_rle"])
+            return True
+        except Exception:
+            return False
+
+
+class EditSession:
+    def __init__(self, session_id: str, path: str):
+        self.session_id = session_id
+        self.path = path
+        self.steps: List[EditStep] = []
+
+    def record(self, mask: np.ndarray, note: str = "") -> EditStep:
+        step = EditStep(len(self.steps), rle_encode(mask), note)
+        self.steps.append(step)
+        self._persist()
+        return step
+
+    def undo(self) -> Optional[EditStep]:
+        if not self.steps:
+            return None
+        step = self.steps.pop()
+        self._persist()
+        return step
+
+    def mask_at(self, index: int) -> np.ndarray:
+        return rle_decode(self.steps[index].mask_rle)
+
+    def _persist(self) -> None:
+        manifest = {
+            "session_id": self.session_id,
+            "steps": [{"index": s.index, "mask_rle": s.mask_rle,
+                       "note": s.note, "ts": s.ts} for s in self.steps],
+        }
+        tmp_manifest_path = os.path.join(self.path, "manifest.json.tmp")
+        with open(tmp_manifest_path, "w") as fh:
+            json.dump(manifest, fh)
+        # atomic rename so a crash mid write never leaves a truncated manifest
+        os.replace(tmp_manifest_path, os.path.join(self.path, "manifest.json"))
+
+    def is_empty(self) -> bool:
+        return len(self.steps) == 0

object_remove-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: object_remove
+Version: 0.1.0
+Summary: From-scratch CPU reference implementation of a tiered on-device object-removal pipeline
+Author: shalaga44
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/shalaga44/object_remove
+Project-URL: Issues, https://github.com/shalaga44/object_remove/issues
+Keywords: image-processing,inpainting,object-removal,computer-vision
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: Pillow>=9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# object_remove
+
+A from scratch, CPU implementation of an on device object removal pipeline (see
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full design): a
+polygon/scanline mask layer, **three fill engines** of increasing
+sophistication, **two interchangeable blend backends**, and a locked/queued
+session persistence layer.
+
+Everything here is implemented from primitives (FAST corners, BRIEF descriptors,
+Hamming matching, PatchMatch, Laplacian/Poisson blending) — no OpenCV, no learned
+weights.
+
+## Quick start
+
+```bash
+pip install -r requirements.txt          # numpy, scipy, Pillow
+PYTHONPATH=. python examples/demo.py     # writes before/after PNGs to examples/out/
+PYTHONPATH=. python -m pytest -q         # 31 tests
+```
+
+```python
+import numpy as np
+from object_remove import RemoveObjectJob, EngineTier
+
+result = RemoveObjectJob(image_rgb).run(mask, tier=EngineTier.AUTO,
+                                        progress=lambda stage, frac: ...)
+removed = result.image          # float32 RGB in [0, 1]
+print(result.tier_used)         # which engine AUTO picked
+```
+
+`image_rgb` is any `(H, W, 3)` array (uint8 or float); `mask` is `(H, W)` with
+nonzero marking the object to remove.
+
+## Module layout
+
+| Stage | Concern | This repo |
+|---|---|---|
+| A — mask | selection, brush, auto select | `object_remove/mask/` |
+| B/D — scale/tiles | pyramid + tile scheduling | `object_remove/pyramid/` |
+| C1 — legacy CPU fill | segment aware patch comparator | `fillengines/patch_comparator.py` |
+| C2 — texture synthesis | self similar rigid shift | `fillengines/self_similar_shift.py` |
+| C3 — patch match | multi scale PatchMatch | `fillengines/patchmatch/` |
+| E — blend | multi band + Poisson | `object_remove/render/` |
+| F — session | undo / persistence | `object_remove/session/` |
+| — orchestration | tier selection, progress, cancellation | `pipeline/remove_object_job.py` |
+
+## The three fill engines
+
+- **Tier 1 — `SegmentAwarePatchFillEngine`** — greedy onion peel exemplar fill
+  scored by segment aware SSD with byte mask validity. Cheap, correct on small
+  holes; the low end / tiny hole fallback.
+- **Tier 2 — `SelfSimilarShiftEngine`** — the fast default for repetitive texture.
+  FAST corners + 256 bit BRIEF + Hamming matching find a *rigid self similar
+  offset*; a 1D DP seam cuts the copied block in cleanly, run for x then y via
+  a transpose trick.
+- **Tier 3 — `PatchMatchEngine`** — multi scale, multi group PatchMatch inpainting
+  (random init → propagation → random search, then patch voting reconstruction,
+  coarse to fine). The quality path.
+
+`EngineTier.AUTO` sends truly tiny holes to tier 1, otherwise tries the cheap
+tier 2 rigid shift first and falls back to tier 3 PatchMatch when the shift's
+boundary continuity score is poor.
+
+## The two blend backends
+
+- **`MultiBandBlender`** — Laplacian pyramid blend with a fixed **4 tap
+  kernel**, `[0.15439, 0.15133, 0.14252, 0.12896]`, and the mask feathered
+  *per pyramid level*.
+- **`PoissonBlend` / `PoissonBlend2`** — gradient domain blend (`sigma`,
+  `multiplier`, `algo_n` 1|2 variant), solved as a sparse Poisson system.
+  Poisson is the safe default for single image inpainting because it reads
+  only the (valid) hole boundary; the compositor repairs the background under
+  the hole so no backend ever samples the object being removed.
+
+## Session persistence
+
+`SessionManager` gives each edit a session id and an RLE mask history. Directory
+removal is dispatched onto a background queue and run **under a lock** — never
+an inline delete from the caller. A separate `EmptySessionSweeper` GCs orphaned
+empty session dirs left by aborted/crashed edits.
+
+## Status & scope
+
+Implemented and tested: the full CPU pipeline across all stages. Auto select
+is explicitly an *interface + CPU fallback*: a real segmentation model can be
+dropped in behind `AutoSelectModel`, which ships a working color flood
+fallback so tap to select runs end to end without one.
+
+Engines run in pure Python/numpy for clarity; they are correct, not tuned for
+speed. The hot inner loops (PatchMatch sweep, Poisson solve) are the obvious
+targets for a native/GPU port.
+
+```
+object_remove/
+  mask/        brush_rasterizer, polygon_selection, selection_enhancer,
+               connected_components, auto_select
+  pyramid/     image_pyramid, scale_scheduler, tile_scheduler
+  fillengines/ patch_comparator (T1), self_similar_shift (T2), patchmatch/ (T3)
+  render/      multiband_blender, poisson_blender, compositor
+  session/     undo_session_manager, empty_session_sweeper
+  pipeline/    remove_object_job
+```

object_remove-0.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+object_remove/__init__.py,sha256=3NybrvSQ27HDkS4oNTSWCbF_d4mISopZczUV1Fo5oYo,1385
+object_remove/imageutil.py,sha256=dytMnESHndVBjBuiWbyRM3ms7Q-eFfLJfynhIQR5GVM,1828
+object_remove/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+object_remove/fillengines/__init__.py,sha256=h6U2VtdJ8axVIPglhWp9KtVe68BBJAPX-oNBHJeWxd0,754
+object_remove/fillengines/patch_comparator.py,sha256=2OYau1BVwp-PMkhaNZrQQdkFtM5MYTOiuGWuq-3aThM,7193
+object_remove/fillengines/self_similar_shift.py,sha256=VwCRW2ru5bJXx_hdO1f9kmFvweBmL1KHixZTD6GeVK8,14272
+object_remove/fillengines/patchmatch/__init__.py,sha256=GQZNoALA6L_7rJCz2d576cmzVB9_WoQknGtCvlGK1dg,1644
+object_remove/fillengines/patchmatch/group_solver.py,sha256=3SlSaqzv1IGZ7jokWomqGq9i0nGM40wAxcNHt-9CKrs,4930
+object_remove/fillengines/patchmatch/patch.py,sha256=2zMCOoIcJuq_a-rWuznWsB0uy2pxYFMzzXmgHmckRXQ,1371
+object_remove/fillengines/patchmatch/patch_scorer.py,sha256=RgZHnQ2sR5aW-Gw4iBqSgSp25Ib3W8v6IF-ijNtZJZc,1455
+object_remove/fillengines/patchmatch/patch_search_index.py,sha256=_43IQEVHD5OK0l1hI5cnrJDylyBAZztFsotTZt2mmvk,2178
+object_remove/fillengines/patchmatch/solver.py,sha256=WcK_ikt6a3r6JrxkY5xaNtg4KW3TwFLCtGbXv0auH2Y,6419
+object_remove/mask/__init__.py,sha256=bQVvd1UM5kd76fnooH2z4a_P9T7_NJI3_J6DNT3rXgE,733
+object_remove/mask/auto_select.py,sha256=KZ6NdwcCqXitI7GD0Ub2Oy3_Q-li0la2Bq2rV0Z1PJ0,3267
+object_remove/mask/brush_rasterizer.py,sha256=R0C48hFWl444qVd-fw8FrBxnyuoAfFAZfKCFOMfHaz4,3861
+object_remove/mask/connected_components.py,sha256=4m4nXnlfxeDTjtn8SgemF9LH5e7uOgHlE44VLReGI4U,3521
+object_remove/mask/polygon_selection.py,sha256=qOMl14O1oNTU9arersIUBFe_fZBcEB4dcD7tTErMuSg,7868
+object_remove/mask/selection_enhancer.py,sha256=uX5IXw34ham9SawOxDcwWVKcxFd6o1UjoT8iAg696to,4787
+object_remove/pipeline/__init__.py,sha256=qeSxaz5HzpyP4moqd7Rcx3acW5W7V3OoUNiaY4siHqs,216
+object_remove/pipeline/remove_object_job.py,sha256=THvnUwEHv5X4vUv7pdqsj_ZuC0IKB6BL0gcWBXgTFro,6344
+object_remove/pyramid/__init__.py,sha256=zw5zsE1A1xJjChM07snD8XpZxQjI6m-isQQfwQRnsVA,525
+object_remove/pyramid/image_pyramid.py,sha256=iLxDZGN6qEvbh9-u3nAEK_RUJBBo1HBzOmd6LNSCWCQ,3686
+object_remove/pyramid/scale_scheduler.py,sha256=WIVymIiku1UVGLJ8bZhiTwbjU5lA8RIbEZvls_xXTDE,2052
+object_remove/pyramid/tile_scheduler.py,sha256=xpvK19y_JSaxRwkMcNicKao1dZ0flfyvcMS_n3rXcfs,2954
+object_remove/render/__init__.py,sha256=3821iqB146nXdeUtLz5xhvDivEkPmO-rSdOecvERtTU,523
+object_remove/render/compositor.py,sha256=Wuma1RJ4YK9yEo6KHNThAeWHCLDjlZMzXrFkl1Mf6lc,2592
+object_remove/render/multiband_blender.py,sha256=bmHB5ul5V2BoUEaKHgudXcS6_cN8Ht_y6kryfVJQM0E,2887
+object_remove/render/poisson_blender.py,sha256=0ebhm0e1wtrayybTQesFEjVzEBA1dvwvfd4GW8dC2q0,5434
+object_remove/session/__init__.py,sha256=54sYX7WqDWlEfq8WY-yUOboiKChNa2wzflwbmJeDXE8,326
+object_remove/session/empty_session_sweeper.py,sha256=QKoCzs5svKM6kK8F7GsBTR4OGB_lHbAAskpm_O7WHO4,1616
+object_remove/session/undo_session_manager.py,sha256=c2f9xC9h5596EWX2BCzYmEuSf61IV6tkHrqMggLVVGM,5473
+object_remove-0.1.0.dist-info/licenses/LICENSE,sha256=MXtYKLz9evYRq3bIl3mXLvBOjGbGLe-O9ofEH5SFQlY,1066
+object_remove-0.1.0.dist-info/METADATA,sha256=tDpw3g7BghCEdZUHFWDMMN30egmDCUkTxQm5z79Ob3U,5726
+object_remove-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+object_remove-0.1.0.dist-info/top_level.txt,sha256=qaadAwnEePg4QvC7T59W-ucRB7lXHekDw3J-nET_aPk,14
+object_remove-0.1.0.dist-info/RECORD,,

object_remove-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
+

object_remove-0.1.0.dist-info/licenses/LICENSE

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

object_remove-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+object_remove