Move files

great_ai/parameters/__init__.py

@@ -0,0 +1,3 @@
+from .automatically_decorate_parameters import automatically_decorate_parameters
+from .log_metric import log_metric
+from .parameter import parameter

great_ai/parameters/automatically_decorate_parameters.py

@@ -0,0 +1,27 @@
+import inspect
+from typing import Any, Callable, TypeVar
+
+from ..helper.get_function_metadata_store import get_function_metadata_store
+from .parameter import parameter
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def automatically_decorate_parameters(func: F) -> F:
+    signature = inspect.signature(func)
+    parameter_names = [
+        param.name
+        for param in signature.parameters.values()
+        if param.kind == param.POSITIONAL_OR_KEYWORD
+    ]
+
+    metadata = get_function_metadata_store(func)
+
+    for name in parameter_names:
+        if (
+            name not in metadata.model_parameter_names
+            and name not in metadata.input_parameter_names
+        ):
+            func = parameter(name)(func)
+
+    return func

great_ai/parameters/log_metric.py

@@ -0,0 +1,15 @@
+import inspect
+from typing import Any
+
+from ..context import get_context
+from ..tracing import TracingContext
+
+
+def log_metric(argument_name: str, value: Any) -> None:
+    tracing_context = TracingContext.get_current_tracing_context()
+    caller = inspect.stack()[1].function
+    actual_name = f"metric:{caller}:{argument_name}"
+    if tracing_context:
+        tracing_context.log_value(name=actual_name, value=value)
+
+    get_context().logger.info(f"{actual_name}={value}")

great_ai/parameters/parameter.py

@@ -0,0 +1,52 @@
+from functools import wraps
+from typing import Any, Callable, Dict, TypeVar, cast
+
+from typeguard import check_type
+
+from ..exceptions import ArgumentValidationError
+from ..helper import get_arguments, get_function_metadata_store
+from ..helper.assert_function_is_not_finalised import assert_function_is_not_finalised
+from ..tracing.tracing_context import TracingContext
+
+T = TypeVar("T")
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def parameter(
+    parameter_name: str,
+    *,
+    validator: Callable[[T], bool] = lambda _: True,
+    disable_logging: bool = False,
+) -> Callable[[F], F]:
+    def decorator(func: F) -> F:
+        get_function_metadata_store(func).input_parameter_names.append(parameter_name)
+        assert_function_is_not_finalised(func)
+
+        actual_name = f"arg:{parameter_name}"
+
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Any:
+            arguments = get_arguments(func, args, kwargs)
+            argument = arguments.get(parameter_name)
+
+            expected_type = func.__annotations__.get(parameter_name)
+
+            if expected_type is not None:
+                check_type(parameter_name, argument, expected_type)
+
+            if not validator(argument):
+                raise ArgumentValidationError(
+                    f"Argument {parameter_name} in {func.__name__} did not pass validation"
+                )
+
+            context = TracingContext.get_current_tracing_context()
+            if context and not disable_logging:
+                context.log_value(name=f"{actual_name}:value", value=argument)
+                if isinstance(argument, str):
+                    context.log_value(name=f"{actual_name}:length", value=len(argument))
+
+            return func(*args, **kwargs)
+
+        return cast(F, wrapper)
+
+    return decorator