ert 16.0.9__py3-none-any.whl → 19.0.0rc2__py3-none-any.whl

ert/config/forward_model_step.py

@@ -1,13 +1,33 @@
 from __future__ import annotations
 
 import logging
-from typing import ClassVar, Literal, NotRequired, Self
-
-from pydantic import BaseModel, Field, field_validator, model_validator
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    ClassVar,
+    Literal,
+    NotRequired,
+    Self,
+    cast,
+)
+
+from pydantic import (
+    BaseModel,
+    Field,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypedDict, Unpack
 
+from ..base_model_context import BaseModelWithContextSupport
 from .parsing import ConfigValidationError, ConfigWarning, SchemaItemType
 
+if TYPE_CHECKING:
+    from ert.plugins import ErtRuntimePlugins
+
 logger = logging.getLogger(__name__)
 
 
@@ -72,6 +92,7 @@ class ForwardModelStepOptions(TypedDict, total=False):
     max_running_minutes: NotRequired[int]
     environment: NotRequired[dict[str, str]]
     default_mapping: NotRequired[dict[str, str]]
+    required_keywords: NotRequired[list[str]]
 
 
 class ForwardModelStepDocumentation(BaseModel):
@@ -80,18 +101,21 @@ class ForwardModelStepDocumentation(BaseModel):
     source_function_name: str = Field(default="ert")
     description: str = Field(default="No description")
     examples: str = Field(default="No examples")
-    category: (
-        Literal[
-            "utility.file_system",
-            "simulators.reservoir",
-            "modelling.reservoir",
-            "utility.templating",
-        ]
-        | str
-    ) = Field(default="Uncategorized")
-
-
-class ForwardModelStep(BaseModel):
+    category: Annotated[
+        str,
+        Field(
+            default="Uncategorized",
+            examples=[
+                "utility.file_system",
+                "simulators.reservoir",
+                "modelling.reservoir",
+                "utility.templating",
+            ],
+        ),
+    ]
+
+
+class ForwardModelStep(BaseModelWithContextSupport):
     """
     Holds information to execute one step of a forward model
 
@@ -202,7 +226,87 @@ class ForwardModelStep(BaseModel):
         return None if v == "null" else v
 
 
-class ForwardModelStepPlugin(ForwardModelStep):
+class UserInstalledForwardModelStep(ForwardModelStep):
+    """
+    Represents a forward model step installed by a user via the ERT Config
+    forward model step format provided via the INSTALL_JOB keyword.
+    User-installed forward model steps serialize with their full configuration,
+    unlike site-installed steps which only serialize as references.
+    """
+
+    type: Literal["user_installed"] = "user_installed"
+
+
+class _SerializedSiteInstalledForwardModelStep(TypedDict):
+    type: Literal["site_installed"]
+    name: str
+    private_args: dict[str, str]
+
+
+class SiteInstalledForwardModelStep(ForwardModelStep):
+    """
+    Represents a forward model step installed via external plugins.
+    Instances of this class serialize only as references to the plugin by name, and
+    the user-provided private_args, allowing them to dynamically update when plugins
+    change, rather than being locked to a specific executable at serialization time.
+    """
+
+    type: Literal["site_installed"] = "site_installed"
+
+    @model_serializer(mode="plain")
+    def serialize_model(self) -> _SerializedSiteInstalledForwardModelStep:
+        return {
+            "type": "site_installed",
+            "name": self.name,
+            "private_args": self.private_args,
+        }
+
+    @model_validator(mode="before")
+    @classmethod
+    def deserialize_model(
+        cls, values: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
+        runtime_plugins = cast("ErtRuntimePlugins", info.context)
+        name = values["name"]
+
+        if runtime_plugins is None:
+            if values.get("type") == "site_installed":
+                msg = (
+                    f"Trying to find site-installed forward model step {name} "
+                    f"without site plugins. This forward model must be loaded "
+                    f"with ERT site plugins available."
+                )
+                raise KeyError(msg)
+            return values
+
+        if name not in runtime_plugins.installed_forward_model_steps:
+            msg = (
+                f"Expected forward model step {name} to be installed "
+                f"via plugins, but it was not found. Please check that "
+                f"your python environment has it installed."
+            )
+            raise KeyError(msg)
+        site_installed_fm = runtime_plugins.installed_forward_model_steps[name]
+
+        # Intent: copy the site installed forward model to this instance.
+        # bypassing the model_serializer
+        site_fm_instance = {
+            k: getattr(site_installed_fm, k)
+            for k in SiteInstalledForwardModelStep.model_fields
+        }
+
+        return site_fm_instance | (
+            {"private_args": values["private_args"]} if "private_args" in values else {}
+        )
+
+
+SiteOrUserForwardModelStep = Annotated[
+    (UserInstalledForwardModelStep | SiteInstalledForwardModelStep),
+    Field(discriminator="type"),
+]
+
+
+class ForwardModelStepPlugin(SiteInstalledForwardModelStep):
     def __init__(
         self, name: str, command: list[str], **kwargs: Unpack[ForwardModelStepOptions]
     ) -> None:
@@ -221,6 +325,7 @@ class ForwardModelStepPlugin(ForwardModelStep):
         max_running_minutes = kwargs.get("max_running_minutes")
         environment = kwargs.get("environment", {}) or {}
         default_mapping = kwargs.get("default_mapping", {}) or {}
+        required_keywords = kwargs.get("required_keywords", []) or []
 
         super().__init__(
             name=name,
@@ -235,7 +340,7 @@ class ForwardModelStepPlugin(ForwardModelStep):
             max_running_minutes=max_running_minutes,
             min_arg=0,
             max_arg=0,
-            required_keywords=[],
+            required_keywords=required_keywords,
             arg_types=[],
             environment=environment,
             default_mapping=default_mapping,

ert/config/gen_data_config.py

@@ -21,7 +21,6 @@ from .responses_index import responses_index
 
 class GenDataConfig(ResponseConfig):
     type: Literal["gen_data"] = "gen_data"
-    name: str = "gen_data"
     report_steps_list: list[list[int] | None] = Field(default_factory=list)
     has_finalized_keys: bool = True
 
@@ -29,7 +28,7 @@ class GenDataConfig(ResponseConfig):
     def metadata(self) -> list[ResponseMetadata]:
         return [
             ResponseMetadata(
-                response_type=self.name,
+                response_type=self.type,
                 response_key=response_key,
                 finalized=self.has_finalized_keys,
                 filter_on={"report_step": report_steps}
@@ -198,28 +197,24 @@ class GenDataConfig(ResponseConfig):
             if all(isinstance(err, FileNotFoundError) for err in errors):
                 raise FileNotFoundError(
                     "Could not find one or more files/directories while reading "
-                    f"GEN_DATA {self.name}: {','.join([str(err) for err in errors])}"
+                    f"GEN_DATA: {','.join([str(err) for err in errors])}"
                 )
             else:
                 raise InvalidResponseFile(
                     "Error reading GEN_DATA "
-                    f"{self.name}, errors: {','.join([str(err) for err in errors])}"
+                    f"{self.type}, errors: {','.join([str(err) for err in errors])}"
                 )
 
         combined = pl.concat(datasets_per_name)
         return combined
 
     def get_args_for_key(self, key: str) -> tuple[str | None, list[int] | None]:
-        for i, _key in enumerate(self.keys):
-            if key == _key:
+        for i, key_ in enumerate(self.keys):
+            if key == key_:
                 return self.input_files[i], self.report_steps_list[i]
 
         return None, None
 
-    @property
-    def response_type(self) -> str:
-        return "gen_data"
-
     @property
     def primary_key(self) -> list[str]:
         return ["report_step", "index"]

ert/config/gen_kw_config.py

@@ -15,7 +15,7 @@ from typing_extensions import TypedDict
 
 from ._str_to_bool import str_to_bool
 from .distribution import DISTRIBUTION_CLASSES, DistributionSettings, get_distribution
-from .parameter_config import ParameterCardinality, ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterCardinality, ParameterConfig
 from .parsing import ConfigValidationError, ConfigWarning
 
 if TYPE_CHECKING:
@@ -53,6 +53,7 @@ class DataSource(StrEnum):
 
 class GenKwConfig(ParameterConfig):
     type: Literal["gen_kw"] = "gen_kw"
+    dimensionality: Literal[1] = 1
     distribution: DistributionSettings
     forward_init: bool = False
     update: bool = True
@@ -73,17 +74,6 @@ class GenKwConfig(ParameterConfig):
     def cardinality(self) -> ParameterCardinality:
         return ParameterCardinality.multiple_configs_per_ensemble_dataset
 
-    @property
-    def metadata(self) -> list[ParameterMetadata]:
-        return [
-            ParameterMetadata(
-                key=f"{self.group}:{self.name}",
-                transformation=self.distribution.name.upper(),
-                dimensionality=1,
-                userdata={"data_origin": "GEN_KW"},
-            )
-        ]
-
     @classmethod
     def templates_from_config(
         cls, gen_kw: list[str | dict[str, str]]
@@ -117,11 +107,11 @@ class GenKwConfig(ParameterConfig):
         return None
 
     @classmethod
-    def from_config_list(cls, gen_kw: list[str | dict[str, str]]) -> list[Self]:
-        gen_kw_key = cast(str, gen_kw[0])
+    def from_config_list(cls, config_list: list[str | dict[str, str]]) -> list[Self]:
+        gen_kw_key = cast(str, config_list[0])
 
-        options = cast(dict[str, str], gen_kw[-1])
-        positional_args = cast(list[str], gen_kw[:-1])
+        options = cast(dict[str, str], config_list[-1])
+        positional_args = cast(list[str | list[str]], config_list[:-1])
         errors = []
         update_parameter = str_to_bool(options.get("UPDATE", "TRUE"))
         if _get_abs_path(options.get("INIT_FILES")):
@@ -129,7 +119,7 @@ class GenKwConfig(ParameterConfig):
                 "INIT_FILES with GEN_KW has been removed. "
                 f"Please remove INIT_FILES from the GEN_KW {gen_kw_key} config. "
                 "Alternatively, use DESIGN_MATRIX to load parameters from files.",
-                gen_kw,
+                config_list,
             )
 
         if len(positional_args) == 2:
@@ -153,7 +143,7 @@ class GenKwConfig(ParameterConfig):
                         ConfigValidationError.with_context(
                             f"Too few values on line {line_number} in parameter "
                             f"file {parameter_file_context}",
-                            gen_kw,
+                            config_list,
                         )
                     )
                 else:
@@ -186,7 +176,7 @@ class GenKwConfig(ParameterConfig):
                         params[0], params[1], params[2:]
                     ),
                     forward_init=False,
-                    update=update_parameter,
+                    update="CONST" not in params and update_parameter,
                 )
                 for params in distributions_spec
             ]
@@ -195,7 +185,7 @@ class GenKwConfig(ParameterConfig):
                 [err.set_context(gen_kw_key) for err in e.errors]
             ) from e
         except ValidationError as e:
-            raise ConfigValidationError.from_pydantic(e, gen_kw) from e
+            raise ConfigValidationError.from_pydantic(e, config_list) from e
 
     def load_parameter_graph(self) -> nx.Graph[int]:
         # Create a graph with no edges
@@ -217,18 +207,7 @@ class GenKwConfig(ParameterConfig):
         real_nr: int,
         ensemble: Ensemble,
     ) -> dict[str, dict[str, float | str]]:
-        df = ensemble.load_parameters(self.name, real_nr, transformed=True).drop(
-            "realization"
-        )
-
-        assert isinstance(df, pl.DataFrame)
-        if not df.width == 1:
-            raise ValueError(
-                f"GEN_KW {self.group_name}:{self.name} should be a single parameter!"
-            )
-
-        data = df.to_dicts()[0]
-        return {self.group_name: data}
+        raise NotImplementedError
 
     def load_parameters(
         self, ensemble: Ensemble, realizations: npt.NDArray[np.int_]
@@ -259,15 +238,6 @@ class GenKwConfig(ParameterConfig):
     def group_name(self) -> str:
         return self.group
 
-    def copy_parameters(
-        self,
-        source_ensemble: Ensemble,
-        target_ensemble: Ensemble,
-        realizations: npt.NDArray[np.int_],
-    ) -> None:
-        df = source_ensemble.load_parameters(self.name, realizations)
-        target_ensemble.save_parameters(dataset=df)
-
     def get_priors(self) -> list[PriorDict]:
         dist_json = self.distribution.model_dump(exclude={"name"})
         return [

ert/config/known_response_types.py

@@ -0,0 +1,14 @@
+from .everest_response import EverestConstraintsConfig, EverestObjectivesConfig
+from .gen_data_config import GenDataConfig
+from .rft_config import RFTConfig
+from .summary_config import SummaryConfig
+
+KnownErtResponseTypes = SummaryConfig | GenDataConfig | RFTConfig
+KNOWN_ERT_RESPONSE_TYPES = (
+    SummaryConfig,
+    GenDataConfig,
+    RFTConfig,
+)
+KnownResponseTypes = (
+    KnownErtResponseTypes | EverestConstraintsConfig | EverestObjectivesConfig
+)

ert/config/parameter_config.py

@@ -5,7 +5,7 @@ from collections.abc import Callable, Iterator
 from enum import StrEnum, auto
 from hashlib import sha256
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -39,13 +39,6 @@ class ParameterCardinality(StrEnum):
     one_config_per_realization_dataset = auto()
 
 
-class ParameterMetadata(BaseModel):
-    key: str
-    transformation: str | None
-    dimensionality: Literal[1, 2, 3] = 1
-    userdata: dict[str, Any]
-
-
 class ParameterConfig(BaseModel):
     type: str
     name: str
@@ -59,14 +52,6 @@ class ParameterConfig(BaseModel):
         Returns a list of parameter keys within this parameter group
         """
 
-    @property
-    @abstractmethod
-    def metadata(self) -> list[ParameterMetadata]:
-        """
-        Returns metadata describing this parameter
-
-        """
-
     @abstractmethod
     def __len__(self) -> int:
         """Number of parameters"""
@@ -108,23 +93,6 @@ class ParameterConfig(BaseModel):
         or polars DataFrame from the numpy data
         """
 
-    def copy_parameters(
-        self,
-        source_ensemble: Ensemble,
-        target_ensemble: Ensemble,
-        realizations: npt.NDArray[np.int_],
-    ) -> None:
-        """
-        Copy parameters from one ensemble to another.
-        If realizations is None, copy all realizations.
-        If realizations is given, copy only those realizations.
-        """
-        for realization in realizations:
-            # Converts to standard python scalar due to mypy
-            realization_int = int(realization)
-            ds = source_ensemble.load_parameters(self.name, realization_int)
-            target_ensemble.save_parameters(ds, self.name, realization_int)
-
     @abstractmethod
     def load_parameters(
         self, ensemble: Ensemble, realizations: npt.NDArray[np.int_]

ert/config/parsing/_option_dict.py

@@ -48,13 +48,21 @@ def option_dict(option_list: Sequence[str], offset: int) -> dict[str, str]:
         if len(option_pair.split(":")) == 2:
             key, val = option_pair.split(":")
             if val and key:
+                if key in result:
+                    raise ConfigValidationError.with_context(
+                        f"Option {key} occured multiple times.", option_pair
+                    )
                 result[key] = val
             else:
                 raise ConfigValidationError.with_context(
-                    f"Invalid argument {option_pair!r}", option_pair
+                    "Option argument should be of the form 'key':'value', "
+                    f"got {option_pair!r}",
+                    option_pair,
                 )
         else:
             raise ConfigValidationError.with_context(
-                f"Invalid argument {option_pair!r}", option_pair
+                "Option argument should be of the form 'key':'value', "
+                f"got {option_pair!r}",
+                option_pair,
             )
     return result

ert/config/parsing/config_errors.py

@@ -76,7 +76,7 @@ class ConfigValidationError(ValueError):
     def from_pydantic(cls, error: ValidationError, context: Any = None) -> Self:
         parsed_errors = []
         for pydantic_error_info in error.errors():
-            actual_error = pydantic_error_info["ctx"]["error"]
+            actual_error = pydantic_error_info.get("ctx", {}).get("error")
 
             if isinstance(actual_error, ConfigValidationError):
                 parsed_errors += [

ert/config/parsing/config_keywords.py

@@ -25,7 +25,6 @@ class ConfigKeys(StrEnum):
     HISTORY_SOURCE = "HISTORY_SOURCE"
     INSTALL_JOB = "INSTALL_JOB"
     INSTALL_JOB_DIRECTORY = "INSTALL_JOB_DIRECTORY"
-    JOB_SCRIPT = "JOB_SCRIPT"
     JOBNAME = "JOBNAME"
     MAX_SUBMIT = "MAX_SUBMIT"
     DESIGN_MATRIX = "DESIGN_MATRIX"
@@ -43,6 +42,7 @@ class ConfigKeys(StrEnum):
     SETENV = "SETENV"
     STD_CUTOFF = "STD_CUTOFF"
     SUMMARY = "SUMMARY"
+    RFT = "RFT"
     SURFACE = "SURFACE"
     UPDATE_LOG_PATH = "UPDATE_LOG_PATH"
     RANDOM_SEED = "RANDOM_SEED"
@@ -56,6 +56,7 @@ class ConfigKeys(StrEnum):
     REALIZATION_MEMORY = "REALIZATION_MEMORY"
     SUBMIT_SLEEP = "SUBMIT_SLEEP"
     MAX_RUNNING = "MAX_RUNNING"
+    PRIORITIZE_PRIVATE_IP_ADDRESS = "PRIORITIZE_PRIVATE_IP_ADDRESS"
 
     def __repr__(self) -> str:
         return f"{self.value!r}"

ert/config/parsing/config_schema.py

@@ -4,8 +4,8 @@ from .config_schema_deprecations import deprecated_keywords_list
 from .config_schema_item import (
     SchemaItem,
     Varies,
+    existing_file_keyword,
     existing_path_inline_keyword,
-    existing_path_keyword,
     float_keyword,
     int_keyword,
     path_keyword,
@@ -63,6 +63,17 @@ def data_kw_keyword() -> SchemaItem:
     )
 
 
+def rft_keyword() -> SchemaItem:
+    return SchemaItem(
+        kw=ConfigKeys.RFT,
+        required_set=False,
+        multi_occurrence=True,
+        options_after=0,
+        argc_min=1,
+        argc_max=1,
+    )
+
+
 def define_keyword() -> SchemaItem:
     return SchemaItem(
         kw=ConfigKeys.DEFINE,
@@ -115,6 +126,13 @@ def hook_workflow_keyword() -> SchemaItem:
     )
 
 
+def prioritize_private_ip_address_keyword() -> SchemaItem:
+    return SchemaItem(
+        kw=ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS,
+        type_map=[SchemaItemType.BOOL],
+    )
+
+
 def set_env_keyword() -> SchemaItem:
     # You can set environment variables which will be applied to the run-time
     # environment.
@@ -176,13 +194,6 @@ def queue_option_keyword() -> SchemaItem:
     )
 
 
-def job_script_keyword() -> SchemaItem:
-    return SchemaItem(
-        kw=ConfigKeys.JOB_SCRIPT,
-        type_map=[SchemaItemType.EXECUTABLE],
-    )
-
-
 def gen_kw_keyword() -> SchemaItem:
     return SchemaItem(
         kw=ConfigKeys.GEN_KW,
@@ -310,11 +321,12 @@ def init_user_config_schema() -> ConfigSchemaDict:
         gen_kw_keyword(),
         gen_data_keyword(),
         summary_keyword(),
+        rft_keyword(),
         surface_keyword(),
         field_keyword(),
         single_arg_keyword(ConfigKeys.ECLBASE),
-        existing_path_keyword(ConfigKeys.DATA_FILE),
-        existing_path_keyword(ConfigKeys.GRID),
+        existing_file_keyword(ConfigKeys.DATA_FILE),
+        existing_file_keyword(ConfigKeys.GRID),
         path_keyword(ConfigKeys.REFCASE),
         int_keyword(ConfigKeys.RANDOM_SEED),
         num_realizations_keyword(),
@@ -339,12 +351,12 @@ def init_user_config_schema() -> ConfigSchemaDict:
         design_matrix_keyword(),
         queue_system_keyword(False),
         queue_option_keyword(),
-        job_script_keyword(),
         load_workflow_job_keyword(),
         set_env_keyword(),
         install_job_keyword(),
         install_job_directory_keyword(),
         hook_workflow_keyword(),
+        prioritize_private_ip_address_keyword(),
     ]:
         schema[item.kw] = item
         if item.kw in ConfigAliases:

ert/config/parsing/config_schema_deprecations.py

@@ -39,9 +39,9 @@ deprecated_keywords_list = [
             keyword=kw,
             message=partial(
                 lambda line, kw: f"Using {kw} with substitution strings "
-                + "that are not of the form '<KEY>' is deprecated. "
-                + f"Please change {line[0]} to "
-                + f"<{line[0].replace('<', '').replace('>', '')}>",
+                "that are not of the form '<KEY>' is deprecated. "
+                f"Please change {line[0]} to "
+                f"<{line[0].replace('<', '').replace('>', '')}>",
                 kw=kw,
             ),
             check=lambda line: not DeprecationInfo.is_angle_bracketed(str(line[0])),

ert/config/parsing/config_schema_item.py

@@ -37,25 +37,34 @@ class SchemaItem:
 
     # The minimum number of arguments
     argc_min: NonNegativeInt = 1
+
     # The maximum number of arguments: None means no upper limit
     argc_max: NonNegativeInt | None = 1
+
     # A list of types for the items. Set along with argc_minmax()
     type_map: list[SchemaItemType | EnumType | None] = Field(default_factory=list)
+
     # A list of item's which must also be set (if this item is set). (can be NULL)
     required_children: list[str] = Field(default_factory=list)
+
     # Information about the deprecation if deprecated
     deprecation_info: list[DeprecationInfo] = Field(default_factory=list)
-    # if positive, arguments after this count will be concatenated with a " " between
+
+    # If positive, arguments after this count will be concatenated with a " " between
     join_after: PositiveInt | None = None
-    # if positive, arguments after this count will be interpreted as options
-    options_after: PositiveInt | Varies | None = None
-    # if true, will accumulate many values set for key, otherwise each entry will
+
+    # If positive, arguments after this count will be interpreted as options
+    options_after: NonNegativeInt | Varies | None = None
+
+    # If true, will accumulate many values set for key, otherwise each entry will
     # overwrite any previous value set
     multi_occurrence: bool = False
+
     # Only applies to SchemaItemType.EXISTING_PATH_INLINE where
     # the contents is then parsed
     parser: Callable[[str, str], Any] = lambda x, y: y
     expand_envvar: bool = True
+
     # Index of tokens to do substitution from until end
     substitute_from: NonNegativeInt = 1
     required_set: bool = False
@@ -155,9 +164,9 @@ class SchemaItem:
                         f"value as argument {index + 1!r}",
                         token,
                     )
-
             case (
                 SchemaItemType.PATH
+                | SchemaItemType.EXISTING_FILE
                 | SchemaItemType.EXISTING_PATH
                 | SchemaItemType.EXISTING_PATH_INLINE
             ):
@@ -166,10 +175,14 @@ class SchemaItem:
                     path = os.path.normpath(
                         os.path.join(os.path.dirname(token.filename), token)
                     )
-                if val_type in {
-                    SchemaItemType.EXISTING_PATH,
-                    SchemaItemType.EXISTING_PATH_INLINE,
-                }:
+                if val_type != SchemaItemType.PATH:
+                    if val_type == SchemaItemType.EXISTING_FILE and not os.path.isfile(
+                        str(path)
+                    ):
+                        raise ConfigValidationError.with_context(
+                            f"{self.kw} {token} is not a file.",
+                            token,
+                        )
                     if not os.path.exists(str(path)):
                         err = f'Cannot find file or directory "{token.value}". '
                         if path != token:
@@ -311,6 +324,8 @@ class SchemaItem:
         self, line: Sequence[FileContextToken]
     ) -> Sequence[FileContextToken | dict[FileContextToken, FileContextToken]]:
         n = self.options_after
+        if not line:
+            return []
         if isinstance(n, Varies):
             args, kwargs = parse_variable_options(list(line), n.max_positionals)
             return [*args, kwargs]  # type: ignore
@@ -343,8 +358,8 @@ def path_keyword(keyword: str) -> SchemaItem:
     return SchemaItem(kw=keyword, type_map=[SchemaItemType.PATH])
 
 
-def existing_path_keyword(keyword: str) -> SchemaItem:
-    return SchemaItem(kw=keyword, type_map=[SchemaItemType.EXISTING_PATH])
+def existing_file_keyword(keyword: str) -> SchemaItem:
+    return SchemaItem(kw=keyword, type_map=[SchemaItemType.EXISTING_FILE])
 
 
 def existing_path_inline_keyword(