traigent 0.18.1.dev4__tar.gz → 0.18.1.dev5__tar.gz

{traigent-0.18.1.dev4/traigent.egg-info → traigent-0.18.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: traigent
-Version: 0.18.1.dev4
+Version: 0.18.1.dev5
 Summary: Enterprise-grade LLM optimization platform with advanced analytics and AI-powered insights
 Author-email: Traigent Team <opensource@traigent.ai>
 License-Expression: AGPL-3.0-only OR LicenseRef-Traigent-Commercial

{traigent-0.18.1.dev4 → traigent-0.18.1.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "traigent"
-version = "0.18.1.dev4"
+version = "0.18.1.dev5"
 authors = [
     {name = "Traigent Team", email = "opensource@traigent.ai"},
 ]

{traigent-0.18.1.dev4 → traigent-0.18.1.dev5}/traigent/api/decorators.py

@@ -43,6 +43,7 @@ Examples:
 from __future__ import annotations
 
 import inspect
+import os
 from collections.abc import Callable, Collection, Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -2011,6 +2012,79 @@ def _suggest_detected_tvars(
         return None
 
 
+def _build_default_experiment_name(
+    func_name: str,
+    resolved_schema: ObjectiveSchema | None,
+    resolved_configuration_space: dict[str, Any] | None,
+    *,
+    max_knobs: int = 4,
+    max_total_length: int = 120,
+) -> str:
+    """Build a self-describing default experiment name when none is provided.
+
+    Combines the function name, objective names, and tuned-variable (knob) names
+    into a concise, deterministic, human-meaningful string.  Format::
+
+        <func_name>[<obj1>,<obj2>,...][<knob1>,<knob2>,...]
+
+    Args:
+        func_name: The decorated function's ``__name__``.
+        resolved_schema: Resolved objective schema (from ``_resolve_objective_schema``).
+        resolved_configuration_space: Normalized configuration-space dict whose keys
+            are the tuned-variable names.
+        max_knobs: Maximum number of knob names to display before appending ``,...``.
+        max_total_length: Hard cap on the final string length (excess is truncated).
+
+    Returns:
+        A deterministic, human-readable default experiment name.
+    """
+    # Build the objective suffix — always preserved in the output.
+    obj_suffix = ""
+    if resolved_schema is not None:
+        obj_names = [obj.name for obj in resolved_schema.objectives]
+        obj_suffix = f"[{','.join(obj_names)}]"
+
+    # Build the knob suffix; cap list length to avoid excessively long names.
+    knob_suffix = ""
+    if resolved_configuration_space:
+        knob_names = list(resolved_configuration_space.keys())
+        if len(knob_names) > max_knobs:
+            displayed = knob_names[:max_knobs]
+            knob_suffix = f"[{','.join(displayed)},...]"
+        else:
+            knob_suffix = f"[{','.join(knob_names)}]"
+
+    # Invariant: the objectives + knob sections are the self-describing payload
+    # and must never be sacrificed to the length cap.  Truncate only the
+    # function-name prefix (appending "~" to signal the cut), never the suffix.
+    suffix = obj_suffix + knob_suffix
+    func_budget = max_total_length - len(suffix)
+
+    if func_budget <= 0:
+        # Suffix alone meets or exceeds the cap — omit the function-name prefix.
+        if len(suffix) <= max_total_length:
+            return suffix
+        # Extreme edge case: even the suffix is over budget.  Preserve at least
+        # the objectives and one knob name by trimming the knob list.
+        if resolved_configuration_space:
+            knob_names_list = list(resolved_configuration_space.keys())
+            min_knob_suffix = f"[{knob_names_list[0]}]"
+            combined = obj_suffix + min_knob_suffix
+            if len(combined) <= max_total_length:
+                return combined
+        return obj_suffix[:max_total_length]
+
+    # Fit the function name into the remaining budget, marking any cut with "~".
+    if len(func_name) <= func_budget:
+        func_part = func_name
+    elif func_budget >= 2:
+        func_part = func_name[: func_budget - 1] + "~"
+    else:
+        func_part = func_name[:func_budget]
+
+    return func_part + suffix
+
+
 def optimize(  # NOSONAR(S107)
     *,
     objectives: list[str] | ObjectiveSchema | None = None,
@@ -2760,6 +2834,36 @@ def optimize(  # NOSONAR(S107)
             config_param,
         )
 
+        # Experiment name resolution (#1422).
+        #
+        # _experiment_name on OptimizedFunction stores ONLY the explicit decorator value
+        # so the getter can lazily check TRAIGENT_EXPERIMENT_NAME at each access —
+        # callers that set the env var AFTER decoration must see it take effect.
+        #
+        # The self-describing default (func name + objectives + knobs) is precomputed
+        # here because the inputs are fully resolved at decoration time; it is stored
+        # in _default_experiment_name and used by the getter as the last resort, after
+        # the explicit value and the env var are both absent.
+        #
+        # Priority resolved in OptimizedFunction.experiment_name getter (highest → lowest):
+        #   1. Explicit experiment_name decorator argument → _experiment_name (not None).
+        #   2. TRAIGENT_EXPERIMENT_NAME env var — checked at ACCESS time (not decoration time).
+        #   3. Self-describing default → _default_experiment_name.
+        #   4. Bare func.__name__ (if no objectives/knobs were registered).
+        default_experiment_name: str | None = None
+        if experiment_name_value is None:
+            default_experiment_name = _build_default_experiment_name(
+                func.__name__, resolved_schema, resolved_configuration_space
+            )
+
+        # Approximate resolved name for the creation log (decoration-time snapshot only).
+        effective_experiment_name = (
+            experiment_name_value
+            or os.environ.get("TRAIGENT_EXPERIMENT_NAME")
+            or default_experiment_name
+            or func.__name__
+        )
+
         optimized_func: OptimizedFunction[_P, _R] = OptimizedFunction(  # type: ignore[assignment]
             func=func,
             eval_dataset=eval_dataset,
@@ -2819,8 +2923,11 @@ def optimize(  # NOSONAR(S107)
             # Optimizer limits (extracted from combined_settings)
             max_trials=max_trials_value,
             _max_trials_explicit=max_trials_explicit,
-            # Experiment display name (overrides func.__name__ in portal/storage)
+            # Experiment display name: only the explicit value goes into _experiment_name
+            # so that TRAIGENT_EXPERIMENT_NAME is checked lazily at access time.
+            # The precomputed self-describing default is stored separately.
             experiment_name=experiment_name_value,
+            _default_experiment_name=default_experiment_name,
             # Warm-start: seed this run from a prior experiment's learned configs.
             warm_start_from=warm_start_from_value,
             # Guided-generation defaults (consumed by optimize_with_guidance)
@@ -2834,9 +2941,8 @@ def optimize(  # NOSONAR(S107)
         optimized_func.hybrid_api_options = hybrid_api_options
         optimized_func.offline = execution_policy.offline
 
-        effective_name = experiment_name_value or func.__name__
         logger.info(
-            f"Created optimizable function: {func.__name__} (experiment_name={effective_name!r})"
+            f"Created optimizable function: {func.__name__} (experiment_name={effective_experiment_name!r})"
         )
 
         # cast so mypy sees OptimizedFunction[_P, _R] rather than

{traigent-0.18.1.dev4 → traigent-0.18.1.dev5}/traigent/core/optimized_function.py

@@ -615,8 +615,16 @@ class OptimizedFunction(Generic[_P, _R]):
         self.max_trials = kwargs.pop("max_trials", DEFAULT_MAX_TRIALS)
         kwargs["max_trials"] = self.max_trials
 
-        # Experiment display name: decorator param > TRAIGENT_EXPERIMENT_NAME > func.__name__
+        # Experiment display name: decorator param > TRAIGENT_EXPERIMENT_NAME > self-describing default > func.__name__
+        # _experiment_name holds ONLY the explicit decorator value (None when absent).
+        # _default_experiment_name holds the precomputed self-describing default string
+        # (func name + objectives + knobs) that decorators.py computed at decoration time.
+        # The experiment_name getter resolves lazily so TRAIGENT_EXPERIMENT_NAME can be
+        # changed AFTER decoration and still take effect.
         self._experiment_name: str | None = kwargs.pop("experiment_name", None)
+        self._default_experiment_name: str | None = kwargs.pop(
+            "_default_experiment_name", None
+        )
 
         self.timeout = kwargs.pop("timeout", None)
         kwargs["timeout"] = self.timeout
@@ -3479,15 +3487,20 @@ Remediation:
         """Resolved experiment display name for portal/storage.
 
         Resolution order (highest to lowest priority):
-        1. ``experiment_name`` passed to ``@traigent.optimize()``
-        2. ``TRAIGENT_EXPERIMENT_NAME`` environment variable
-        3. Decorated function's ``__name__``
+        1. ``experiment_name`` passed to ``@traigent.optimize()`` — stored in ``_experiment_name``.
+        2. ``TRAIGENT_EXPERIMENT_NAME`` environment variable — checked at access time, so
+           setting it after decoration still takes effect.
+        3. Self-describing default precomputed at decoration time (func name + objectives + knobs)
+           — stored in ``_default_experiment_name``.
+        4. Decorated function's ``__name__`` (bare fallback when no objectives/knobs exist).
         """
         if self._experiment_name is not None:
             return self._experiment_name
         env_name = os.environ.get("TRAIGENT_EXPERIMENT_NAME")
         if env_name:
             return env_name
+        if self._default_experiment_name is not None:
+            return self._default_experiment_name
         return self.__name__
 
     @property

{traigent-0.18.1.dev4 → traigent-0.18.1.dev5}/traigent/utils/results_table.py

@@ -111,12 +111,28 @@ def _format_config_value(val: Any) -> str:
     return str(val)
 
 
+def _format_percent_metric(val: float) -> str:
+    """Format a quality metric (accuracy / score / ...) as a percent string.
+
+    Metrics reach the table on either a 0-1 fraction scale or an already-percent
+    0-100 scale (e.g. a 0-100 ``accuracy`` of 79.16). Mirror the frontend rule
+    (``percentFormatting``): a value ``> 1`` is already a percent and is rendered
+    as-is (79.16 -> ``"79.2%"``); a value ``<= 1`` is a fraction and scaled
+    (0.79 -> ``"79.0%"``). This never double-scales, so a 0-100 metric can no
+    longer render as ">100%" (the prior ``f"{val:.1%}"`` turned 79.16 into
+    "7916.2%").
+    """
+    if val > 1.0:
+        return f"{val:.1f}%"
+    return f"{val:.1%}"
+
+
 def _format_metric_value(metric: str, val: float) -> str:
     if metric == "cost":
         return f"${val:.5f}"
     if metric == "latency":
         return f"{val:.3f}s"
-    return f"{val:.1%}"
+    return _format_percent_metric(val)
 
 
 def _coerce_float(value: Any) -> float | None:

{traigent-0.18.1.dev4 → traigent-0.18.1.dev5/traigent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: traigent
-Version: 0.18.1.dev4
+Version: 0.18.1.dev5
 Summary: Enterprise-grade LLM optimization platform with advanced analytics and AI-powered insights
 Author-email: Traigent Team <opensource@traigent.ai>
 License-Expression: AGPL-3.0-only OR LicenseRef-Traigent-Commercial