[ENH]: Make detach a Collection method (#5958)

## Description of changes

_Summarize the changes made by this PR._

- Improvements & Bug fixes
    - detach used to be a AttachedFunction method. This change makes it a Collection method that takes in an attached function name to delete.
- New functionality
    - ...

## Test plan

_How are these changes tested?_

- [ ] Tests pass locally with `pytest` for python, `yarn test` for js, `cargo test` for rust

## Migration plan

_Are there any migrations, or any forwards/backwards compatibility changes needed in order to make sure this change deploys reliably?_

## Observability plan

_What is the plan to instrument and monitor this change?_

## Documentation Changes

_Are all docstrings for user-facing APIs updated if required? Do we need to make documentation changes in the_ [_docs section](https://github.com/chroma-core/chroma/tree/main/docs/docs.trychroma.com)?_

Author: tanujnay112

chromadb/api/__init__.py

@@ -868,7 +868,7 @@ def get_attached_function(
     @abstractmethod
     def detach_function(
         self,
-        attached_function_id: UUID,
+        name: str,
         input_collection_id: UUID,
         delete_output: bool = False,
         tenant: str = DEFAULT_TENANT,
@@ -877,7 +877,7 @@ def detach_function(
         """Detach a function and prevent any further runs.
 
         Args:
-            attached_function_id: ID of the attached function to remove
+            name: Name of the attached function to remove
             input_collection_id: ID of the input collection
             delete_output: Whether to also delete the output collection
             tenant: The tenant name
@@ -887,27 +887,3 @@ def detach_function(
             bool: True if successful
         """
         pass
-
-    @abstractmethod
-    def get_attached_function(
-        self,
-        name: str,
-        input_collection_id: UUID,
-        tenant: str = DEFAULT_TENANT,
-        database: str = DEFAULT_DATABASE,
-    ) -> "AttachedFunction":
-        """Get an attached function by name for a specific collection.
-
-        Args:
-            name: Name of the attached function
-            input_collection_id: ID of the input collection
-            tenant: The tenant name
-            database: The database name
-
-        Returns:
-            AttachedFunction: The attached function object
-
-        Raises:
-            NotFoundError: If the attached function doesn't exist
-        """
-        pass

chromadb/api/fastapi.py

@@ -830,7 +830,7 @@ def get_attached_function(
     @override
     def detach_function(
         self,
-        attached_function_id: UUID,
+        name: str,
         input_collection_id: UUID,
         delete_output: bool = False,
         tenant: str = DEFAULT_TENANT,
@@ -839,10 +839,9 @@ def detach_function(
         """Detach a function and prevent any further runs."""
         resp_json = self._make_request(
             "post",
-            f"/tenants/{tenant}/databases/{database}/attached_functions/{attached_function_id}/detach",
+            f"/tenants/{tenant}/databases/{database}/collections/{input_collection_id}/attached_functions/{name}/detach",
             json={
                 "delete_output": delete_output,
-                "input_collection_id": str(input_collection_id),
             },
         )
         return cast(bool, resp_json["success"])

chromadb/api/models/AttachedFunction.py

@@ -77,40 +77,21 @@ def params(self) -> Optional[Dict[str, Any]]:
     @staticmethod
     def _normalize_params(params: Optional[Any]) -> Dict[str, Any]:
         """Normalize params to a consistent dict format.
-        
+
         Handles None, empty strings, JSON strings, and dicts.
         """
         if params is None:
             return {}
         if isinstance(params, str):
             try:
-                return json.loads(params) if params else {}
+                result = json.loads(params) if params else {}
+                return result if isinstance(result, dict) else {}
             except json.JSONDecodeError:
                 return {}
         if isinstance(params, dict):
             return params
         return {}
 
-    def detach(self, delete_output_collection: bool = False) -> bool:
-        """Detach this function and prevent any further runs.
-
-        Args:
-            delete_output_collection: Whether to also delete the output collection. Defaults to False.
-
-        Returns:
-            bool: True if successful
-
-        Example:
-            >>> success = attached_fn.detach(delete_output_collection=True)
-        """
-        return self._client.detach_function(
-            attached_function_id=self._id,
-            input_collection_id=self._input_collection_id,
-            delete_output=delete_output_collection,
-            tenant=self._tenant,
-            database=self._database,
-        )
-
     def __repr__(self) -> str:
         return (
             f"AttachedFunction(id={self._id}, name='{self._name}', "
@@ -123,11 +104,11 @@ def __eq__(self, other: object) -> bool:
         """Compare two AttachedFunction objects for equality."""
         if not isinstance(other, AttachedFunction):
             return False
-        
+
         # Normalize params: handle None, {}, and JSON strings
         self_params = self._normalize_params(self._params)
         other_params = self._normalize_params(other._params)
-        
+
         return (
             self._id == other._id
             and self._name == other._name
@@ -143,8 +124,10 @@ def __hash__(self) -> int:
         """Return hash of the AttachedFunction."""
         # Normalize params using the same logic as __eq__
         normalized_params = self._normalize_params(self._params)
-        params_tuple = tuple(sorted(normalized_params.items())) if normalized_params else ()
-        
+        params_tuple = (
+            tuple(sorted(normalized_params.items())) if normalized_params else ()
+        )
+
         return hash(
             (
                 self._id,

chromadb/api/models/Collection.py

@@ -552,3 +552,28 @@ def get_attached_function(self, name: str) -> "AttachedFunction":
             tenant=self.tenant,
             database=self.database,
         )
+
+    def detach_function(
+        self,
+        name: str,
+        delete_output_collection: bool = False,
+    ) -> bool:
+        """Detach a function from this collection.
+
+        Args:
+            name: The name of the attached function
+            delete_output_collection: Whether to also delete the output collection. Defaults to False.
+
+        Returns:
+            bool: True if successful
+
+        Example:
+            >>> success = collection.detach_function("my_function", delete_output_collection=True)
+        """
+        return self._client.detach_function(
+            name=name,
+            input_collection_id=self.id,
+            delete_output=delete_output_collection,
+            tenant=self.tenant,
+            database=self.database,
+        )

chromadb/api/rust.py

@@ -637,7 +637,7 @@ def get_attached_function(
     @override
     def detach_function(
         self,
-        attached_function_id: UUID,
+        name: str,
         input_collection_id: UUID,
         delete_output: bool = False,
         tenant: str = DEFAULT_TENANT,
@@ -649,20 +649,6 @@ def detach_function(
             "The Rust bindings (embedded mode) do not support attached function operations."
         )
 
-    @override
-    def get_attached_function(
-        self,
-        name: str,
-        input_collection_id: UUID,
-        tenant: str = DEFAULT_TENANT,
-        database: str = DEFAULT_DATABASE,
-    ) -> "AttachedFunction":
-        """Attached functions are not supported in the Rust bindings (local embedded mode)."""
-        raise NotImplementedError(
-            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
-            "The Rust bindings (embedded mode) do not support attached function operations."
-        )
-
     # TODO: Remove this if it's not planned to be used
     @override
     def get_user_identity(self) -> UserIdentity:

chromadb/api/segment.py

@@ -946,7 +946,7 @@ def get_attached_function(
     @override
     def detach_function(
         self,
-        attached_function_id: UUID,
+        name: str,
         input_collection_id: UUID,
         delete_output: bool = False,
         tenant: str = DEFAULT_TENANT,
@@ -958,20 +958,6 @@ def detach_function(
             "The Segment API (embedded mode) does not support attached function operations."
         )
 
-    @override
-    def get_attached_function(
-        self,
-        name: str,
-        input_collection_id: UUID,
-        tenant: str = DEFAULT_TENANT,
-        database: str = DEFAULT_DATABASE,
-    ) -> "AttachedFunction":
-        """Attached functions are not supported in the Segment API (local embedded mode)."""
-        raise NotImplementedError(
-            "Attached functions are only supported when connecting to a Chroma server via HttpClient. "
-            "The Segment API (embedded mode) does not support attached function operations."
-        )
-
     # TODO: This could potentially cause race conditions in a distributed version of the
     # system, since the cache is only local.
     # TODO: promote collection -> topic to a base class method so that it can be

chromadb/test/distributed/test_task_api.py

@@ -57,7 +57,8 @@ def test_count_function_attach_and_detach(basic_http_client: System) -> None:
     assert result["metadatas"][0]["total_count"] == 300
 
     # Remove the task
-    success = attached_fn.detach(
+    success = collection.detach_function(
+        attached_fn.name,
         delete_output_collection=True,
     )
 
@@ -108,7 +109,7 @@ def test_attach_function_returns_function_name(basic_http_client: System) -> Non
     assert retrieved_fn == attached_fn
 
     # Clean up
-    attached_fn.detach(delete_output_collection=True)
+    collection.detach_function(attached_fn.name, delete_output_collection=True)
 
 
 def test_function_multiple_collections(basic_http_client: System) -> None:
@@ -146,8 +147,14 @@ def test_function_multiple_collections(basic_http_client: System) -> None:
     assert attached_fn1.id != attached_fn2.id
 
     # Clean up
-    assert attached_fn1.detach(delete_output_collection=True) is True
-    assert attached_fn2.detach(delete_output_collection=True) is True
+    assert (
+        collection1.detach_function(attached_fn1.name, delete_output_collection=True)
+        is True
+    )
+    assert (
+        collection2.detach_function(attached_fn2.name, delete_output_collection=True)
+        is True
+    )
 
 
 def test_functions_one_attached_function_per_collection(
@@ -191,7 +198,10 @@ def test_functions_one_attached_function_per_collection(
         )
 
     # Detach the first function
-    assert attached_fn1.detach(delete_output_collection=True) is True
+    assert (
+        collection.detach_function(attached_fn1.name, delete_output_collection=True)
+        is True
+    )
 
     # Now we should be able to attach a new function
     attached_fn2 = collection.attach_function(
@@ -205,7 +215,10 @@ def test_functions_one_attached_function_per_collection(
     assert attached_fn2.id != attached_fn1.id
 
     # Clean up
-    assert attached_fn2.detach(delete_output_collection=True) is True
+    assert (
+        collection.detach_function(attached_fn2.name, delete_output_collection=True)
+        is True
+    )
 
 
 def test_function_remove_nonexistent(basic_http_client: System) -> None:
@@ -222,11 +235,12 @@ def test_function_remove_nonexistent(basic_http_client: System) -> None:
         params=None,
     )
 
-    attached_fn.detach(delete_output_collection=True)
+    collection.detach_function(attached_fn.name, delete_output_collection=True)
 
     # Trying to detach this function again should raise NotFoundError
     with pytest.raises(NotFoundError, match="does not exist"):
-        attached_fn.detach(delete_output_collection=True)
+        collection.detach_function(attached_fn.name, delete_output_collection=True)
+
 
 def test_attach_to_output_collection_fails(basic_http_client: System) -> None:
     """Test that attaching a function to an output collection fails"""
@@ -245,14 +259,17 @@ def test_attach_to_output_collection_fails(basic_http_client: System) -> None:
     )
     output_collection = client.get_collection(name="output_collection")
 
-    with pytest.raises(ChromaError, match="cannot attach function to an output collection"):
+    with pytest.raises(
+        ChromaError, match="cannot attach function to an output collection"
+    ):
         _ = output_collection.attach_function(
             name="test_function_2",
             function_id="record_counter",
             output_collection="output_collection_2",
             params=None,
         )
 
+
 def test_delete_output_collection_detaches_function(basic_http_client: System) -> None:
     """Test that deleting an output collection also detaches the attached function"""
     client = ClientCreator.from_system(basic_http_client)
@@ -277,6 +294,7 @@ def test_delete_output_collection_detaches_function(basic_http_client: System) -
     with pytest.raises(NotFoundError):
         input_collection.get_attached_function("my_function")
 
+
 def test_delete_orphaned_output_collection(basic_http_client: System) -> None:
     """Test that deleting an output collection from a recently detached function works"""
     client = ClientCreator.from_system(basic_http_client)
@@ -294,15 +312,15 @@ def test_delete_orphaned_output_collection(basic_http_client: System) -> None:
     )
     assert attached_fn is not None
 
-    attached_fn.detach(delete_output_collection=False)
+    input_collection.detach_function(attached_fn.name, delete_output_collection=False)
 
     # Delete the output collection directly
     client.delete_collection("output_collection")
 
     # The attached function should still exist but be marked as detached
     with pytest.raises(NotFoundError):
         input_collection.get_attached_function("my_function")
-    
+
     with pytest.raises(NotFoundError):
         # Try to use the function - it should fail since it's detached
-        client.get_collection("output_collection")
+        client.get_collection("output_collection")