chalkpy 2.89.22__py3-none-any.whl → 2.95.3__py3-none-any.whl

chalk/utils/notebook.py

@@ -1,15 +1,21 @@
+import ast
 import enum
 import functools
 import inspect
 import sys
 from contextvars import ContextVar
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 
 from chalk.utils.environment_parsing import env_var_bool
 
 if TYPE_CHECKING:
     from chalk.sql._internal.sql_file_resolver import SQLStringResult
 
+    try:
+        from ipython.core.interactiveshell import InteractiveShell  # type: ignore
+    except ImportError:
+        InteractiveShell = Any  # type: ignore
+
 
 def print_user_error(message: str, exception: Optional[Exception] = None, suggested_action: Optional[str] = None):
     print(f"\033[91mERROR: {message}\033[0m", file=sys.stderr)
@@ -29,7 +35,7 @@ class IPythonEvents(enum.Enum):
     POST_RUN_CELL = "post_run_cell"
 
 
-def get_ipython_or_none() -> Optional[object]:
+def get_ipython_or_none() -> Optional[Any]:
     """
     Returns the global IPython shell object, if this code is running in an ipython environment.
     :return: An `IPython.core.interactiveshell.InteractiveShell`, or None if we're not running in a notebook/ipython repl
@@ -129,3 +135,250 @@ def register_resolver_from_cell_magic(sql_string_result: "SQLStringResult"):
         return
 
     NOTEBOOK_DEFINED_SQL_RESOLVERS[sql_string_result.path] = resolver_result
+
+
+def is_valid_python_code(code_string: str):
+    try:
+        compile(code_string, "<string>", "exec")
+        return True
+    except (SyntaxError, ValueError):
+        return False
+
+
+def _get_import_names(node: Union[ast.Import, ast.ImportFrom], cell_source: str, import_source: str) -> set[str]:
+    """Extract the names that an import statement brings into scope."""
+    import ast
+
+    imported_names = set()
+    if isinstance(node, ast.Import):
+        for alias in node.names:
+            name = alias.asname if alias.asname else alias.name
+            imported_names.add(name)
+    else:  # ast.ImportFrom
+        for alias in node.names:
+            if alias.name == "*":
+                # Can't track wildcard imports precisely, so include the import text itself
+                imported_names.add(import_source)
+            else:
+                name = alias.asname if alias.asname else alias.name
+                imported_names.add(name)
+    return imported_names
+
+
+def _parse_notebook_cells(cells: list[tuple[int, int, str]]):
+    """Parse notebook cells and extract definitions of functions, classes, globals, and imports."""
+    import ast
+
+    latest_function_def: dict[str, tuple[str, ast.AST]] = {}  # name -> (source, ast_node)
+    latest_global_assign: dict[str, str] = {}  # name -> source
+    latest_class_def: dict[str, tuple[str, ast.AST]] = {}  # name -> (source, ast_node)
+    all_imports: dict[str, tuple[list[str], ast.AST]] = {}  # import_text -> (names_imported, ast_node)
+
+    for _, _, cell_source in cells:
+        cell_source = cell_source.strip()
+        if not cell_source:
+            continue
+
+        try:
+            cell_tree = ast.parse(cell_source)
+        except SyntaxError:
+            continue
+
+        for node in cell_tree.body:
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                import_source = ast.get_source_segment(cell_source, node)
+                if import_source is None:
+                    continue
+                imported_names = _get_import_names(node, cell_source, import_source)
+                all_imports[import_source] = (list(imported_names), node)
+
+            elif isinstance(node, ast.FunctionDef):
+                func_source = ast.get_source_segment(cell_source, node)
+                if func_source is not None:
+                    latest_function_def[node.name] = (func_source, node)
+
+            elif isinstance(node, ast.ClassDef):
+                class_source = ast.get_source_segment(cell_source, node)
+                if class_source is not None:
+                    latest_class_def[node.name] = (class_source, node)
+
+            elif isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        assign_source = ast.get_source_segment(cell_source, node)
+                        if assign_source is not None:
+                            latest_global_assign[target.id] = assign_source
+
+    return latest_function_def, latest_class_def, latest_global_assign, all_imports
+
+
+def _get_referenced_names(source_code: str) -> set[str]:
+    """Extract all names referenced in source code."""
+    import ast
+
+    try:
+        tree = ast.parse(source_code)
+    except SyntaxError:
+        return set()
+
+    names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            names.add(node.id)
+        elif isinstance(node, ast.Attribute):
+            # For module.function, capture the base module
+            if isinstance(node.value, ast.Name):
+                names.add(node.value.id)
+    return names
+
+
+def _collect_dependencies(
+    fn_source: str,
+    fn_name: str,
+    latest_function_def: dict[str, tuple[str, ast.AST]],
+    latest_class_def: dict[str, tuple[str, ast.AST]],
+    latest_global_assign: dict[str, str],
+    builtin_names: set[str],
+):
+    """Recursively collect all dependencies needed by the function."""
+    # maps name -> source
+    needed_functions: dict[str, str] = {}
+    needed_classes: dict[str, str] = {}
+    needed_globals: dict[str, str] = {}
+    needed_names: set[str] = set()
+
+    to_process = [fn_source]
+    processed = set()
+
+    while to_process:
+        current_source = to_process.pop()
+        if current_source in processed:
+            continue
+        processed.add(current_source)
+
+        referenced = _get_referenced_names(current_source)
+        referenced = referenced - builtin_names - {fn_name}
+        needed_names.update(referenced)
+
+        for name in referenced:
+            # Check if it's a class we defined
+            if name in latest_class_def and name not in needed_classes:
+                class_source, _ = latest_class_def[name]
+                needed_classes[name] = class_source
+                to_process.append(class_source)
+
+            # Check if it's a function we defined
+            elif name in latest_function_def and name not in needed_functions:
+                func_source, _ = latest_function_def[name]
+                needed_functions[name] = func_source
+                to_process.append(func_source)
+
+        for name in referenced:
+            # Check if it's a global variable we defined
+            if name in latest_global_assign and name not in needed_globals:
+                assign_source = latest_global_assign[name]
+                needed_globals[name] = assign_source
+                to_process.append(assign_source)
+
+    return needed_functions, needed_classes, needed_globals, needed_names
+
+
+def _filter_imports(all_imports: dict[str, tuple[list[str], ast.AST]], needed_names: set[str]) -> list[str]:
+    """Filter imports to only include those that are actually used."""
+    needed_imports: list[str] = []
+    for import_text, (imported_names, _) in all_imports.items():
+        if any(name in needed_names or name == import_text for name in imported_names):
+            needed_imports.append(import_text)
+    return needed_imports
+
+
+def _build_script(
+    fn_source: str,
+    fn_name: str,
+    needed_imports: list[str],
+    needed_globals: dict[str, str],
+    needed_classes: dict[str, str],
+    needed_functions: dict[str, str],
+) -> str:
+    """Build the final script from collected components."""
+    script_parts: list[str] = []
+
+    if needed_imports:
+        script_parts.extend(needed_imports)
+        script_parts.append("")
+
+    if needed_globals:
+        script_parts.extend(needed_globals.values())
+        script_parts.append("")
+
+    if needed_classes:
+        script_parts.extend(needed_classes.values())
+        script_parts.append("")
+
+    if needed_functions:
+        script_parts.extend(needed_functions.values())
+        script_parts.append("")
+
+    script_parts.append(fn_source)
+
+    return "\n".join(script_parts)
+
+
+def parse_notebook_into_script(fn: Callable[[], None], takes_argument: bool) -> str:
+    """
+    Parse a notebook function and its dependencies into a standalone Python script.
+
+    The function must take no inputs and produce no outputs. The output script will
+    call fn() in __main__ and include all necessary imports, globals, and helper
+    functions that have been executed in the notebook.
+
+    Args:
+        fn (Callable[[], None]): A callable with no parameters and no return value.
+
+    Returns:
+        str: A Python script as a string.
+    """
+    import builtins
+
+    if not is_notebook():
+        raise RuntimeError("parse_notebook_into_script should only be called from a notebook environment.")
+
+    sig = inspect.signature(fn)
+    if len(sig.parameters) != int(takes_argument):
+        raise ValueError(
+            f"Function {fn.__name__} must take {int(takes_argument)} inputs, but has parameters: {list(sig.parameters.keys())}"
+        )
+
+    shell = get_ipython_or_none()
+    if shell is None:
+        raise RuntimeError("Could not access IPython shell")
+
+    # Get the cell contents of executed cells
+    if getattr(shell, "history_manager", None) is None:
+        raise RuntimeError("Could not access IPython history manager")
+
+    history_manager = shell.history_manager
+    session_number = history_manager.get_last_session_id()
+    cells = list(history_manager.get_range(session=session_number, start=1))
+
+    # Parse cells to extract definitions
+    latest_function_def, latest_class_def, latest_global_assign, all_imports = _parse_notebook_cells(cells)
+
+    # Get function source and collect dependencies
+    fn_source = inspect.getsource(fn)
+    builtin_names = set(dir(builtins))
+
+    needed_functions, needed_classes, needed_globals, needed_names = _collect_dependencies(
+        fn_source, fn.__name__, latest_function_def, latest_class_def, latest_global_assign, builtin_names
+    )
+
+    # Filter imports to only used ones
+    needed_imports = _filter_imports(all_imports, needed_names)
+
+    # Build and return the script
+    script = _build_script(fn_source, fn.__name__, needed_imports, needed_globals, needed_classes, needed_functions)
+
+    if not is_valid_python_code(script):
+        raise RuntimeError("Error generating valid training function from notebook")
+
+    return script

chalk/utils/pl_helpers.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 import itertools
+import zoneinfo
 from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Iterator, TypeVar
+from typing import TYPE_CHECKING, Any, Iterator, TypeGuard, TypeVar, overload
 
 import pyarrow as pa
-import zoneinfo
 from packaging.version import parse
-from typing_extensions import TypeGuard
 
 from chalk.utils.log_with_context import get_logger
 from chalk.utils.missing_dependency import missing_dependency_exception
@@ -27,6 +26,13 @@ except ImportError:
     json_loads = json.loads
 
 
+def json_loads_as_str(x: str | None):
+    if x is None:
+        return None
+    x = json_loads(x)
+    return x if x is None else str(x)
+
+
 def is_version_gte(version: str, target: str) -> bool:
     return parse(version) >= parse(target)
 
@@ -36,9 +42,46 @@ try:
 
     is_new_polars = is_version_gte(pl.__version__, "0.18.0")
     polars_has_pad_start = is_version_gte(pl.__version__, "0.19.12")
+    polars_array_uses_shape = is_version_gte(pl.__version__, "1.0.0")
+    polars_uses_schema_overrides = is_version_gte(pl.__version__, "0.20.31")
+    polars_join_ignores_nulls = is_version_gte(pl.__version__, "0.20.0")
+    polars_broken_concat_on_nested_list = is_version_gte(pl.__version__, "1.0.0")
+    polars_group_by_instead_of_groupby = is_version_gte(pl.__version__, "1.0.0")
+    polars_name_dot_suffix_instead_of_suffix = is_version_gte(pl.__version__, "1.0.0")
+    polars_lazy_frame_collect_schema = is_version_gte(pl.__version__, "1.0.0")
+    polars_allow_lit_empty_struct = is_version_gte(pl.__version__, "1.0.0")
 except ImportError:
     is_new_polars = False
     polars_has_pad_start = False
+    polars_array_uses_shape = False
+    polars_uses_schema_overrides = False
+    polars_join_ignores_nulls = False
+    polars_broken_concat_on_nested_list = False
+    polars_group_by_instead_of_groupby = False
+    polars_name_dot_suffix_instead_of_suffix = False
+    polars_lazy_frame_collect_schema = False
+    polars_allow_lit_empty_struct = False
+
+
+def pl_array(inner: pl.PolarsDataType, size: int) -> pl.Array:
+    """Create a Polars Array type with version-compatible parameter names.
+
+    Args:
+        inner: The inner data type of the array
+        size: The fixed size of the array
+
+    Returns:
+        A Polars Array type
+    """
+    try:
+        import polars as pl
+    except ImportError:
+        raise missing_dependency_exception("chalkpy[runtime]")
+
+    if polars_array_uses_shape:
+        return pl.Array(inner=inner, shape=size)
+    else:
+        return pl.Array(inner=inner, width=size)  # type: ignore[call-arg]
 
 
 def chunked_df_slices(df: pl.LazyFrame | pl.DataFrame, chunk_size: int) -> Iterator[pl.DataFrame]:
@@ -100,13 +143,13 @@ def pl_datetime_to_iso_string(expr: pl.Expr, tz_key: str | None) -> pl.Expr:
     else:
         return pl.format(
             "{}-{}-{}T{}:{}:{}.{}" + timezone,
-            expr.dt.year().cast(pl.Utf8).str.rjust(4, "0"),
-            expr.dt.month().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.day().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.hour().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.minute().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.second().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.microsecond().cast(pl.Utf8).str.rjust(6, "0"),
+            expr.dt.year().cast(pl.Utf8).str.rjust(4, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.month().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.day().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.hour().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.minute().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.second().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.microsecond().cast(pl.Utf8).str.rjust(6, "0"),  # pyright: ignore -- polars backcompat
         )
 
 
@@ -126,9 +169,9 @@ def pl_date_to_iso_string(expr: pl.Expr) -> pl.Expr:
     else:
         return pl.format(
             "{}-{}-{}",
-            expr.dt.year().cast(pl.Utf8).str.rjust(4, "0"),
-            expr.dt.month().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.day().cast(pl.Utf8).str.rjust(2, "0"),
+            expr.dt.year().cast(pl.Utf8).str.rjust(4, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.month().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.day().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
         )
 
 
@@ -149,21 +192,39 @@ def pl_time_to_iso_string(expr: pl.Expr) -> pl.Expr:
     else:
         return pl.format(
             "{}:{}:{}.{}",
-            expr.dt.hour().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.minute().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.second().cast(pl.Utf8).str.rjust(2, "0"),
-            expr.dt.microsecond().cast(pl.Utf8).str.rjust(6, "0"),
+            expr.dt.hour().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.minute().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.second().cast(pl.Utf8).str.rjust(2, "0"),  # pyright: ignore -- polars backcompat
+            expr.dt.microsecond().cast(pl.Utf8).str.rjust(6, "0"),  # pyright: ignore -- polars backcompat
+        )
+
+
+def pl_dtype_swap(dtype: pl.PolarsDataType, _from: pl.PolarsDataType, to: pl.PolarsDataType) -> pl.PolarsDataType:
+    if isinstance(dtype, _from):
+        return to
+    if isinstance(dtype, pl.List):
+        return pl.List(inner=pl_dtype_swap(dtype.inner, _from, to))
+    if isinstance(dtype, pl.Struct):
+        return pl.Struct(
+            {field_name: pl_dtype_swap(field_dtype, _from, to) for field_name, field_dtype in dtype.to_schema().items()}
         )
+    return dtype
 
 
-def pl_json_decode(series: pl.Series, dtype: pl.PolarsDataType | None = None) -> pl.Series:
+def pl_json_decode(series: pl.Series, dtype: pl.PolarsDataType) -> pl.Series:
     if is_new_polars:
-        decoded_series = series.map_elements(json_loads, return_dtype=dtype)  # pyright: ignore -- polars backcompat
+        swapped_dtype = pl_dtype_swap(dtype, pl.Binary, pl.Utf8)
+        if swapped_dtype == pl.Utf8:
+            decoded_series = series.map_elements(json_loads_as_str, return_dtype=swapped_dtype).cast(
+                dtype
+            )  # pyright: ignore -- polars backcompat
+        else:
+            decoded_series = series.map_elements(json_loads, return_dtype=swapped_dtype).cast(
+                dtype
+            )  # pyright: ignore -- polars backcompat
     else:
-        decoded_series = series.apply(json_loads, return_dtype=dtype)
-    if dtype is not None:
-        # Special case -- for nested dtypes polars doesn't always respect the return_dtype
-        decoded_series = decoded_series.cast(dtype)
+        decoded_series = series.apply(json_loads, return_dtype=dtype)  # pyright: ignore -- polars backcompat
+    decoded_series = decoded_series.cast(dtype)
     return decoded_series
 
 
@@ -174,19 +235,33 @@ def pl_duration_to_iso_string(expr: pl.Expr) -> pl.Expr:
     except ImportError:
         raise missing_dependency_exception("chalkpy[runtime]")
 
-    return pl.format(
-        "{}P{}DT{}H{}M{}.{}S",
-        pl.when(expr.dt.microseconds() < 0).then(pl.lit("-")).otherwise(pl.lit("")),
-        expr.dt.days().abs().cast(pl.Utf8),
-        (expr.dt.hours().abs() % 24).cast(pl.Utf8),
-        (expr.dt.minutes().abs() % 60).cast(pl.Utf8),
-        (expr.dt.seconds().abs() % 60).cast(pl.Utf8),
-        (expr.dt.microseconds().abs() % 1_000_000)
-        .cast(pl.Utf8)
-        .str.pad_start(6, "0")  # pyright: ignore -- polars backcompat
-        if is_new_polars
-        else (expr.dt.microseconds().abs() % 1_000_000).cast(pl.Utf8).str.rjust(6, "0"),
-    )
+    try:
+        return pl.format(
+            "{}P{}DT{}H{}M{}.{}S",
+            pl.when(expr.dt.microseconds() < 0)  # pyright: ignore -- polars backcompat
+            .then(pl.lit("-"))
+            .otherwise(pl.lit("")),  # pyright: ignore -- polars backcompat
+            expr.dt.days().abs().cast(pl.Utf8),  # pyright: ignore -- polars backcompat
+            (expr.dt.hours().abs() % 24).cast(pl.Utf8),  # pyright: ignore -- polars backcompat
+            (expr.dt.minutes().abs() % 60).cast(pl.Utf8),  # pyright: ignore -- polars backcompat
+            (expr.dt.seconds().abs() % 60).cast(pl.Utf8),  # pyright: ignore -- polars backcompat
+            (expr.dt.microseconds().abs() % 1_000_000)  # pyright: ignore -- polars backcompat
+            .cast(pl.Utf8)
+            .str.pad_start(6, "0")  # pyright: ignore -- polars backcompat
+            if is_new_polars
+            else (expr.dt.microseconds().abs() % 1_000_000)  # pyright: ignore -- polars backcompat
+            .cast(pl.Utf8)
+            .str.rjust(6, "0"),  # pyright: ignore -- polars backcompat
+        )
+    except AttributeError:
+        return (
+            pl.format("{}P{}DT{}H{}M{}.{}S", expr.dt.total_microseconds().abs() % 1_000_000)
+            .cast(pl.Utf8)
+            .str.pad_start(
+                6,
+                "0",
+            )
+        )
 
 
 def pl_json_encode(expr: pl.Expr, dtype: pl.PolarsDataType):
@@ -374,7 +449,7 @@ def _json_encode_inner(expr: pl.Expr, dtype: pl.PolarsDataType) -> pl.Expr:
                     _backup_json_encode, return_dtype=pl.Utf8
                 )
             else:
-                return expr.apply(_backup_json_encode, return_dtype=pl.Utf8)
+                return expr.apply(_backup_json_encode, return_dtype=pl.Utf8)  # pyright: ignore -- polars backcompat
         expr = expr.fill_null([])
         lists_with_extra_none = (
             expr.list.concat(pl.lit(None))  # pyright: ignore -- back compat
@@ -469,3 +544,81 @@ def recursively_has_struct(dtype: pa.DataType) -> bool:
         assert isinstance(dtype, pa.MapType)
         return recursively_has_struct(dtype.key_type) or recursively_has_struct(dtype.item_type)
     return False
+
+
+def apply_compat(
+    expr: "pl.Expr",
+    function: Any,
+    return_dtype: "pl.PolarsDataType | None" = None,
+    **kwargs: Any,
+) -> "pl.Expr":
+    """
+    Apply a custom function to an expression in a version-compatible way.
+
+    In Polars >= 0.19, expr.apply() was deprecated in favor of expr.map_elements().
+    This function provides compatibility between versions.
+
+    Args:
+        expr: The Polars expression to apply the function to
+        function: The function to apply to each element
+        return_dtype: The return data type for the expression (optional)
+        **kwargs: Additional keyword arguments to pass to the underlying method
+
+    Returns:
+        A Polars expression with the function applied
+
+    Example:
+        >>> import polars as pl
+        >>> from chalkengine.utils.polars_compat_util import apply_compat
+        >>> df = pl.DataFrame({"a": [1, 2, 3]})
+        >>> df.select(apply_compat(pl.col("a"), lambda x: x * 2))
+    """
+    # Build kwargs for the call
+    call_kwargs = kwargs.copy()
+    if return_dtype is not None:
+        call_kwargs["return_dtype"] = return_dtype
+
+    try:
+        # Try newer API first: map_elements()
+        return expr.map_elements(function, **call_kwargs)  # type: ignore
+    except AttributeError:
+        # Fall back to older API: apply()
+        return expr.apply(function, **call_kwargs)  # type: ignore
+
+
+@overload
+def str_json_decode_compat(expr: "pl.Expr", dtype: "pl.PolarsDataType") -> "pl.Expr":
+    ...
+
+
+@overload
+def str_json_decode_compat(expr: "pl.Series", dtype: "pl.PolarsDataType") -> "pl.Series":
+    ...
+
+
+def str_json_decode_compat(expr: "pl.Expr | pl.Series", dtype: "pl.PolarsDataType") -> "pl.Expr | pl.Series":
+    """
+    Parse/decode JSON strings in a version-compatible way.
+
+    In newer Polars versions (>= 1.0), str.json_extract() was renamed to str.json_decode().
+    This function provides compatibility between versions.
+
+    Args:
+        expr: The Polars expression containing JSON strings to parse
+        dtype: The Polars data type to extract to
+
+    Returns:
+        A Polars expression that parses the JSON strings
+    """
+    try:
+        # Try newer API first: str.json_decode()
+        return expr.str.json_decode(dtype=dtype)  # type: ignore
+    except AttributeError:
+        # Fall back to older API: str.json_extract()
+        return expr.str.json_extract(dtype=dtype)  # type: ignore
+
+
+def schema_compat(df: "pl.DataFrame | pl.LazyFrame"):
+    if polars_lazy_frame_collect_schema and isinstance(df, pl.LazyFrame):
+        return df.collect_schema()
+    return df.schema

chalk/utils/pydanticutil/pydantic_compat.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 import json
 from inspect import isclass
-from typing import Any
+from typing import Any, TypeGuard
 
 import pydantic
 from packaging import version
 from pydantic import BaseModel
-from typing_extensions import TypeGuard
 
 try:
     from pydantic.v1 import BaseModel as V1BaseModel