Implement support for *AMF* components filtering by config variant.

Signed-off-by: Thomas Mansencal <thomas.mansencal@gmail.com>

Author: KelSolaar

docs/opencolorio_config_aces.utilities.rst

@@ -40,3 +40,5 @@ Common
     timestamp
     as_bool
     optional
+    filter_any
+    filter_all

opencolorio_config_aces/config/cg/generate/config.py

@@ -53,6 +53,8 @@
 )
 from opencolorio_config_aces.utilities import (
     attest,
+    filter_all,
+    filter_any,
     optional,
     timestamp,
     validate_method,
@@ -816,6 +818,7 @@ def generate_config_cg(
             describe=describe,
             scheme=scheme,
             analytical=False,
+            additional_filterers=additional_filterers,
             additional_data=True,
         )
 
@@ -969,24 +972,6 @@ def transform_filterer(transform: dict[str, Any]) -> bool:
 
         return False
 
-    def filter_any(
-        array: list[dict[str, Any]], filterers: list[Callable[[dict[str, Any]], bool]]
-    ) -> list[dict[str, Any]]:
-        """Filter array elements passing any of the filterers."""
-
-        filtered = [a for a in array if any(filterer(a) for filterer in filterers)]
-
-        return filtered
-
-    def filter_all(
-        array: list[dict[str, Any]], filterers: list[Callable[[dict[str, Any]], bool]]
-    ) -> list[dict[str, Any]]:
-        """Filter array elements passing all of the filterers."""
-
-        filtered = [a for a in array if all(filterer(a) for filterer in filterers)]
-
-        return filtered
-
     # "Colorspaces" Filtering
     # =======================
     any_colorspace_filterers = [
@@ -1161,7 +1146,8 @@ def remove_existing_named_transform(name: str) -> None:
                 )
             ) is not None:
                 filtered_amf_components = filter_amf_components(
-                    amf_components, aces_transform_id.aces_transform_id
+                    amf_components,
+                    aces_transform_id.aces_transform_id,
                 )
 
             kwargs.update(

opencolorio_config_aces/config/generation/configuration.py

@@ -120,6 +120,9 @@ def extended_fields(self) -> dict[str, str]:
             "view_transform_filterers": [lambda x: "D60 in" not in x["name"]],
             "shared_view_filterers": [lambda x: "D60 in" not in x["view_transform"]],
             "view_filterers": [lambda x: "D60 in" not in x["view"]],
+            "amf_component_display_filterers": [
+                lambda x: "-D60_" not in x["transform_id"]
+            ],
         },
     },
     "D60 Views": {
@@ -140,6 +143,7 @@ def extended_fields(self) -> dict[str, str]:
                 or x["view"] == "Un-tone-mapped"
                 or x["view"] == "Raw"
             ],
+            "amf_component_display_filterers": [lambda x: "-D60_" in x["transform_id"]],
         },
     },
     "All Views": {"any": {}, "all": {}},

opencolorio_config_aces/config/reference/discover/classify.py

@@ -32,6 +32,8 @@
 
 from opencolorio_config_aces.utilities import (
     attest,
+    filter_all,
+    filter_any,
     message_box,
     optional,
     paths_common_ancestor,
@@ -1511,8 +1513,11 @@ def generate_amf_components(
 
 
 def filter_amf_components(
-    amf_components: dict[str, list[str]], aces_transform_id: str
-) -> list[str] | None:
+    amf_components: dict[str, list[str]],
+    aces_transform_id: str,
+    filter_any_filterers: list[Callable[[dict[str, Any]], bool]] | None = None,
+    filter_all_filterers: list[Callable[[dict[str, Any]], bool]] | None = None,
+) -> list[str]:
     """
     Filter the *ACES* *AMF* components for specified *ACEStransformID*.
 
@@ -1522,16 +1527,79 @@ def filter_amf_components(
         *ACES* *AMF* components to filter.
     aces_transform_id : str
         *ACEStransformID* to filter the *ACES* *AMF* components with.
+    filter_any_filterers : list[Callable[[dict[str, Any]], bool]] | None, optional
+        List of filter functions for OR logic filtering. Each function should
+        accept a dictionary with *transform_id* key and return True if the
+        element passes the filter condition.
+    filter_all_filterers : list[Callable[[dict[str, Any]], bool]] | None, optional
+        List of filter functions for AND logic filtering. Each function should
+        accept a dictionary with *transform_id* key and return True if the
+        element passes the filter condition.
 
     Returns
     -------
-    :class:`list`
+    list
         Filtered *ACES* *AMF* components.
+
+    Examples
+    --------
+    >>> amf_components = {
+    ...     "DISPLAY - CIE-XYZ-D65_to_sRGB - MIRROR NEGS": [
+    ...         'urn:ampas:aces:transformId:v2.0:Output.Academy.\
+Rec709-D65_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1',
+    ...         'urn:ampas:aces:transformId:v2.0:InvOutput.Academy.\
+Rec709-D65_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1',
+    ...         'urn:ampas:aces:transformId:v2.0:Output.Academy.\
+Rec709-D60_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1',
+    ...         'urn:ampas:aces:transformId:v2.0:InvOutput.Academy.\
+Rec709-D60_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1'
+    ...     ]
+    ... }
+    >>> filterers_all = [lambda x: "-D60_" not in x['transform_id']]
+    >>> filter_amf_components(
+    ...     amf_components,
+    ...     "DISPLAY - CIE-XYZ-D65_to_sRGB - MIRROR NEGS",
+    ...     filterers_all
+    ... )  # doctest: +ELLIPSIS
+    ['urn:ampas:aces:transformId:v2.0:Output.Academy.\
+Rec709-D65_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1', \
+'urn:ampas:aces:transformId:v2.0:InvOutput.Academy.\
+Rec709-D65_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1']
+    >>> filterers_all = [lambda x: "-D60_" in x['transform_id']]
+    >>> filter_amf_components(
+    ...     amf_components,
+    ...     "DISPLAY - CIE-XYZ-D65_to_sRGB - MIRROR NEGS",
+    ...     filterers_all
+    ... )  # doctest: +ELLIPSIS
+    ['urn:ampas:aces:transformId:v2.0:Output.Academy.\
+Rec709-D60_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1', \
+'urn:ampas:aces:transformId:v2.0:InvOutput.Academy.\
+Rec709-D60_100nit_in_Rec709-D65_sRGB-Piecewise.a2.v1']
     """
 
-    filtered_amf_components = list(amf_components.get(aces_transform_id, []))
+    filtered_amf_components = amf_components.get(aces_transform_id, [])
+
+    if filter_any_filterers or filter_all_filterers:
+        filtered_amf_components_dicts = [
+            {"transform_id": transform_id} for transform_id in filtered_amf_components
+        ]
+
+        if filter_any_filterers:
+            filtered_amf_components_dicts = filter_any(
+                filtered_amf_components_dicts, filter_any_filterers
+            )
+
+        if filter_all_filterers:
+            filtered_amf_components_dicts = filter_all(
+                filtered_amf_components_dicts, filter_all_filterers
+            )
+
+        filtered_amf_components = [
+            filtered_amf_components_dict["transform_id"]
+            for filtered_amf_components_dict in filtered_amf_components_dicts
+        ]
 
-    return filtered_amf_components if len(filtered_amf_components) else None
+    return filtered_amf_components
 
 
 if __name__ == "__main__":

opencolorio_config_aces/config/reference/generate/config.py

@@ -55,6 +55,7 @@
 from opencolorio_config_aces.utilities import (
     as_bool,
     attest,
+    optional,
     timestamp,
     validate_method,
 )
@@ -839,6 +840,8 @@ def generate_config_aces(
     config_mapping_file_path: Any = PATH_TRANSFORMS_MAPPING_FILE_REFERENCE,
     scheme: str = "Modern 1",
     analytical: bool = True,
+    additional_filterers: dict[str, dict[str, list[Callable[[Any], bool]]]]
+    | None = None,
     additional_data: bool = False,
 ) -> Any:
     """
@@ -876,6 +879,21 @@ def generate_config_aces(
         Whether to generate *OpenColorIO* transform families that analytically
         match the given *ACES* *CTL* transform, i.e., true to the *aces-dev*
         reference but not necessarily user-friendly.
+    additional_filterers : dict, optional
+        Additional filterers to further include or exclude components from the
+        generated config.
+
+        .. code-block:: python
+
+            filterer = [lambda x: "-D60_" not in x["transform_id"]]
+
+            {
+                "any": {},
+                "all": {
+                    "amf_component_display_filterers": filterer,
+                },
+            },
+
     additional_data : bool, optional
         Whether to return additional data.
 
@@ -892,6 +910,10 @@ def generate_config_aces(
         config_name_aces(build_configuration),
     )
 
+    # TODO: Implement full filtering for all the transforms that is defined
+    # in the *CG* config.
+    additional_filterers = optional(additional_filterers, {"any": {}, "all": {}})
+
     LOGGER.debug('Using %s "Builtin" transforms...', list(BUILTIN_TRANSFORMS.keys()))
 
     ctl_transforms = unclassify_ctl_transforms(
@@ -1089,7 +1111,10 @@ def generate_config_aces(
             display_style = transform_data["linked_display_colorspace_style"]
 
             filtered_amf_components = filter_amf_components(
-                amf_components, display_style
+                amf_components,
+                display_style,
+                additional_filterers["any"].get("amf_component_display_filterers"),
+                additional_filterers["all"].get("amf_component_display_filterers"),
             )
 
             display = style_to_display_colorspace(

opencolorio_config_aces/utilities/__init__.py

@@ -27,6 +27,8 @@
     timestamp,
     as_bool,
     optional,
+    filter_any,
+    filter_all,
 )
 
 __all__ = [
@@ -55,4 +57,6 @@
     "timestamp",
     "as_bool",
     "optional",
+    "filter_any",
+    "filter_all",
 ]

opencolorio_config_aces/utilities/common.py

@@ -60,6 +60,8 @@
     "timestamp",
     "as_bool",
     "optional",
+    "filter_any",
+    "filter_all",
 ]
 
 LOGGER = logging.getLogger(__name__)
@@ -842,3 +844,90 @@ def optional(value: T | None, default: T) -> T:
         return default
     else:
         return value
+
+
+def filter_any(
+    array: list[dict[str, Any]], filterers: list[Callable[[dict[str, Any]], bool]]
+) -> list[dict[str, Any]]:
+    """
+    Filter array elements that pass any of the provided filter functions.
+
+    This function applies multiple filter functions to each element in the array
+    and returns elements that satisfy at least one filter condition (OR logic).
+
+    Parameters
+    ----------
+    array : list[dict[str, Any]]
+        The list of dictionaries to filter.
+    filterers : list[Callable[[dict[str, Any]], bool]]
+        A list of callable filter functions. Each function should accept a
+        dictionary and return True if the element passes the filter condition,
+        False otherwise.
+
+    Returns
+    -------
+    list[dict[str, Any]]
+        A new list containing only the elements that pass at least one of the
+        filter conditions.
+
+    Examples
+    --------
+    >>> transforms = [
+    ...     {'name': 'ACEScc', 'type': 'CSC', 'family': 'aces'},
+    ...     {'name': 'ACEScg', 'type': 'CSC', 'family': 'aces'},
+    ...     {'name': 'sRGB', 'type': 'Output', 'family': 'display'},
+    ... ]
+    >>> is_csc = lambda x: x['type'] == 'CSC'
+    >>> is_output = lambda x: x['type'] == 'Output'
+    >>> filter_any(transforms, [is_csc, is_output])
+    [{'name': 'ACEScc', 'type': 'CSC', 'family': 'aces'}, \
+{'name': 'ACEScg', 'type': 'CSC', 'family': 'aces'}, \
+{'name': 'sRGB', 'type': 'Output', 'family': 'display'}]
+    """
+
+    filtered = [a for a in array if any(filterer(a) for filterer in filterers)]
+
+    return filtered
+
+
+def filter_all(
+    array: list[dict[str, Any]], filterers: list[Callable[[dict[str, Any]], bool]]
+) -> list[dict[str, Any]]:
+    """
+    Filter array elements that pass all of the provided filter functions.
+
+    This function applies multiple filter functions to each element in the array
+    and returns only elements that satisfy every filter condition (AND logic).
+
+    Parameters
+    ----------
+    array : list[dict[str, Any]]
+        The list of dictionaries to filter.
+    filterers : list[Callable[[dict[str, Any]], bool]]
+        A list of callable filter functions. Each function should accept a
+        dictionary and return True if the element passes the filter condition,
+        False otherwise.
+
+    Returns
+    -------
+    list[dict[str, Any]]
+        A new list containing only the elements that pass all of the filter
+        conditions.
+
+    Examples
+    --------
+    >>> transforms = [
+    ...     {'name': 'ACEScc', 'type': 'CSC', 'family': 'aces'},
+    ...     {'name': 'Rec709', 'type': 'Output', 'family': 'display'},
+    ...     {'name': 'sRGB', 'type': 'Output', 'family': 'display'},
+    ... ]
+    >>> is_output = lambda x: x['type'] == 'Output'
+    >>> is_display = lambda x: x['family'] == 'display'
+    >>> filter_all(transforms, [is_output, is_display])
+    [{'name': 'Rec709', 'type': 'Output', 'family': 'display'}, \
+{'name': 'sRGB', 'type': 'Output', 'family': 'display'}]
+    """
+
+    filtered = [a for a in array if all(filterer(a) for filterer in filterers)]
+
+    return filtered