Update to simplify code and logic

Signed-off-by: Nijat Khanbabayev <nijat.khanbabayev@cubistsystematic.com>

Author: Nijat Khanbabayev

ccflow/callable.py

@@ -535,37 +535,46 @@ def model(*args, **kwargs):
         features (caching, evaluation, registry, serialization) work unchanged.
 
         Args:
-            context_args: List of parameter names that come from context (for unpacked mode)
-            context_type: Explicit ContextBase subclass to use with context_args mode
+            context_type: Optional ContextBase subclass used only to validate/coerce
+                `FromContext[...]` inputs against an existing nominal context shape
             cacheable: Enable caching of results (default: False)
             volatile: Mark as volatile (default: False)
             log_level: Logging verbosity (default: logging.DEBUG)
             validate_result: Validate return type (default: True)
             verbose: Verbose logging output (default: True)
             evaluator: Custom evaluator (default: None)
 
-        Two Context Modes:
+        Primary authoring model:
+            Mark runtime/contextual inputs explicitly with `FromContext[...]`.
+            Ordinary unmarked parameters are regular bound inputs and are never
+            read implicitly from the runtime context.
 
-        Mode 1 - Explicit context parameter:
-            Function has a 'context' parameter annotated with a ContextBase subclass.
+            @Flow.model
+            def load_prices(
+                source: str,
+                start_date: FromContext[date],
+                end_date: FromContext[date],
+            ) -> GenericResult[pl.DataFrame]:
+                return GenericResult(value=query_db(source, start_date, end_date))
+
+        Advanced interop path:
+            Functions may still declare an explicit context parameter annotated
+            with a ContextBase subclass.
 
             @Flow.model
             def load_prices(context: DateRangeContext, source: str) -> GenericResult[pl.DataFrame]:
                 return GenericResult(value=query_db(source, context.start_date, context.end_date))
 
-        Mode 2 - Unpacked context_args:
-            Context fields are unpacked into function parameters.
-
-            @Flow.model(context_args=["start_date", "end_date"], context_type=DateRangeContext)
-            def load_prices(start_date: date, end_date: date, source: str) -> GenericResult[pl.DataFrame]:
-                return GenericResult(value=query_db(source, start_date, end_date))
-
         Dependencies:
-            Any non-context parameter can be bound either to a literal value or
+            Any ordinary parameter can be bound either to a literal value or
             to another CallableModel. When a CallableModel is supplied, the
             generated model treats it as an upstream dependency and resolves it
             with the current context before calling the underlying function.
 
+            `FromContext[...]` parameters are different: they may be satisfied by
+            runtime context, construction-time contextual defaults, or function
+            defaults, but not by CallableModel values.
+
         Usage:
             # Create model instances
             loader = load_prices(source="prod_db")

ccflow/exttypes/frequency.py

@@ -1,3 +1,4 @@
+import re
 import warnings
 from datetime import timedelta
 from functools import cached_property
@@ -32,6 +33,13 @@ def _validate(cls, value) -> "Frequency":
         if isinstance(value, cls):
             return cls._validate(str(value))
 
+        if isinstance(value, timedelta):
+            if value.total_seconds() % 86400 == 0:
+                return cls(f"{int(value.total_seconds() // 86400)}D")
+
+        if isinstance(value, str):
+            value = _normalize_frequency_alias(value)
+
         if isinstance(value, (timedelta, str)):
             try:
                 with warnings.catch_warnings():
@@ -43,7 +51,7 @@ def _validate(cls, value) -> "Frequency":
                 raise ValueError(f"ensure this value can be converted to a pandas offset: {e}")
 
         if isinstance(value, pd.offsets.DateOffset):
-            return cls(f"{value.n}{value.base.freqstr}")
+            return cls(_canonicalize_offset_string(value))
 
         raise ValueError(f"ensure this value can be converted to a pandas offset: {value}")
 
@@ -54,3 +62,39 @@ def validate(cls, value) -> "Frequency":
 
 
 _TYPE_ADAPTER = TypeAdapter(Frequency)
+
+
+_LEGACY_FREQ_PATTERN = re.compile(
+    r"^(?P<count>[+-]?\d+)?(?P<unit>T|M|A|Y)(?:-(?P<suffix>[A-Za-z]{3}))?$",
+    re.IGNORECASE,
+)
+
+
+def _normalize_frequency_alias(value: str) -> str:
+    normalized = value.strip()
+    if not normalized:
+        return normalized
+
+    match = _LEGACY_FREQ_PATTERN.fullmatch(normalized)
+    if not match:
+        day_match = re.fullmatch(r"(?P<count>[+-]?\d+)?d", normalized, re.IGNORECASE)
+        if day_match:
+            return f"{day_match.group('count') or 1}D"
+        return normalized
+
+    count = match.group("count") or "1"
+    unit = match.group("unit").upper()
+    suffix = (match.group("suffix") or "DEC").upper()
+    replacements = {
+        "T": f"{count}min",
+        "M": f"{count}ME",
+        "A": f"{count}YE-{suffix}",
+        "Y": f"{count}YE-{suffix}",
+    }
+    return replacements[unit]
+
+
+def _canonicalize_offset_string(offset: pd.offsets.DateOffset) -> str:
+    if isinstance(offset, pd.offsets.Day):
+        return f"{offset.n}D"
+    return f"{offset.n}{offset.base.freqstr}"