Cache describe_interface and other endpoints (#1932)

* Cache describe_interface components

* make style

* Cache describe and schema

* Address PR Comment & Fix Tests

* Update inference/core/workflows/execution_engine/introspection/schema_parser.py

Author: yeldarby

inference/core/workflows/execution_engine/introspection/blocks_loader.py

@@ -4,7 +4,7 @@
 from collections import Counter
 from copy import copy
 from functools import lru_cache
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version
@@ -50,10 +50,39 @@
 WORKFLOWS_CORE_PLUGIN_NAME = "workflows_core"
 
 
+def _get_env_configuration_state() -> Tuple[Tuple[str, ...], bool]:
+    """
+    Returns current environment configuration state for cache keying.
+    This ensures caches are invalidated when plugins or enterprise blocks change.
+    """
+    plugins = tuple(get_plugin_modules())
+    return (plugins, LOAD_ENTERPRISE_BLOCKS)
+
+
+def clear_caches() -> None:
+    """
+    Clear all LRU caches in this module.
+    Useful for testing or when environment configuration changes.
+    """
+    _cached_describe_available_blocks.cache_clear()
+    load_core_workflow_blocks.cache_clear()
+    _cached_load_all_defined_kinds.cache_clear()
+    _cached_model_json_schema.cache_clear()
+    _cached_describe_outputs.cache_clear()
+
+
 def describe_available_blocks(
     dynamic_blocks: List[BlockSpecification],
     execution_engine_version: Optional[Union[str, Version]] = None,
 ) -> BlocksDescription:
+    # Fast path: cache for common case with no dynamic blocks
+    if not dynamic_blocks:
+        env_state = _get_env_configuration_state()
+        return _cached_describe_available_blocks(
+            execution_engine_version=execution_engine_version,
+            env_state=env_state,
+        )
+
     blocks = (
         load_workflow_blocks(execution_engine_version=execution_engine_version)
         + dynamic_blocks
@@ -87,7 +116,54 @@ def describe_available_blocks(
             )
         )
     _validate_loaded_blocks_manifest_type_identifiers(blocks=result)
-    declared_kinds = load_all_defined_kinds()
+    declared_kinds = _cached_load_all_defined_kinds(
+        env_state=_get_env_configuration_state()
+    )
+    return BlocksDescription(blocks=result, declared_kinds=declared_kinds)
+
+
+@lru_cache(maxsize=8)
+def _cached_describe_available_blocks(
+    execution_engine_version: Optional[Union[str, Version]] = None,
+    env_state: Tuple[Tuple[str, ...], bool] = None,
+) -> BlocksDescription:
+    """Cached version for when there are no dynamic blocks (common case).
+
+    Args:
+        execution_engine_version: Version filter for blocks
+        env_state: Tuple of (plugins, enterprise_blocks_flag) for cache invalidation
+    """
+    blocks = load_workflow_blocks(execution_engine_version=execution_engine_version)
+    result = []
+    for block in blocks:
+        block_schema = _cached_model_json_schema(block.manifest_class)
+        outputs_manifest = _cached_describe_outputs(block.manifest_class)
+        manifest_type_identifiers = get_manifest_type_identifiers(
+            block_schema=block_schema,
+            block_source=block.block_source,
+            block_identifier=block.identifier,
+        )
+        result.append(
+            BlockDescription(
+                manifest_class=block.manifest_class,
+                block_class=block.block_class,
+                block_schema=block_schema,
+                outputs_manifest=outputs_manifest,
+                block_source=block.block_source,
+                fully_qualified_block_class_name=block.identifier,
+                human_friendly_block_name=build_human_friendly_block_name(
+                    fully_qualified_name=block.identifier, block_schema=block_schema
+                ),
+                manifest_type_identifier=manifest_type_identifiers[0],
+                manifest_type_identifier_aliases=manifest_type_identifiers[1:],
+                execution_engine_compatibility=block.manifest_class.get_execution_engine_compatibility(),
+                input_dimensionality_offsets=block.manifest_class.get_input_dimensionality_offsets(),
+                dimensionality_reference_property=block.manifest_class.get_dimensionality_reference_property(),
+                output_dimensionality_offset=block.manifest_class.get_output_dimensionality_offset(),
+            )
+        )
+    _validate_loaded_blocks_manifest_type_identifiers(blocks=result)
+    declared_kinds = _cached_load_all_defined_kinds(env_state=env_state)
     return BlocksDescription(blocks=result, declared_kinds=declared_kinds)
 
 
@@ -350,6 +426,18 @@ def _validate_used_kinds_uniqueness(declared_kinds: List[Kind]) -> None:
         )
 
 
+@lru_cache(maxsize=8)
+def _cached_load_all_defined_kinds(
+    env_state: Tuple[Tuple[str, ...], bool] = None,
+) -> List[Kind]:
+    """Cached version of load_all_defined_kinds.
+
+    Args:
+        env_state: Tuple of (plugins, enterprise_blocks_flag) for cache invalidation
+    """
+    return load_all_defined_kinds()
+
+
 def load_all_defined_kinds() -> List[Kind]:
     core_blocks_kinds = load_kinds()
     plugins_kinds = load_plugins_kinds()

inference/core/workflows/execution_engine/introspection/schema_parser.py

@@ -1,6 +1,7 @@
 import itertools
 from collections import OrderedDict, defaultdict
 from dataclasses import replace
+from functools import lru_cache
 from typing import Dict, Optional, Set, Type
 
 from inference.core.workflows.execution_engine.entities.types import (
@@ -52,10 +53,21 @@
 OBJECT_TYPE = "object"
 
 
+def clear_cache() -> None:
+    """Clear the parse_block_manifest cache."""
+    parse_block_manifest.cache_clear()
+
+
+@lru_cache(maxsize=10000)
 def parse_block_manifest(
     manifest_type: Type[WorkflowBlockManifest],
 ) -> BlockManifestMetadata:
-    schema = manifest_type.model_json_schema()
+    # Import here to avoid circular dependency
+    from inference.core.workflows.execution_engine.introspection.blocks_loader import (
+        _cached_model_json_schema,
+    )
+
+    schema = _cached_model_json_schema(manifest_type)
     inputs_dimensionality_offsets = manifest_type.get_input_dimensionality_offsets()
     dimensionality_reference_property = (
         manifest_type.get_dimensionality_reference_property()

inference/core/workflows/execution_engine/v1/compiler/syntactic_parser.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Optional, Type, Union
+from functools import lru_cache
+from typing import Dict, List, Optional, Tuple, Type, Union
 
 import pydantic
 from pydantic import BaseModel, Field, create_model
@@ -8,6 +9,7 @@
 from inference.core.workflows.errors import WorkflowBlockError, WorkflowSyntaxError
 from inference.core.workflows.execution_engine.entities.base import InputType, JsonField
 from inference.core.workflows.execution_engine.introspection.blocks_loader import (
+    _get_env_configuration_state,
     load_workflow_blocks,
 )
 from inference.core.workflows.execution_engine.profiling.core import (
@@ -126,10 +128,28 @@ def build_workflow_definition_entity(
     return entity
 
 
-def get_workflow_schema_description() -> WorkflowsBlocksSchemaDescription:
+@lru_cache(maxsize=8)
+def _cached_workflow_schema(
+    env_state: Tuple[Tuple[str, ...], bool] = None,
+) -> dict:
+    """Cached schema generation - called only when blocks don't change.
+
+    Args:
+        env_state: Tuple of (plugins, enterprise_blocks_flag) for cache invalidation
+    """
     available_blocks = load_workflow_blocks()
     workflow_definition_class = build_workflow_definition_entity(
         available_blocks=available_blocks
     )
-    schema = workflow_definition_class.model_json_schema()
+    return workflow_definition_class.model_json_schema()
+
+
+def clear_cache() -> None:
+    """Clear the workflow schema cache."""
+    _cached_workflow_schema.cache_clear()
+
+
+def get_workflow_schema_description() -> WorkflowsBlocksSchemaDescription:
+    env_state = _get_env_configuration_state()
+    schema = _cached_workflow_schema(env_state=env_state)
     return WorkflowsBlocksSchemaDescription(schema=schema)

tests/workflows/unit_tests/execution_engine/introspection/conftest.py

@@ -0,0 +1,19 @@
+"""Pytest configuration for introspection tests."""
+import pytest
+
+from inference.core.workflows.execution_engine.introspection import blocks_loader
+from inference.core.workflows.execution_engine.introspection import schema_parser
+from inference.core.workflows.execution_engine.v1.compiler import syntactic_parser
+
+
+@pytest.fixture(autouse=True)
+def clear_all_caches():
+    """Clear all LRU caches before each test to ensure test isolation."""
+    blocks_loader.clear_caches()
+    schema_parser.clear_cache()
+    syntactic_parser.clear_cache()
+    yield
+    # Also clear after test in case test modified state
+    blocks_loader.clear_caches()
+    schema_parser.clear_cache()
+    syntactic_parser.clear_cache()