zombie-squirrel 0.7.4__tar.gz → 0.8.0__tar.gz

{zombie_squirrel-0.7.4/src/zombie_squirrel.egg-info → zombie_squirrel-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-squirrel
-Version: 0.7.4
+Version: 0.8.0
 Summary: Generated from aind-library-template
 Author: Allen Institute for Neural Dynamics
 License: MIT
@@ -21,7 +21,7 @@ Dynamic: license-file
 ![Code Style](https://img.shields.io/badge/code%20style-black-black)
 [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
 ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
-![Coverage](https://img.shields.io/badge/coverage-99%25-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)
 ![Python](https://img.shields.io/badge/python->=3.10-blue?logo=python)
 
 <img src="zombie-squirrel_logo.png" width="400" alt="Logo (image from ChatGPT)">
@@ -37,10 +37,10 @@ pip install zombie-squirrel
 ### Set backend
 
 ```bash
-export TREE_SPECIES='s3'
+export FOREST_TYPE='S3'
 ```
 
-Options are 's3', 'MEMORY'.
+Options are 'S3', 'MEMORY'.
 
 ### Scurry (fetch) data
 

{zombie_squirrel-0.7.4 → zombie_squirrel-0.8.0}/README.md

@@ -4,7 +4,7 @@
 ![Code Style](https://img.shields.io/badge/code%20style-black-black)
 [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
 ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
-![Coverage](https://img.shields.io/badge/coverage-99%25-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)
 ![Python](https://img.shields.io/badge/python->=3.10-blue?logo=python)
 
 <img src="zombie-squirrel_logo.png" width="400" alt="Logo (image from ChatGPT)">
@@ -20,10 +20,10 @@ pip install zombie-squirrel
 ### Set backend
 
 ```bash
-export TREE_SPECIES='s3'
+export FOREST_TYPE='S3'
 ```
 
-Options are 's3', 'MEMORY'.
+Options are 'S3', 'MEMORY'.
 
 ### Scurry (fetch) data
 

{zombie_squirrel-0.7.4 → zombie_squirrel-0.8.0}/src/zombie_squirrel/__init__.py

@@ -3,9 +3,9 @@
 Provides functions to fetch and cache project names, subject IDs, and asset
 metadata from the AIND metadata database with support for multiple backends."""
 
-__version__ = "0.7.4"
+__version__ = "0.8.0"
 
-from zombie_squirrel.squirrels import (  # noqa: F401
+from zombie_squirrel.acorns import (  # noqa: F401
     asset_basics,
     raw_to_derived,
     source_data,

zombie_squirrel-0.7.4/src/zombie_squirrel/squirrels.py → zombie_squirrel-0.8.0/src/zombie_squirrel/acorns.py

@@ -1,4 +1,4 @@
-"""Squirrels: functions to fetch and cache data from MongoDB."""
+"""Acorns: functions to fetch and cache data from MongoDB."""
 
 import logging
 import os
@@ -8,41 +8,41 @@ from typing import Any
 import pandas as pd
 from aind_data_access_api.document_db import MetadataDbClient
 
-from zombie_squirrel.acorns import (
-    MemoryAcorn,
-    S3Acorn,
+from zombie_squirrel.forest import (
+    MemoryTree,
+    S3Tree,
 )
 
 # --- Backend setup ---------------------------------------------------
 
 API_GATEWAY_HOST = "api.allenneuraldynamics.org"
 
-tree_type = os.getenv("TREE_SPECIES", "memory").lower()
+forest_type = os.getenv("FOREST_TYPE", "memory").lower()
 
-if tree_type == "s3":  # pragma: no cover
-    logging.info("Using S3 acorn for caching")
-    ACORN = S3Acorn()
+if forest_type == "S3":  # pragma: no cover
+    logging.info("Using S3 forest for caching")
+    TREE = S3Tree()
 else:
-    logging.info("Using in-memory acorn for caching")
-    ACORN = MemoryAcorn()
+    logging.info("Using in-memory forest for caching")
+    TREE = MemoryTree()
 
-# --- Squirrel registry -----------------------------------------------------
+# --- Acorn registry -----------------------------------------------------
 
-SQUIRREL_REGISTRY: dict[str, Callable[[], Any]] = {}
+ACORN_REGISTRY: dict[str, Callable[[], Any]] = {}
 
 
-def register_squirrel(name: str):
-    """Decorator for registering new squirrels."""
+def register_acorn(name: str):
+    """Decorator for registering new acorns."""
 
     def decorator(func):
-        """Register function in squirrel registry."""
-        SQUIRREL_REGISTRY[name] = func
+        """Register function in acorn registry."""
+        ACORN_REGISTRY[name] = func
         return func
 
     return decorator
 
 
-# --- Squirrels -----------------------------------------------------
+# --- Acorns -----------------------------------------------------
 
 NAMES = {
     "upn": "unique_project_names",
@@ -53,7 +53,7 @@ NAMES = {
 }
 
 
-@register_squirrel(NAMES["upn"])
+@register_acorn(NAMES["upn"])
 def unique_project_names(force_update: bool = False) -> list[str]:
     """Fetch unique project names from metadata database.
 
@@ -65,7 +65,7 @@ def unique_project_names(force_update: bool = False) -> list[str]:
 
     Returns:
         List of unique project names."""
-    df = ACORN.scurry(NAMES["upn"])
+    df = TREE.scurry(NAMES["upn"])
 
     if df.empty or force_update:
         # If cache is missing, fetch data
@@ -81,12 +81,12 @@ def unique_project_names(force_update: bool = False) -> list[str]:
             ]
         )
         df = pd.DataFrame(unique_project_names)
-        ACORN.hide(NAMES["upn"], df)
+        TREE.hide(NAMES["upn"], df)
 
     return df["project_name"].tolist()
 
 
-@register_squirrel(NAMES["usi"])
+@register_acorn(NAMES["usi"])
 def unique_subject_ids(force_update: bool = False) -> list[str]:
     """Fetch unique subject IDs from metadata database.
 
@@ -98,7 +98,7 @@ def unique_subject_ids(force_update: bool = False) -> list[str]:
 
     Returns:
         List of unique subject IDs."""
-    df = ACORN.scurry(NAMES["usi"])
+    df = TREE.scurry(NAMES["usi"])
 
     if df.empty or force_update:
         # If cache is missing, fetch data
@@ -114,12 +114,12 @@ def unique_subject_ids(force_update: bool = False) -> list[str]:
             ]
         )
         df = pd.DataFrame(unique_subject_ids)
-        ACORN.hide(NAMES["usi"], df)
+        TREE.hide(NAMES["usi"], df)
 
     return df["subject_id"].tolist()
 
 
-@register_squirrel(NAMES["basics"])
+@register_acorn(NAMES["basics"])
 def asset_basics(force_update: bool = False) -> pd.DataFrame:
     """Fetch basic asset metadata including modalities, projects, and subject info.
 
@@ -133,7 +133,7 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
 
     Returns:
         DataFrame with basic asset metadata."""
-    df = ACORN.scurry(NAMES["basics"])
+    df = TREE.scurry(NAMES["basics"])
 
     FIELDS = [
         "data_description.modalities",
@@ -146,7 +146,6 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
         "subject.subject_details.genotype",
         "other_identifiers",
         "location",
-        "name",
     ]
 
     if df.empty or force_update:
@@ -165,7 +164,6 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
                 "process_date",
                 "genotype",
                 "location",
-                "name",
             ]
         )
         client = MetadataDbClient(
@@ -218,11 +216,10 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
 
             # Get the CO asset ID
             other_identifiers = record.get("other_identifiers", {})
-            code_ocean = None
             if other_identifiers:
-                co_list = other_identifiers.get("Code Ocean", None)
-                if co_list:
-                    code_ocean = co_list[0]
+                code_ocean = other_identifiers.get("Code Ocean", None)
+            else:
+                code_ocean = None
 
             flat_record = {
                 "_id": record["_id"],
@@ -237,7 +234,6 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
                 "process_date": process_date,
                 "genotype": record.get("subject", {}).get("subject_details", {}).get("genotype", None),
                 "location": record.get("location", None),
-                "name": record.get("name", None),
             }
             records.append(flat_record)
 
@@ -245,12 +241,12 @@ def asset_basics(force_update: bool = False) -> pd.DataFrame:
         new_df = pd.DataFrame(records)
         df = pd.concat([df[~df["_id"].isin(keep_ids)], new_df], ignore_index=True)
 
-        ACORN.hide(NAMES["basics"], df)
+        TREE.hide(NAMES["basics"], df)
 
     return df
 
 
-@register_squirrel(NAMES["d2r"])
+@register_acorn(NAMES["d2r"])
 def source_data(force_update: bool = False) -> pd.DataFrame:
     """Fetch source data references for derived records.
 
@@ -262,7 +258,7 @@ def source_data(force_update: bool = False) -> pd.DataFrame:
 
     Returns:
         DataFrame with _id and source_data columns."""
-    df = ACORN.scurry(NAMES["d2r"])
+    df = TREE.scurry(NAMES["d2r"])
 
     if df.empty or force_update:
         logging.info("Updating cache for source data")
@@ -287,12 +283,12 @@ def source_data(force_update: bool = False) -> pd.DataFrame:
             )
 
         df = pd.DataFrame(data)
-        ACORN.hide(NAMES["d2r"], df)
+        TREE.hide(NAMES["d2r"], df)
 
     return df
 
 
-@register_squirrel(NAMES["r2d"])
+@register_acorn(NAMES["r2d"])
 def raw_to_derived(force_update: bool = False) -> pd.DataFrame:
     """Fetch mapping of raw records to their derived records.
 
@@ -304,7 +300,7 @@ def raw_to_derived(force_update: bool = False) -> pd.DataFrame:
 
     Returns:
         DataFrame with _id and derived_records columns."""
-    df = ACORN.scurry(NAMES["r2d"])
+    df = TREE.scurry(NAMES["r2d"])
 
     if df.empty or force_update:
         logging.info("Updating cache for raw to derived mapping")
@@ -350,6 +346,6 @@ def raw_to_derived(force_update: bool = False) -> pd.DataFrame:
             )
 
         df = pd.DataFrame(data)
-        ACORN.hide(NAMES["r2d"], df)
+        TREE.hide(NAMES["r2d"], df)
 
     return df

zombie_squirrel-0.7.4/src/zombie_squirrel/acorns.py → zombie_squirrel-0.8.0/src/zombie_squirrel/forest.py

@@ -11,11 +11,11 @@ import pandas as pd
 from zombie_squirrel.utils import get_s3_cache_path, prefix_table_name
 
 
-class Acorn(ABC):
+class Tree(ABC):
     """Base class for a storage backend (the cache)."""
 
     def __init__(self) -> None:
-        """Initialize the Acorn."""
+        """Initialize the Tree."""
         super().__init__()
 
     @abstractmethod
@@ -29,7 +29,7 @@ class Acorn(ABC):
         pass  # pragma: no cover
 
 
-class S3Acorn(Acorn):
+class S3Tree(Tree):
     """Stores and retrieves caches using AWS S3 with parquet files."""
 
     def __init__(self) -> None:
@@ -79,7 +79,7 @@ class S3Acorn(Acorn):
             return pd.DataFrame()
 
 
-class MemoryAcorn(Acorn):
+class MemoryTree(Tree):
     """A simple in-memory backend for testing or local development."""
 
     def __init__(self) -> None:

zombie_squirrel-0.8.0/src/zombie_squirrel/sync.py

@@ -0,0 +1,18 @@
+"""Synchronization utilities for updating all cached data."""
+
+import logging
+
+from .acorns import ACORN_REGISTRY
+
+
+def hide_acorns():
+    """Trigger force update of all registered acorn functions.
+
+    Calls each acorn function with force_update=True to refresh
+    all cached data in the tree backend."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s"
+    )
+    for acorn in ACORN_REGISTRY.values():
+        acorn(force_update=True)

{zombie_squirrel-0.7.4 → zombie_squirrel-0.8.0/src/zombie_squirrel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-squirrel
-Version: 0.7.4
+Version: 0.8.0
 Summary: Generated from aind-library-template
 Author: Allen Institute for Neural Dynamics
 License: MIT
@@ -21,7 +21,7 @@ Dynamic: license-file
 ![Code Style](https://img.shields.io/badge/code%20style-black-black)
 [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
 ![Interrogate](https://img.shields.io/badge/interrogate-100.0%25-brightgreen)
-![Coverage](https://img.shields.io/badge/coverage-99%25-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)
 ![Python](https://img.shields.io/badge/python->=3.10-blue?logo=python)
 
 <img src="zombie-squirrel_logo.png" width="400" alt="Logo (image from ChatGPT)">
@@ -37,10 +37,10 @@ pip install zombie-squirrel
 ### Set backend
 
 ```bash
-export TREE_SPECIES='s3'
+export FOREST_TYPE='S3'
 ```
 
-Options are 's3', 'MEMORY'.
+Options are 'S3', 'MEMORY'.
 
 ### Scurry (fetch) data
 

{zombie_squirrel-0.7.4 → zombie_squirrel-0.8.0}/src/zombie_squirrel.egg-info/SOURCES.txt

@@ -4,7 +4,7 @@ pyproject.toml
 setup.py
 src/zombie_squirrel/__init__.py
 src/zombie_squirrel/acorns.py
-src/zombie_squirrel/squirrels.py
+src/zombie_squirrel/forest.py
 src/zombie_squirrel/sync.py
 src/zombie_squirrel/utils.py
 src/zombie_squirrel.egg-info/PKG-INFO
@@ -13,6 +13,6 @@ src/zombie_squirrel.egg-info/dependency_links.txt
 src/zombie_squirrel.egg-info/requires.txt
 src/zombie_squirrel.egg-info/top_level.txt
 tests/test_acorns.py
-tests/test_squirrels.py
 tests/test_sync.py
+tests/test_trees.py
 tests/test_utils.py

zombie_squirrel-0.7.4/tests/test_squirrels.py → zombie_squirrel-0.8.0/tests/test_acorns.py

@@ -1,16 +1,16 @@
-"""Unit tests for zombie_squirrel.squirrels module.
+"""Unit tests for zombie_squirrel.acorns module.
 
-Tests for squirrel functions, caching, and registry mechanism."""
+Tests for acorn functions, caching, and registry mechanism."""
 
 import unittest
 from unittest.mock import MagicMock, patch
 
 import pandas as pd
 
-from zombie_squirrel.acorns import MemoryAcorn
-from zombie_squirrel.squirrels import (
+from zombie_squirrel.forest import MemoryTree
+from zombie_squirrel.acorns import (
     NAMES,
-    SQUIRREL_REGISTRY,
+    ACORN_REGISTRY,
     asset_basics,
     raw_to_derived,
     source_data,
@@ -19,20 +19,20 @@ from zombie_squirrel.squirrels import (
 )
 
 
-class TestSquirrelRegistration(unittest.TestCase):
-    """Tests for squirrel registration mechanism."""
+class TestAcornRegistration(unittest.TestCase):
+    """Tests for acorn registration mechanism."""
 
-    def test_squirrel_registry_contains_all_functions(self):
-        """Test that all squirrel functions are registered."""
-        self.assertIn(NAMES["upn"], SQUIRREL_REGISTRY)
-        self.assertIn(NAMES["usi"], SQUIRREL_REGISTRY)
-        self.assertIn(NAMES["basics"], SQUIRREL_REGISTRY)
-        self.assertIn(NAMES["d2r"], SQUIRREL_REGISTRY)
-        self.assertIn(NAMES["r2d"], SQUIRREL_REGISTRY)
+    def test_acorn_registry_contains_all_functions(self):
+        """Test that all acorn functions are registered."""
+        self.assertIn(NAMES["upn"], ACORN_REGISTRY)
+        self.assertIn(NAMES["usi"], ACORN_REGISTRY)
+        self.assertIn(NAMES["basics"], ACORN_REGISTRY)
+        self.assertIn(NAMES["d2r"], ACORN_REGISTRY)
+        self.assertIn(NAMES["r2d"], ACORN_REGISTRY)
 
     def test_registry_values_are_callable(self):
         """Test that registry values are callable functions."""
-        for name, func in SQUIRREL_REGISTRY.items():
+        for name, func in ACORN_REGISTRY.items():
             self.assertTrue(callable(func), f"{name} is not callable")
 
     def test_names_dict_completeness(self):
@@ -43,23 +43,23 @@ class TestSquirrelRegistration(unittest.TestCase):
 
 
 class TestUniqueProjectNames(unittest.TestCase):
-    """Tests for unique_project_names squirrel."""
+    """Tests for unique_project_names acorn."""
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_project_names_cache_hit(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_project_names_cache_hit(self, mock_client_class, mock_tree):
         """Test returning cached project names."""
         cached_df = pd.DataFrame({"project_name": ["proj1", "proj2", "proj3"]})
-        mock_acorn.hide(NAMES["upn"], cached_df)
+        mock_tree.hide(NAMES["upn"], cached_df)
 
         result = unique_project_names()
 
         self.assertEqual(result, ["proj1", "proj2", "proj3"])
         mock_client_class.assert_not_called()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_project_names_cache_miss(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_project_names_cache_miss(self, mock_client_class, mock_tree):
         """Test fetching project names when cache is empty."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -74,12 +74,12 @@ class TestUniqueProjectNames(unittest.TestCase):
         mock_client_class.assert_called_once()
         mock_client_instance.aggregate_docdb_records.assert_called_once()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_project_names_force_update(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_project_names_force_update(self, mock_client_class, mock_tree):
         """Test force_update bypasses cache."""
         cached_df = pd.DataFrame({"project_name": ["old_proj"]})
-        mock_acorn.hide(NAMES["upn"], cached_df)
+        mock_tree.hide(NAMES["upn"], cached_df)
 
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -94,21 +94,21 @@ class TestUniqueProjectNames(unittest.TestCase):
 class TestUniqueSubjectIds(unittest.TestCase):
     """Tests for unique_subject_ids squirrel."""
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_subject_ids_cache_hit(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_subject_ids_cache_hit(self, mock_client_class, mock_tree):
         """Test returning cached subject IDs."""
         cached_df = pd.DataFrame({"subject_id": ["sub001", "sub002"]})
-        mock_acorn.hide(NAMES["usi"], cached_df)
+        mock_tree.hide(NAMES["usi"], cached_df)
 
         result = unique_subject_ids()
 
         self.assertEqual(result, ["sub001", "sub002"])
         mock_client_class.assert_not_called()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_subject_ids_cache_miss(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_subject_ids_cache_miss(self, mock_client_class, mock_tree):
         """Test fetching subject IDs when cache is empty."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -122,12 +122,12 @@ class TestUniqueSubjectIds(unittest.TestCase):
         self.assertEqual(result, ["sub001", "sub002"])
         mock_client_class.assert_called_once()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_unique_subject_ids_force_update(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_unique_subject_ids_force_update(self, mock_client_class, mock_tree):
         """Test force_update bypasses cache."""
         cached_df = pd.DataFrame({"subject_id": ["old_sub"]})
-        mock_acorn.hide(NAMES["usi"], cached_df)
+        mock_tree.hide(NAMES["usi"], cached_df)
 
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -141,9 +141,9 @@ class TestUniqueSubjectIds(unittest.TestCase):
 class TestAssetBasics(unittest.TestCase):
     """Tests for asset_basics squirrel."""
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_asset_basics_cache_hit(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_asset_basics_cache_hit(self, mock_client_class, mock_tree):
         """Test returning cached asset basics."""
         cached_df = pd.DataFrame(
             {
@@ -163,7 +163,7 @@ class TestAssetBasics(unittest.TestCase):
                 ],
             }
         )
-        mock_acorn.hide(NAMES["basics"], cached_df)
+        mock_tree.hide(NAMES["basics"], cached_df)
 
         result = asset_basics()
 
@@ -171,9 +171,9 @@ class TestAssetBasics(unittest.TestCase):
         self.assertListEqual(list(result["_id"]), ["id1", "id2"])
         mock_client_class.assert_not_called()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_asset_basics_cache_miss(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_asset_basics_cache_miss(self, mock_client_class, mock_tree):
         """Test fetching asset basics when cache is empty."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -202,10 +202,10 @@ class TestAssetBasics(unittest.TestCase):
         self.assertEqual(result.iloc[0]["modalities"], "img")
         self.assertEqual(result.iloc[0]["project_name"], "proj1")
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
     def test_asset_basics_with_data_processes(
-        self, mock_client_class, mock_acorn
+        self, mock_client_class, mock_tree
     ):
         """Test asset_basics includes process_date from data_processes."""
         mock_client_instance = MagicMock()
@@ -240,10 +240,10 @@ class TestAssetBasics(unittest.TestCase):
         self.assertEqual(result.iloc[0]["_id"], "id1")
         self.assertEqual(result.iloc[0]["process_date"], "2023-01-20")
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
     def test_asset_basics_incremental_update(
-        self, mock_client_class, mock_acorn
+        self, mock_client_class, mock_tree
     ):
         """Test incremental cache update with partial data refresh."""
         mock_client_instance = MagicMock()
@@ -277,13 +277,83 @@ class TestAssetBasics(unittest.TestCase):
         self.assertEqual(len(result), 1)
         self.assertEqual(result.iloc[0]["_id"], "id2")
 
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_asset_basics_with_other_identifiers_no_code_ocean(
+        self, mock_client_class, mock_tree
+    ):
+        """Test asset_basics when other_identifiers exists but has no Code Ocean."""
+        mock_client_instance = MagicMock()
+        mock_client_class.return_value = mock_client_instance
+
+        mock_client_instance.retrieve_docdb_records.return_value = [
+            {
+                "_id": "id1",
+                "_last_modified": "2023-01-01",
+                "data_description": {
+                    "modalities": [{"abbreviation": "img"}],
+                    "project_name": "proj1",
+                    "data_level": "raw",
+                },
+                "subject": {"subject_id": "sub001"},
+                "acquisition": {
+                    "acquisition_start_time": "2023-01-01T10:00:00",
+                    "acquisition_end_time": "2023-01-01T11:00:00",
+                },
+                "other_identifiers": {"Some Other Field": "value123"},
+            }
+        ]
+
+        result = asset_basics()
+
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result.iloc[0]["_id"], "id1")
+        self.assertIsNone(result.iloc[0]["code_ocean"])
+
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_asset_basics_with_code_ocean_identifier(
+        self, mock_client_class, mock_tree
+    ):
+        """Test asset_basics when other_identifiers contains Code Ocean."""
+        mock_client_instance = MagicMock()
+        mock_client_class.return_value = mock_client_instance
+
+        mock_client_instance.retrieve_docdb_records.return_value = [
+            {
+                "_id": "id1",
+                "_last_modified": "2023-01-01",
+                "data_description": {
+                    "modalities": [{"abbreviation": "img"}],
+                    "project_name": "proj1",
+                    "data_level": "raw",
+                },
+                "subject": {"subject_id": "sub001"},
+                "acquisition": {
+                    "acquisition_start_time": "2023-01-01T10:00:00",
+                    "acquisition_end_time": "2023-01-01T11:00:00",
+                },
+                "other_identifiers": {
+                    "Code Ocean": ["df429003-91a0-45d2-8457-66b156ad8bfa"]
+                },
+            }
+        ]
+
+        result = asset_basics()
+
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result.iloc[0]["_id"], "id1")
+        self.assertEqual(
+            result.iloc[0]["code_ocean"], ["df429003-91a0-45d2-8457-66b156ad8bfa"]
+        )
+
 
 class TestSourceData(unittest.TestCase):
     """Tests for source_data squirrel."""
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_source_data_cache_hit(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_source_data_cache_hit(self, mock_client_class, mock_tree):
         """Test returning cached source data."""
         cached_df = pd.DataFrame(
             {
@@ -291,7 +361,7 @@ class TestSourceData(unittest.TestCase):
                 "source_data": ["source1, source2", "source3"],
             }
         )
-        mock_acorn.hide(NAMES["d2r"], cached_df)
+        mock_tree.hide(NAMES["d2r"], cached_df)
 
         result = source_data()
 
@@ -299,9 +369,9 @@ class TestSourceData(unittest.TestCase):
         self.assertEqual(result.iloc[0]["source_data"], "source1, source2")
         mock_client_class.assert_not_called()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_source_data_cache_miss(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_source_data_cache_miss(self, mock_client_class, mock_tree):
         """Test fetching source data when cache is empty."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -319,9 +389,9 @@ class TestSourceData(unittest.TestCase):
         self.assertEqual(result.iloc[0]["source_data"], "src1, src2")
         self.assertEqual(result.iloc[1]["source_data"], "")
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_source_data_force_update(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_source_data_force_update(self, mock_client_class, mock_tree):
         """Test force_update bypasses cache."""
         cached_df = pd.DataFrame(
             {
@@ -329,7 +399,7 @@ class TestSourceData(unittest.TestCase):
                 "source_data": ["old_source"],
             }
         )
-        mock_acorn.hide(NAMES["d2r"], cached_df)
+        mock_tree.hide(NAMES["d2r"], cached_df)
 
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -349,9 +419,9 @@ class TestSourceData(unittest.TestCase):
 class TestRawToDerived(unittest.TestCase):
     """Tests for raw_to_derived squirrel."""
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_raw_to_derived_cache_hit(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_raw_to_derived_cache_hit(self, mock_client_class, mock_tree):
         """Test returning cached raw to derived mapping."""
         cached_df = pd.DataFrame(
             {
@@ -359,7 +429,7 @@ class TestRawToDerived(unittest.TestCase):
                 "derived_records": ["derived1, derived2", "derived3"],
             }
         )
-        mock_acorn.hide(NAMES["r2d"], cached_df)
+        mock_tree.hide(NAMES["r2d"], cached_df)
 
         result = raw_to_derived()
 
@@ -367,9 +437,9 @@ class TestRawToDerived(unittest.TestCase):
         self.assertEqual(result.iloc[0]["derived_records"], "derived1, derived2")
         mock_client_class.assert_not_called()
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_raw_to_derived_cache_miss(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_raw_to_derived_cache_miss(self, mock_client_class, mock_tree):
         """Test fetching raw to derived mapping when cache is empty."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -400,9 +470,9 @@ class TestRawToDerived(unittest.TestCase):
         self.assertEqual(raw1_row.iloc[0]["derived_records"], "derived1, derived2")
         self.assertEqual(raw2_row.iloc[0]["derived_records"], "derived2")
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_raw_to_derived_no_derived(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_raw_to_derived_no_derived(self, mock_client_class, mock_tree):
         """Test raw records with no derived data."""
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance
@@ -417,9 +487,9 @@ class TestRawToDerived(unittest.TestCase):
         self.assertEqual(len(result), 1)
         self.assertEqual(result.iloc[0]["derived_records"], "")
 
-    @patch("zombie_squirrel.squirrels.ACORN", new_callable=MemoryAcorn)
-    @patch("zombie_squirrel.squirrels.MetadataDbClient")
-    def test_raw_to_derived_force_update(self, mock_client_class, mock_acorn):
+    @patch("zombie_squirrel.acorns.TREE", new_callable=MemoryTree)
+    @patch("zombie_squirrel.acorns.MetadataDbClient")
+    def test_raw_to_derived_force_update(self, mock_client_class, mock_tree):
         """Test force_update bypasses cache."""
         cached_df = pd.DataFrame(
             {
@@ -427,7 +497,7 @@ class TestRawToDerived(unittest.TestCase):
                 "derived_records": ["old_derived"],
             }
         )
-        mock_acorn.hide(NAMES["r2d"], cached_df)
+        mock_tree.hide(NAMES["r2d"], cached_df)
 
         mock_client_instance = MagicMock()
         mock_client_class.return_value = mock_client_instance

zombie_squirrel-0.8.0/tests/test_sync.py

@@ -0,0 +1,85 @@
+"""Unit tests for zombie_squirrel.sync module.
+
+Tests for cache synchronization functions."""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from zombie_squirrel.sync import hide_acorns
+
+
+class TestHideAcorns(unittest.TestCase):
+    """Tests for the hide_acorns function."""
+
+    @patch("zombie_squirrel.sync.ACORN_REGISTRY")
+    def test_hide_acorns_calls_all_acorns(self, mock_registry):
+        """Test that hide_acorns calls all registered acorns with force_update."""
+        mock_acorn1 = MagicMock()
+        mock_acorn2 = MagicMock()
+        mock_acorn3 = MagicMock()
+
+        mock_registry.values.return_value = [
+            mock_acorn1,
+            mock_acorn2,
+            mock_acorn3,
+        ]
+
+        hide_acorns()
+
+        mock_acorn1.assert_called_once_with(force_update=True)
+        mock_acorn2.assert_called_once_with(force_update=True)
+        mock_acorn3.assert_called_once_with(force_update=True)
+
+    @patch("zombie_squirrel.sync.ACORN_REGISTRY")
+    def test_hide_acorns_empty_registry(self, mock_registry):
+        """Test hide_acorns with empty registry."""
+        mock_registry.values.return_value = []
+
+        # Should not raise any exception
+        hide_acorns()
+
+        mock_registry.values.assert_called_once()
+
+    @patch("zombie_squirrel.sync.ACORN_REGISTRY")
+    def test_hide_acorns_single_acorn(self, mock_registry):
+        """Test hide_acorns with a single acorn."""
+        mock_acorn = MagicMock()
+        mock_registry.values.return_value = [mock_acorn]
+
+        hide_acorns()
+
+        mock_acorn.assert_called_once_with(force_update=True)
+
+    @patch("zombie_squirrel.sync.ACORN_REGISTRY")
+    def test_hide_acorns_acorn_order_independent(self, mock_registry):
+        """Test that hide_acorns calls all acorns regardless of order."""
+        mock_acorns = [MagicMock() for _ in range(5)]
+        mock_registry.values.return_value = mock_acorns
+
+        hide_acorns()
+
+        # All acorns should be called with force_update=True
+        for acorn in mock_acorns:
+            acorn.assert_called_once_with(force_update=True)
+
+    @patch("zombie_squirrel.sync.ACORN_REGISTRY")
+    def test_hide_acorns_propagates_exceptions(self, mock_registry):
+        """Test that exceptions from acorns are propagated."""
+        mock_acorn_ok = MagicMock()
+        mock_acorn_error = MagicMock(side_effect=Exception("Update failed"))
+
+        mock_registry.values.return_value = [
+            mock_acorn_ok,
+            mock_acorn_error,
+        ]
+
+        with self.assertRaises(Exception) as context:
+            hide_acorns()
+
+        self.assertEqual(str(context.exception), "Update failed")
+        # First acorn should have been called
+        mock_acorn_ok.assert_called_once_with(force_update=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

zombie_squirrel-0.7.4/tests/test_acorns.py → zombie_squirrel-0.8.0/tests/test_trees.py

@@ -1,73 +1,73 @@
-"""Unit tests for zombie_squirrel.acorns module.
+"""Unit tests for zombie_squirrel.trees module.
 
 Tests for abstract base class, memory backend, and S3 backend
 for caching functionality."""
 
 import unittest
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, patch
 
 import pandas as pd
 
-from zombie_squirrel.acorns import (
-    Acorn,
-    MemoryAcorn,
-    S3Acorn,
+from zombie_squirrel.forest import (
+    Tree,
+    MemoryTree,
+    S3Tree,
 )
 
 
-class TestAcornAbstractClass(unittest.TestCase):
-    """Tests for Acorn abstract base class."""
+class TestTreeAbstractClass(unittest.TestCase):
+    """Tests for Tree abstract base class."""
 
-    def test_acorn_cannot_be_instantiated(self):
-        """Test that Acorn abstract class cannot be instantiated."""
+    def test_tree_cannot_be_instantiated(self):
+        """Test that Tree abstract class cannot be instantiated."""
         with self.assertRaises(TypeError):
-            Acorn()
+            Tree()
 
-    def test_acorn_subclass_must_implement_hide(self):
+    def test_tree_subclass_must_implement_hide(self):
         """Test that subclasses must implement hide method."""
 
-        class IncompleteAcorn(Acorn):
-            """Incomplete Acorn subclass missing hide method."""
+        class IncompleteTree(Tree):
+            """Incomplete Tree subclass missing hide method."""
 
             def scurry(self, table_name: str) -> pd.DataFrame:  # pragma: no cover
                 """Fetch records from the cache."""
                 return pd.DataFrame()
 
         with self.assertRaises(TypeError):
-            IncompleteAcorn()
+            IncompleteTree()
 
-    def test_acorn_subclass_must_implement_scurry(self):
+    def test_tree_subclass_must_implement_scurry(self):
         """Test that subclasses must implement scurry method."""
 
-        class IncompleteAcorn(Acorn):
-            """Incomplete Acorn subclass missing scurry method."""
+        class IncompleteTree(Tree):
+            """Incomplete Tree subclass missing scurry method."""
 
             def hide(self, table_name: str, data: pd.DataFrame) -> None:  # pragma: no cover
                 """Store records in the cache."""
                 pass
 
         with self.assertRaises(TypeError):
-            IncompleteAcorn()
+            IncompleteTree()
 
 
-class TestMemoryAcorn(unittest.TestCase):
-    """Tests for MemoryAcorn implementation."""
+class TestMemoryTree(unittest.TestCase):
+    """Tests for MemoryTree implementation."""
 
     def setUp(self):
-        """Initialize a fresh MemoryAcorn for each test."""
-        self.acorn = MemoryAcorn()
+        """Initialize a fresh MemoryTree for each test."""
+        self.tree = MemoryTree()
 
     def test_hide_and_scurry_basic(self):
         """Test basic hide and scurry operations."""
         df = pd.DataFrame({"col1": [1, 2, 3], "col2": ["a", "b", "c"]})
-        self.acorn.hide("test_table", df)
+        self.tree.hide("test_table", df)
 
-        retrieved = self.acorn.scurry("test_table")
+        retrieved = self.tree.scurry("test_table")
         pd.testing.assert_frame_equal(df, retrieved)
 
     def test_scurry_empty_table(self):
         """Test scurrying a table that doesn't exist returns empty DataFrame."""
-        result = self.acorn.scurry("nonexistent_table")
+        result = self.tree.scurry("nonexistent_table")
         self.assertTrue(result.empty)
         self.assertIsInstance(result, pd.DataFrame)
 
@@ -76,10 +76,10 @@ class TestMemoryAcorn(unittest.TestCase):
         df1 = pd.DataFrame({"col1": [1, 2, 3]})
         df2 = pd.DataFrame({"col1": [4, 5, 6]})
 
-        self.acorn.hide("table", df1)
-        self.acorn.hide("table", df2)
+        self.tree.hide("table", df1)
+        self.tree.hide("table", df2)
 
-        retrieved = self.acorn.scurry("table")
+        retrieved = self.tree.scurry("table")
         pd.testing.assert_frame_equal(df2, retrieved)
 
     def test_multiple_tables(self):
@@ -87,11 +87,11 @@ class TestMemoryAcorn(unittest.TestCase):
         df1 = pd.DataFrame({"col1": [1, 2]})
         df2 = pd.DataFrame({"col2": ["a", "b"]})
 
-        self.acorn.hide("table1", df1)
-        self.acorn.hide("table2", df2)
+        self.tree.hide("table1", df1)
+        self.tree.hide("table2", df2)
 
-        retrieved1 = self.acorn.scurry("table1")
-        retrieved2 = self.acorn.scurry("table2")
+        retrieved1 = self.tree.scurry("table1")
+        retrieved2 = self.tree.scurry("table2")
 
         pd.testing.assert_frame_equal(df1, retrieved1)
         pd.testing.assert_frame_equal(df2, retrieved2)
@@ -99,34 +99,34 @@ class TestMemoryAcorn(unittest.TestCase):
     def test_hide_empty_dataframe(self):
         """Test hiding an empty DataFrame."""
         df = pd.DataFrame()
-        self.acorn.hide("empty_table", df)
+        self.tree.hide("empty_table", df)
 
-        retrieved = self.acorn.scurry("empty_table")
+        retrieved = self.tree.scurry("empty_table")
         pd.testing.assert_frame_equal(df, retrieved)
 
 
-class TestS3Acorn(unittest.TestCase):
-    """Tests for S3Acorn implementation with mocking."""
+class TestS3Tree(unittest.TestCase):
+    """Tests for S3Tree implementation with mocking."""
 
-    @patch("zombie_squirrel.acorns.boto3.client")
+    @patch("zombie_squirrel.forest.boto3.client")
     def test_s3_acorn_initialization(self, mock_boto3_client):
-        """Test S3Acorn initialization."""
+        """Test S3Tree initialization."""
         mock_s3_client = MagicMock()
         mock_boto3_client.return_value = mock_s3_client
 
-        acorn = S3Acorn()
+        acorn = S3Tree()
 
         self.assertEqual(acorn.bucket, "aind-scratch-data")
         self.assertEqual(acorn.s3_client, mock_s3_client)
         mock_boto3_client.assert_called_once_with("s3")
 
-    @patch("zombie_squirrel.acorns.boto3.client")
+    @patch("zombie_squirrel.forest.boto3.client")
     def test_s3_hide(self, mock_boto3_client):
-        """Test S3Acorn.hide method writes to S3."""
+        """Test S3Tree.hide method writes to S3."""
         mock_s3_client = MagicMock()
         mock_boto3_client.return_value = mock_s3_client
 
-        acorn = S3Acorn()
+        acorn = S3Tree()
         df = pd.DataFrame({"col1": [1, 2, 3]})
 
         acorn.hide("test_table", df)
@@ -139,10 +139,10 @@ class TestS3Acorn(unittest.TestCase):
         )
         self.assertIsInstance(call_kwargs["Body"], bytes)
 
-    @patch("zombie_squirrel.acorns.duckdb.query")
-    @patch("zombie_squirrel.acorns.boto3.client")
+    @patch("zombie_squirrel.forest.duckdb.query")
+    @patch("zombie_squirrel.forest.boto3.client")
     def test_s3_scurry(self, mock_boto3_client, mock_duckdb_query):
-        """Test S3Acorn.scurry method reads from S3 using DuckDB."""
+        """Test S3Tree.scurry method reads from S3 using DuckDB."""
         mock_s3_client = MagicMock()
         mock_boto3_client.return_value = mock_s3_client
 
@@ -151,7 +151,7 @@ class TestS3Acorn(unittest.TestCase):
         mock_result.to_df.return_value = expected_df
         mock_duckdb_query.return_value = mock_result
 
-        acorn = S3Acorn()
+        acorn = S3Tree()
         result = acorn.scurry("test_table")
 
         # Verify DuckDB was called with correct S3 path
@@ -163,17 +163,17 @@ class TestS3Acorn(unittest.TestCase):
         )
         pd.testing.assert_frame_equal(result, expected_df)
 
-    @patch("zombie_squirrel.acorns.duckdb.query")
-    @patch("zombie_squirrel.acorns.boto3.client")
+    @patch("zombie_squirrel.forest.duckdb.query")
+    @patch("zombie_squirrel.forest.boto3.client")
     def test_s3_scurry_handles_error(
         self, mock_boto3_client, mock_duckdb_query
     ):
-        """Test S3Acorn.scurry returns empty DataFrame on error."""
+        """Test S3Tree.scurry returns empty DataFrame on error."""
         mock_s3_client = MagicMock()
         mock_boto3_client.return_value = mock_s3_client
         mock_duckdb_query.side_effect = Exception("S3 access error")
 
-        acorn = S3Acorn()
+        acorn = S3Tree()
         result = acorn.scurry("nonexistent_table")
 
         self.assertTrue(result.empty)

zombie_squirrel-0.7.4/src/zombie_squirrel/sync.py

@@ -1,18 +0,0 @@
-"""Synchronization utilities for updating all cached data."""
-
-import logging
-
-from .squirrels import SQUIRREL_REGISTRY
-
-
-def hide_acorns():
-    """Trigger force update of all registered squirrel functions.
-
-    Calls each squirrel function with force_update=True to refresh
-    all cached data in the acorn backend."""
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s %(levelname)s %(message)s"
-    )
-    for squirrel in SQUIRREL_REGISTRY.values():
-        squirrel(force_update=True)

zombie_squirrel-0.7.4/tests/test_sync.py

@@ -1,85 +0,0 @@
-"""Unit tests for zombie_squirrel.sync module.
-
-Tests for cache synchronization functions."""
-
-import unittest
-from unittest.mock import MagicMock, patch
-
-from zombie_squirrel.sync import hide_acorns
-
-
-class TestHideAcorns(unittest.TestCase):
-    """Tests for the hide_acorns function."""
-
-    @patch("zombie_squirrel.sync.SQUIRREL_REGISTRY")
-    def test_hide_acorns_calls_all_squirrels(self, mock_registry):
-        """Test that hide_acorns calls all registered squirrels with force_update."""
-        mock_squirrel1 = MagicMock()
-        mock_squirrel2 = MagicMock()
-        mock_squirrel3 = MagicMock()
-
-        mock_registry.values.return_value = [
-            mock_squirrel1,
-            mock_squirrel2,
-            mock_squirrel3,
-        ]
-
-        hide_acorns()
-
-        mock_squirrel1.assert_called_once_with(force_update=True)
-        mock_squirrel2.assert_called_once_with(force_update=True)
-        mock_squirrel3.assert_called_once_with(force_update=True)
-
-    @patch("zombie_squirrel.sync.SQUIRREL_REGISTRY")
-    def test_hide_acorns_empty_registry(self, mock_registry):
-        """Test hide_acorns with empty registry."""
-        mock_registry.values.return_value = []
-
-        # Should not raise any exception
-        hide_acorns()
-
-        mock_registry.values.assert_called_once()
-
-    @patch("zombie_squirrel.sync.SQUIRREL_REGISTRY")
-    def test_hide_acorns_single_squirrel(self, mock_registry):
-        """Test hide_acorns with a single squirrel."""
-        mock_squirrel = MagicMock()
-        mock_registry.values.return_value = [mock_squirrel]
-
-        hide_acorns()
-
-        mock_squirrel.assert_called_once_with(force_update=True)
-
-    @patch("zombie_squirrel.sync.SQUIRREL_REGISTRY")
-    def test_hide_acorns_squirrel_order_independent(self, mock_registry):
-        """Test that hide_acorns calls all squirrels regardless of order."""
-        mock_squirrels = [MagicMock() for _ in range(5)]
-        mock_registry.values.return_value = mock_squirrels
-
-        hide_acorns()
-
-        # All squirrels should be called with force_update=True
-        for squirrel in mock_squirrels:
-            squirrel.assert_called_once_with(force_update=True)
-
-    @patch("zombie_squirrel.sync.SQUIRREL_REGISTRY")
-    def test_hide_acorns_propagates_exceptions(self, mock_registry):
-        """Test that exceptions from squirrels are propagated."""
-        mock_squirrel_ok = MagicMock()
-        mock_squirrel_error = MagicMock(side_effect=Exception("Update failed"))
-
-        mock_registry.values.return_value = [
-            mock_squirrel_ok,
-            mock_squirrel_error,
-        ]
-
-        with self.assertRaises(Exception) as context:
-            hide_acorns()
-
-        self.assertEqual(str(context.exception), "Update failed")
-        # First squirrel should have been called
-        mock_squirrel_ok.assert_called_once_with(force_update=True)
-
-
-if __name__ == "__main__":
-    unittest.main()