code: def test_asset_dependencies():
      """
      Test that MyAsset can have model dependencies of any kind
      (SomeAsset, SomeModel, SomeAsyncModel), loaded and available during its _load.
      """
  
      class SomeAsset(Asset):
          CONFIGURATIONS = {"some_asset": {}}
  
          def _load(self) -> None:
              self.data = "some_asset"
  
      class SomeModel(Model):
          CONFIGURATIONS = {"some_model": {}}
  
          def _load(self) -> None:
              self.data = "some_model"
  
          def _predict(self, _):
              return self.data
  
      class SomeAsyncModel(AsyncModel):
          CONFIGURATIONS = {"some_async_model": {}}
  
          def _load(self) -> None:
              self.data = "some_async_model"
  
          async def _predict(self, _):
              await asyncio.sleep(0)
              return self.data
  
      class MyAsset(Asset):
          CONFIGURATIONS = {
              "my_asset": {
                  "model_dependencies": {
                      "some_asset",
                      "some_model",
                      "some_async_model",
                  }
              }
          }
  
          def _load(self) -> None:
              self.data = {
                  "my_asset": [
                      self.model_dependencies["some_asset"].data,
                      self.model_dependencies["some_model"].predict(
                          None
                      ),
                      self.model_dependencies[
                          "some_async_model"
                      ].predict(None),
                  ]
              }
  
      class MyModel(Model):
          CONFIGURATIONS = {
              "my_model": {"model_dependencies": {"my_asset"}}
          }
  
          def _predict(self, _):
              return self.model_dependencies["my_asset"].data
  
      model = load_model(
          "my_model",
          models=[
              MyModel,
              MyAsset,
              SomeAsset,
              SomeModel,
              SomeAsyncModel,
          ],
      )
      assert model.predict(None) == {
          "my_asset": ["some_asset", "some_model", "some_async_model"]
      }
  
imports: import asyncio
  import os
  import pytest
  from modelkit.assets.errors import AssetDoesNotExistError, InvalidAssetSpecError
  from modelkit.core import errors
  from modelkit.core.library import ConfigurationNotFoundException, ModelLibrary, download_assets, load_model
  from modelkit.core.model import Asset, AsyncModel, Model
  from modelkit.core.model_configuration import ModelConfiguration, _configurations_from_objects, configure, list_assets
  from modelkit.core.settings import LibrarySettings
  from tests import TEST_DIR, testmodels
  from tests.assets.test_versioning import test_versioning
label_desc: Use image node_id 24 for calling a global function with example usage: test_asset_dependencies() and returns: self, self, self