refactor(delete): replace force_parts/force_masters with part_integrity

Introduced unified `part_integrity` parameter for delete and drop operations
with policies for master-part integrity:

For delete():
- "enforce" (default): Error if parts would be deleted without masters
- "ignore": Allow deleting parts without masters (breaks integrity)
- "cascade": Also delete masters when parts are deleted

For drop():
- "enforce" (default): Error - drop master instead
- "ignore": Allow direct drop

This replaces the previous boolean parameters:
- force_parts=True → part_integrity="ignore"
- force_masters=True → part_integrity="cascade"
- Part.drop(force=True) → Part.drop(part_integrity="ignore")

The same parameter works consistently on both Table and Part classes,
providing a cleaner, more intuitive API.

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: dimitri-yatsenko

RELEASE_MEMO.md

@@ -0,0 +1,117 @@
+# DataJoint 2.0 Release Memo
+
+## PyPI Release Process
+
+### Steps
+
+1. **Run "Manual Draft Release" workflow** on GitHub Actions
+2. **Edit the draft release**:
+   - Change release name to `Release 2.0.0`
+   - Change tag to `v2.0.0`
+3. **Publish the release**
+4. Automation will:
+   - Update `version.py` to `2.0.0`
+   - Build and publish to PyPI
+   - Create PR to merge version update back to master
+
+### Version Note
+
+The release drafter computes version from the previous tag (`v0.14.6`), so it would generate `0.14.7` or `0.15.0`. You must **manually edit** the release name to include `2.0.0`.
+
+The regex on line 42 of `post_draft_release_published.yaml` extracts version from the release name:
+```bash
+VERSION=$(echo "${{ github.event.release.name }}" | grep -oP '\d+\.\d+\.\d+')
+```
+
+---
+
+## Conda-Forge Release Process
+
+DataJoint has a [conda-forge feedstock](https://github.com/conda-forge/datajoint-feedstock).
+
+### How Conda-Forge Updates Work
+
+Conda-forge has **automated bots** that detect new PyPI releases and create PRs automatically:
+
+1. **You publish to PyPI** (via the GitHub release workflow)
+2. **regro-cf-autotick-bot** detects the new version within ~24 hours
+3. **Bot creates a PR** to the feedstock with updated version and hash
+4. **Maintainers review and merge** (you're listed as a maintainer)
+5. **Package builds automatically** for all platforms
+
+### Manual Update (if bot doesn't trigger)
+
+If the bot doesn't create a PR, manually update the feedstock:
+
+1. **Fork** [conda-forge/datajoint-feedstock](https://github.com/conda-forge/datajoint-feedstock)
+
+2. **Edit `recipe/meta.yaml`**:
+   ```yaml
+   {% set version = "2.0.0" %}
+
+   package:
+     name: datajoint
+     version: {{ version }}
+
+   source:
+     url: https://pypi.io/packages/source/d/datajoint/datajoint-{{ version }}.tar.gz
+     sha256: <NEW_SHA256_HASH>
+
+   build:
+     number: 0  # Reset to 0 for new version
+   ```
+
+3. **Get the SHA256 hash**:
+   ```bash
+   curl -sL https://pypi.org/pypi/datajoint/2.0.0/json | jq -r '.urls[] | select(.packagetype=="sdist") | .digests.sha256'
+   ```
+
+4. **Update license** (important for 2.0!):
+   ```yaml
+   about:
+     license: Apache-2.0  # Changed from LGPL-2.1-only
+     license_file: LICENSE
+   ```
+
+5. **Submit PR** to the feedstock
+
+### Action Items for 2.0 Release
+
+1. **First**: Publish to PyPI via GitHub release (name it "Release 2.0.0")
+2. **Wait**: ~24 hours for conda-forge bot to detect
+3. **Check**: [datajoint-feedstock PRs](https://github.com/conda-forge/datajoint-feedstock/pulls) for auto-PR
+4. **Review**: Ensure license changed from LGPL to Apache-2.0
+5. **Merge**: As maintainer, approve and merge the PR
+
+### Timeline
+
+| Step | When |
+|------|------|
+| PyPI release | Day 0 |
+| Bot detects & creates PR | Day 0-1 |
+| Review & merge PR | Day 1-2 |
+| Conda-forge package available | Day 1-2 |
+
+### Verification
+
+After release:
+```bash
+conda search datajoint -c conda-forge
+# Should show 2.0.0
+```
+
+---
+
+## Maintainers
+
+- @datajointbot
+- @dimitri-yatsenko
+- @drewyangdev
+- @guzman-raphael
+- @ttngu207
+
+## Links
+
+- [datajoint-feedstock on GitHub](https://github.com/conda-forge/datajoint-feedstock)
+- [datajoint on Anaconda.org](https://anaconda.org/conda-forge/datajoint)
+- [datajoint on PyPI](https://pypi.org/project/datajoint/)

docs/src/archive/manipulation/delete.md

@@ -26,6 +26,6 @@ Entities in a [part table](../design/tables/master-part.md) are usually removed
 consequence of deleting the master table.
 
 To enforce this workflow, calling `delete` directly on a part table produces an error.
-In some cases, it may be necessary to override this behavior.
-To remove entities from a part table without calling `delete` master, use the argument `force_parts=True`.
-To include the corresponding entries in the master table, use the argument `force_masters=True`.
+In some cases, it may be necessary to override this behavior using the `part_integrity` parameter:
+- `part_integrity="ignore"`: Remove entities from a part table without deleting from master (breaks integrity).
+- `part_integrity="cascade"`: Delete from parts and also cascade up to delete the corresponding master entries.

src/datajoint/table.py

@@ -813,8 +813,7 @@ def delete(
         self,
         transaction: bool = True,
         prompt: bool | None = None,
-        force_parts: bool = False,
-        force_masters: bool = False,
+        part_integrity: str = "enforce",
     ) -> int:
         """
         Deletes the contents of the table and its dependent tables, recursively.
@@ -825,18 +824,22 @@ def delete(
                 nested within another transaction.
             prompt: If `True`, show what will be deleted and ask for confirmation.
                 If `False`, delete without confirmation. Default is `dj.config['safemode']`.
-            force_parts: Delete from parts even when not deleting from their masters.
-            force_masters: If `True`, include part/master pairs in the cascade.
-                Default is `False`.
+            part_integrity: Policy for master-part integrity. One of:
+                - ``"enforce"`` (default): Error if parts would be deleted without masters.
+                - ``"ignore"``: Allow deleting parts without masters (breaks integrity).
+                - ``"cascade"``: Also delete masters when parts are deleted (maintains integrity).
 
         Returns:
             Number of deleted rows (excluding those from dependent tables).
 
         Raises:
             DataJointError: Delete exceeds maximum number of delete attempts.
             DataJointError: When deleting within an existing transaction.
-            DataJointError: Deleting a part table before its master.
+            DataJointError: Deleting a part table before its master (when part_integrity="enforce").
+            ValueError: Invalid part_integrity value.
         """
+        if part_integrity not in ("enforce", "ignore", "cascade"):
+            raise ValueError(f"part_integrity must be 'enforce', 'ignore', or 'cascade', got {part_integrity!r}")
         deleted = set()
         visited_masters = set()
 
@@ -892,7 +895,7 @@ def cascade(table):
 
                     master_name = get_master(child.full_table_name)
                     if (
-                        force_masters
+                        part_integrity == "cascade"
                         and master_name
                         and master_name != table.full_table_name
                         and master_name not in visited_masters
@@ -941,15 +944,16 @@ def cascade(table):
                 self.connection.cancel_transaction()
             raise
 
-        if not force_parts:
-            # Avoid deleting from child before master (See issue #151)
+        if part_integrity == "enforce":
+            # Avoid deleting from part before master (See issue #151)
             for part in deleted:
                 master = get_master(part)
                 if master and master not in deleted:
                     if transaction:
                         self.connection.cancel_transaction()
                     raise DataJointError(
-                        "Attempt to delete part table {part} before deleting from its master {master} first.".format(
+                        "Attempt to delete part table {part} before deleting from its master {master} first. "
+                        "Use part_integrity='ignore' to allow, or part_integrity='cascade' to also delete master.".format(
                             part=part, master=master
                         )
                     )

src/datajoint/user_tables.py

@@ -213,32 +213,53 @@ class Part(UserTable, metaclass=PartMeta):
         + ")"
     )
 
-    def delete(self, force=False, **kwargs):
+    def delete(self, part_integrity: str = "enforce", **kwargs):
         """
         Delete from a Part table.
 
         Args:
-            force: If True, allow direct deletion from Part table.
-                   If False (default), raise an error.
+            part_integrity: Policy for master-part integrity. One of:
+                - ``"enforce"`` (default): Error - delete from master instead.
+                - ``"ignore"``: Allow direct deletion (breaks master-part integrity).
+                - ``"cascade"``: Delete parts AND cascade up to delete master.
             **kwargs: Additional arguments passed to Table.delete()
-                      (transaction, prompt, force_masters)
+                      (transaction, prompt)
 
         Raises:
-            DataJointError: If force is False (direct Part deletes are prohibited)
+            DataJointError: If part_integrity="enforce" (direct Part deletes prohibited)
         """
-        if force:
-            super().delete(force_parts=True, **kwargs)
-        else:
-            raise DataJointError("Cannot delete from a Part directly. Delete from master instead")
-
-    def drop(self, force=False):
+        if part_integrity == "enforce":
+            raise DataJointError(
+                "Cannot delete from a Part directly. Delete from master instead, "
+                "or use part_integrity='ignore' to break integrity, "
+                "or part_integrity='cascade' to also delete master."
+            )
+        super().delete(part_integrity=part_integrity, **kwargs)
+
+    def drop(self, part_integrity: str = "enforce"):
         """
-        unless force is True, prohibits direct deletes from parts.
+        Drop a Part table.
+
+        Args:
+            part_integrity: Policy for master-part integrity. One of:
+                - ``"enforce"`` (default): Error - drop master instead.
+                - ``"ignore"``: Allow direct drop (breaks master-part structure).
+                Note: ``"cascade"`` is not supported for drop (too destructive).
+
+        Raises:
+            DataJointError: If part_integrity="enforce" (direct Part drops prohibited)
         """
-        if force:
+        if part_integrity == "ignore":
             super().drop()
+        elif part_integrity == "enforce":
+            raise DataJointError(
+                "Cannot drop a Part directly. Drop master instead, "
+                "or use part_integrity='ignore' to force."
+            )
         else:
-            raise DataJointError("Cannot drop a Part directly.  Delete from master instead")
+            raise ValueError(
+                f"part_integrity for drop must be 'enforce' or 'ignore', got {part_integrity!r}"
+            )
 
     def alter(self, prompt=True, context=None):
         # without context, use declaration context which maps master keyword to master table

tests/integration/test_cascading_delete.py

@@ -38,7 +38,7 @@ def test_delete_tree(schema_simp_pop):
 def test_stepwise_delete(schema_simp_pop):
     assert not dj.config["safemode"], "safemode must be off for testing"
     assert L() and A() and B() and B.C(), "schema population failed"
-    B.C().delete(force=True)
+    B.C().delete(part_integrity="ignore")
     assert not B.C(), "failed to delete child tables"
     B().delete()
     assert not B(), "failed to delete from the parent table following child table deletion"
@@ -113,19 +113,19 @@ def test_delete_parts_error(schema_simp_pop):
     """test issue #151"""
     with pytest.raises(dj.DataJointError):
         Profile().populate_random()
-        Website().delete(force_masters=False)
+        Website().delete(part_integrity="enforce")
 
 
 def test_delete_parts(schema_simp_pop):
     """test issue #151"""
     Profile().populate_random()
-    Website().delete(force_masters=True)
+    Website().delete(part_integrity="cascade")
 
 
 def test_delete_parts_complex(schema_simp_pop):
     """test issue #151 with complex master/part. PR #1158."""
     prev_len = len(G())
-    (A() & "id_a=1").delete(force_masters=True)
+    (A() & "id_a=1").delete(part_integrity="cascade")
     assert prev_len - len(G()) == 16, "Failed to delete parts"
 
 

tests/schema_simple.py

@@ -141,9 +141,9 @@ class H(dj.Part):
         """
 
     class M(dj.Part):
-        definition = """ # test force_masters revisit
+        definition = """ # test part_integrity cascade
         -> E
-        id_m :int
+        id_m : uint16
         ---
         -> E.H
         """