rbx.cp 0.13.5__tar.gz → 0.13.7__tar.gz

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rbx.cp
-Version: 0.13.5
+Version: 0.13.7
 Summary: 
 Author: Roberto Sales
 Requires-Python: >=3.9.1,<4.0.0

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rbx.cp"
-version = "0.13.5"
+version = "0.13.7"
 description = ""
 packages = [
   {include = "rbx"}

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/code.py

@@ -174,7 +174,7 @@ def _ignore_warning_in_cxx_input(input: GradingFileInput):
     input.src = preprocessed_path
 
 
-def _maybe_rename_java_class(
+def maybe_rename_java_class(
     compilable_path: pathlib.Path, file_mapping: FileMapping
 ) -> pathlib.Path:
     mapped_path = PosixPath(file_mapping.compilable)
@@ -540,7 +540,7 @@ def compile_item(
     download.maybe_add_testlib(code, artifacts)
     download.maybe_add_jngen(code, artifacts)
     download.maybe_add_rbx_header(code, artifacts)
-    compilable_path = _maybe_rename_java_class(compilable_path, file_mapping)
+    compilable_path = maybe_rename_java_class(compilable_path, file_mapping)
     artifacts.inputs.append(
         GradingFileInput(src=compilable_path, dest=PosixPath(file_mapping.compilable))
     )

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/header.py

@@ -49,7 +49,7 @@ def _get_string_var_block() -> str:
     return _get_var_block(_get_vars_of_type(str, _string_repr))
 
 
-def _check_int_bounds(x: int) -> None:
+def check_int_bounds(x: int) -> None:
     if x >= 2**64:
         raise ValueError(
             f'Some variable you defined (value: {x}) is too large to fit in a C++ 64-bit integer (signed or unsigned)'
@@ -63,11 +63,19 @@ def _check_int_bounds(x: int) -> None:
 def _get_int_var_block() -> str:
     def _transform(x: Primitive) -> str:
         if isinstance(x, bool):
-            return str(int(x))
-        _check_int_bounds(int(x))
+            return f'static_cast<int64_t>({int(x)})'
+        check_int_bounds(int(x))
         return f'static_cast<int64_t>({x})'
 
-    return _get_var_block(_get_vars_of_type(int, _transform))
+    # Get both int and bool variables for the int block
+    pkg = package.find_problem_package_or_die()
+    vars = pkg.expanded_vars
+    int_vars = {
+        name: _transform(value)
+        for name, value in vars.items()
+        if isinstance(value, (int, bool))
+    }
+    return _get_var_block(int_vars)
 
 
 def _get_float_var_block() -> str:
@@ -81,11 +89,9 @@ def _get_bool_var_block() -> str:
 def _get_vars_of_type(t: Type, transform: Callable[[Primitive], str]) -> Dict[str, str]:
     pkg = package.find_problem_package_or_die()
     vars = pkg.expanded_vars
-
-    def is_valid(value: Primitive) -> bool:
-        return isinstance(value, t)
-
-    return {name: transform(value) for name, value in vars.items() if is_valid(value)}
+    return {
+        name: transform(value) for name, value in vars.items() if isinstance(value, t)
+    }
 
 
 def _get_var_block(mappings: Dict[str, str]) -> str:

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/statements/latex_jinja.py

@@ -119,7 +119,7 @@ def scientific_notation(
     mult, exp, rest = _process_zeroes(value)
     if exp < zeroes:
         return str(value)
-    res = '10' if exp == 1 else f'10^{exp}'
+    res = '10' if exp == 1 else f'10^{{{exp}}}'
     if rest > 0 and len(str(rest)) + 1 >= len(str(value)):
         # Should not convert numbers like 532 to 5*10^2 + 32.
         return str(value)

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/testcase_extractors.py

@@ -30,7 +30,7 @@ def _get_group_output(
     return group_path / f'{subgroup_prefix}{i:03d}.out'
 
 
-async def _run_generator_script(testcase: TestcaseSubgroup) -> str:
+async def run_generator_script(testcase: TestcaseSubgroup) -> str:
     assert testcase.generatorScript is not None
 
     cacher = package.get_file_cacher()
@@ -240,7 +240,7 @@ async def run_testcase_visitor(visitor: TestcaseVisitor):
 
         # Run generator script.
         if subgroup.generatorScript is not None:
-            script = await _run_generator_script(subgroup)
+            script = await run_generator_script(subgroup)
 
             # Run each line from generator script.
             for generator_name, args, line_number in _extract_script_lines(script):

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/testcase_utils.py

@@ -40,6 +40,8 @@ class TestcaseEntry(BaseModel):
 
 
 class TestcasePattern(BaseModel):
+    __test__ = False
+
     group_prefix: List[str]
     index: Optional[int] = None
 

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/testing/testing_package.py

@@ -1,19 +1,25 @@
 import pathlib
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from rbx import console, utils
-from rbx.box import presets
+from rbx.box import package, presets
 from rbx.box.fields import Primitive
 from rbx.box.schema import (
+    CheckerTest,
     CodeItem,
     ExpectedOutcome,
     Generator,
+    GeneratorCall,
     Interactor,
     Package,
     Solution,
     TaskType,
+    Testcase,
     TestcaseGroup,
+    TestcaseSubgroup,
+    ValidatorOutcome,
+    ValidatorTest,
 )
 from rbx.box.testing.testing_preset import TestingPreset
 from rbx.box.testing.testing_shared import PathOrStr, TestingShared
@@ -79,6 +85,9 @@ class TestingPackage(TestingShared):
 
     def save(self):
         self.yml_path.write_text(utils.model_to_yaml(self.yml))
+        # Clear internal cache and package cache to ensure the updated package is loaded fresh
+        self._yml = None
+        package.clear_package_cache()
 
     def set_type(self, type: TaskType):
         self.yml.type = type
@@ -223,6 +232,154 @@ class TestingPackage(TestingShared):
         ]
         self.save()
 
+    def add_testgroup_with_subgroups(
+        self,
+        name: str,
+        subgroups: List[Dict[str, Any]],
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        """Add a testgroup with subgroups.
+
+        Args:
+            name: Name of the testgroup
+            subgroups: List of subgroup definitions, each containing fields like:
+                - name: subgroup name
+                - generators: list of generator calls
+                - testcases: list of testcase objects
+                - testcaseGlob: glob pattern
+                - generatorScript: generator script path
+                - extraValidators: list of extra validators
+        """
+
+        subgroup_objects = []
+        for subgroup_data in subgroups:
+            subgroup_dict = {'name': subgroup_data['name']}
+
+            if 'generators' in subgroup_data:
+                subgroup_dict['generators'] = [
+                    GeneratorCall(name=gen['name'], args=gen.get('args'))
+                    for gen in subgroup_data['generators']
+                ]
+
+            if 'testcases' in subgroup_data:
+                subgroup_dict['testcases'] = [
+                    Testcase(
+                        inputPath=pathlib.Path(tc['inputPath']),
+                        outputPath=pathlib.Path(tc['outputPath'])
+                        if tc.get('outputPath')
+                        else None,
+                    )
+                    for tc in subgroup_data['testcases']
+                ]
+
+            if 'testcaseGlob' in subgroup_data:
+                subgroup_dict['testcaseGlob'] = subgroup_data['testcaseGlob']
+
+            if 'generatorScript' in subgroup_data:
+                subgroup_dict['generatorScript'] = CodeItem(
+                    path=pathlib.Path(subgroup_data['generatorScript'])
+                )
+
+            if 'extraValidators' in subgroup_data:
+                subgroup_dict['extraValidators'] = [
+                    CodeItem(path=pathlib.Path(v))
+                    for v in subgroup_data['extraValidators']
+                ]
+
+            subgroup_objects.append(TestcaseSubgroup(**subgroup_dict))
+
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                subgroups=subgroup_objects,
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
+    def add_testgroup_with_manual_testcases(
+        self,
+        name: str,
+        testcases: List[Dict[str, str]],
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        """Add a testgroup with manually defined testcases.
+
+        Args:
+            name: Name of the testgroup
+            testcases: List of testcase definitions, each containing:
+                - inputPath: path to input file
+                - outputPath: optional path to output file
+        """
+
+        testcase_objects = []
+        for tc_data in testcases:
+            testcase_objects.append(
+                Testcase(
+                    inputPath=pathlib.Path(tc_data['inputPath']),
+                    outputPath=pathlib.Path(tc_data['outputPath'])
+                    if tc_data.get('outputPath')
+                    else None,
+                )
+            )
+
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                testcases=testcase_objects,
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
+    def add_testgroup_with_generators(
+        self,
+        name: str,
+        generators: List[Dict[str, str]],
+        validator: Optional[PathOrStr] = None,
+        extra_validators: Optional[List[PathOrStr]] = None,
+    ):
+        """Add a testgroup with generator calls.
+
+        Args:
+            name: Name of the testgroup
+            generators: List of generator definitions, each containing:
+                - name: generator name
+                - args: optional generator arguments
+        """
+
+        generator_objects = []
+        for gen_data in generators:
+            generator_objects.append(
+                GeneratorCall(name=gen_data['name'], args=gen_data.get('args'))
+            )
+
+        self.yml.testcases = self.yml.testcases + [
+            TestcaseGroup(
+                name=name,
+                generators=generator_objects,
+                validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+                extraValidators=[
+                    CodeItem(path=pathlib.Path(v)) for v in extra_validators
+                ]
+                if extra_validators
+                else [],
+            )
+        ]
+        self.save()
+
     def get_build_testgroup_path(self, name: str) -> pathlib.Path:
         return self.root / 'build' / 'tests' / name
 
@@ -244,3 +401,59 @@ class TestingPackage(TestingShared):
         if interactor_pipes_path.exists():
             contents.interactor_pipes = interactor_pipes_path.read_text()
         return contents
+
+    def add_validator_unit_test(
+        self,
+        glob: str,
+        outcome: ValidatorOutcome = ValidatorOutcome.VALID,
+        validator: Optional[PathOrStr] = None,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the validator.
+
+        Args:
+            glob: Glob pattern for input files
+            outcome: Expected validation outcome
+            validator: Optional validator to use (if not main validator)
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        validator_test = ValidatorTest(
+            glob=glob,
+            outcome=outcome,
+            validator=CodeItem(path=pathlib.Path(validator)) if validator else None,
+        )
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.validator = unit_tests.validator + [validator_test]
+        self.yml.unitTests = unit_tests
+        self.save()
+
+    def add_checker_unit_test(
+        self,
+        glob: str,
+        outcome: ExpectedOutcome = ExpectedOutcome.ACCEPTED,
+        files: Optional[Dict[str, str]] = None,
+    ):
+        """Add a unit test for the checker.
+
+        Args:
+            glob: Glob pattern for test files
+            outcome: Expected checker outcome
+            files: Optional dict of {filename: content} to create test files
+        """
+        if files:
+            for filename, content in files.items():
+                self.add_file(filename).write_text(content)
+
+        checker_test = CheckerTest(glob=glob, outcome=outcome)
+
+        # Explicitly set the unitTests field to mark it as dirty
+        unit_tests = self.yml.unitTests
+        unit_tests.checker = unit_tests.checker + [checker_test]
+        self.yml.unitTests = unit_tests
+        self.save()

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/testing/testing_shared.py

@@ -55,7 +55,10 @@ class TestingShared:
         return filename
 
     def relpath(self, path: PathOrStr) -> pathlib.Path:
-        return pathlib.Path(path).relative_to(self.root)
+        path = pathlib.Path(path)
+        if not path.is_relative_to(self.root):
+            return path
+        return path.relative_to(self.root)
 
     def add_from_testdata(self, path: PathOrStr, src: PathOrStr):
         testdata_path = get_testdata_path()

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/box/unit.py

@@ -41,7 +41,7 @@ class CheckerTestEntry(BaseModel):
         return ', '.join(res)
 
 
-def _extract_validator_test_entries(
+def extract_validator_test_entries(
     tests: List[ValidatorTest],
 ) -> List[ValidatorTestEntry]:
     res: List[ValidatorTestEntry] = []
@@ -57,7 +57,7 @@ def _extract_validator_test_entries(
     return sorted(res, key=lambda x: x.input.name)
 
 
-def _extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
+def extract_checker_test_entries(tests: List[CheckerTest]) -> List[CheckerTestEntry]:
     res: List[CheckerTestEntry] = []
     seen: Set[pathlib.Path] = set()
     for test in tests:
@@ -94,7 +94,7 @@ def _get_validator_for_test(test: ValidatorTestEntry) -> Optional[CodeItem]:
 async def run_validator_unit_tests(progress: StatusProgress):
     pkg = package.find_problem_package_or_die()
 
-    entries = _extract_validator_test_entries(pkg.unitTests.validator)
+    entries = extract_validator_test_entries(pkg.unitTests.validator)
 
     vals: List[CodeItem] = []
     for test in entries:
@@ -158,7 +158,7 @@ async def run_checker_unit_tests(progress: StatusProgress):
 
     console.console.rule('Checker tests', style='info')
 
-    entries = _extract_checker_test_entries(pkg.unitTests.checker)
+    entries = extract_checker_test_entries(pkg.unitTests.checker)
     if not entries:
         console.console.print('No checker unit tests found.')
         return

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/caching.py

@@ -371,7 +371,7 @@ class DependencyCache:
         self.transient_db = SqliteDict(str(tmp_dir / '.cache_db'), autocommit=True)
         atexit.register(lambda: self.db.close())
         atexit.register(lambda: self.transient_db.close())
-        atexit.register(lambda: shutil.rmtree(tmp_dir))
+        atexit.register(lambda: shutil.rmtree(tmp_dir, ignore_errors=True))
 
     def _cache_name(self) -> str:
         return str(self.root / '.cache_db')

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/judge/cacher.py

@@ -73,7 +73,9 @@ class FileCacher:
             self.file_dir = pathlib.Path(tempfile.mkdtemp())
             # Delete this directory on exit since it has a random name and
             # won't be used again.
-            atexit.register(lambda: shutil.rmtree(str(self.file_dir)))
+            atexit.register(
+                lambda: shutil.rmtree(str(self.file_dir), ignore_errors=True)
+            )
         else:
             assert folder is not None
             self.file_dir = folder / 'fs-cache-shared'
@@ -84,7 +86,7 @@ class FileCacher:
         self.temp_dir = pathlib.Path(
             tempfile.mkdtemp(dir=self.file_dir, prefix='_temp')
         )
-        atexit.register(lambda: shutil.rmtree(str(self.temp_dir)))
+        atexit.register(lambda: shutil.rmtree(str(self.temp_dir), ignore_errors=True))
         # Just to make sure it was created.
 
     def is_shared(self) -> bool:
@@ -526,7 +528,7 @@ class FileCacher:
         """
         if self.is_shared():
             raise Exception('You may not destroy a shared cache.')
-        shutil.rmtree(str(self.file_dir))
+        shutil.rmtree(str(self.file_dir), ignore_errors=True)
 
     def list(self) -> List[storage.FileWithMetadata]:
         """List the files available in the storage.

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/judge/program.py

@@ -94,12 +94,40 @@ def get_preexec_fn(params: ProgramParams):
 
 
 def get_memory_usage(ru: resource.struct_rusage) -> int:
+    """Get memory usage in bytes from resource usage statistics.
+
+    Returns the total memory usage (RSS + shared memory segments) in bytes.
+
+    Platform differences in ru.ru_maxrss:
+    - macOS/Darwin: ru.ru_maxrss is in bytes
+    - Linux: ru.ru_maxrss is in kilobytes
+
+    This function normalizes the result to always return bytes.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        int: Total memory usage in bytes
+    """
     if sys.platform == 'darwin':
-        return ru.ru_maxrss // 1024 + ru.ru_ixrss
-    return ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss
+        # On macOS, ru.ru_maxrss is already in bytes
+        return ru.ru_maxrss + ru.ru_ixrss * 1024
+    # On Linux, ru.ru_maxrss is in kilobytes, so convert to bytes
+    return (ru.ru_maxrss + ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss) * 1024
 
 
 def get_cpu_time(ru: resource.struct_rusage) -> float:
+    """Get CPU time in seconds from resource usage statistics.
+
+    Returns the total CPU time (user + system) in seconds.
+
+    Args:
+        ru: Resource usage statistics from os.wait4() or similar
+
+    Returns:
+        float: Total CPU time in seconds
+    """
     return ru.ru_utime + ru.ru_stime
 
 
@@ -239,6 +267,10 @@ class Program:
         ):
             program_codes.append(ProgramCode.WT)
             program_codes.append(ProgramCode.TO)
+        # Memory limit checking: Two ways a process can exceed memory limits:
+        # 1. Runtime monitoring (_handle_alarm) kills the process during execution
+        # 2. Post-execution check using ru.ru_maxrss detects peak memory usage exceeded limit
+        # Both memory_used (from ru.ru_maxrss) and memory_limit (converted to bytes) are in bytes
         if (
             self.params.memory_limit is not None
             and memory_used > self.params.memory_limit * 1024 * 1024

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/judge/sandbox.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-import collections
 import dataclasses
 import io
 import json
@@ -146,12 +145,6 @@ class SandboxParams(pydantic.BaseModel):
     reverse_io: bool = False
     pgid: Optional[int] = None
 
-    # For timeit
-    timeit_dups: Dict[str, List[pathlib.Path]] = dataclasses.field(
-        default_factory=lambda: collections.defaultdict(list)
-    )
-    timeit_prefix: Optional[str] = None
-
     def get_cacheable_params(self) -> Dict[str, Any]:
         return self.model_dump(mode='json', exclude_unset=True, exclude_none=True)
 

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/judge/sandboxes/stupid_sandbox.py

@@ -5,6 +5,7 @@ import logging
 import os
 import pathlib
 import shutil
+import signal
 import subprocess
 import sys
 import tempfile
@@ -313,7 +314,12 @@ class StupidSandbox(SandboxBase):
                 if should_tee:
                     assert interactor_tee.pipes.output is not None
                     interactor_tee.pipes.output.close()
-                # TODO: kill in case of WA
+
+                if idx == 0 and program_result.exitcode != 0:
+                    try:
+                        os.killpg(group_id, signal.SIGKILL)
+                    except Exception:
+                        pass
             elif pid == program.pid:
                 program_result = program.process_exit(status, ru)
                 results[0] = self._get_sandbox_log(program_result, params)

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/judge/storage.py

@@ -277,8 +277,14 @@ class FilesystemStorage(Storage):
             return None
 
         # Create a temporary file in the same directory
+        # Use only the basename for the suffix to avoid issues with subdirectories
+        filename_basename = pathlib.Path(filename).name
         temp_file = tempfile.NamedTemporaryFile(
-            'wb', delete=False, prefix='.tmp.', suffix=filename, dir=self.path
+            'wb',
+            delete=False,
+            prefix='.tmp.',
+            suffix=f'.{filename_basename}',
+            dir=self.path,
         )
         metadata: Dict[str, Optional[BaseModel]] = {'compression': None}
         if self.compress or grading_context.should_compress():

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/grading/steps.py

@@ -595,7 +595,7 @@ def _maybe_complain_about_sanitization(command: str) -> None:
         raise typer.Exit(1)
 
 
-def _check_for_sanitizer_warnings_in_line(line: str) -> bool:
+def check_for_sanitizer_warnings_in_line(line: str) -> bool:
     line = line.lower()
     return 'runtime error:' in line or '==error' in line
 
@@ -608,7 +608,7 @@ def _check_for_sanitizer_warnings(
     if not sandbox.file_exists(stderr_file):
         return False
     with sandbox.get_file(stderr_file) as f:
-        return any(_check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
+        return any(check_for_sanitizer_warnings_in_line(line.decode()) for line in f)
 
 
 _WARNING_RE = re.compile(r'([^:]+):\d+:\d+:[ ]+warning:.*')

{rbx_cp-0.13.5 → rbx_cp-0.13.7}/rbx/utils.py

@@ -103,14 +103,62 @@ def uploaded_schema_path(model: Type[BaseModel]) -> str:
     return f'https://rsalesc.github.io/rbx/schemas/{model.__name__}.json'
 
 
-def model_to_yaml(model: BaseModel) -> str:
+def model_to_yaml(model: BaseModel, **kwargs) -> str:
+    """Convert model to YAML string with proper boolean handling.
+
+    This function works around Pydantic's issue where Union[str, int, float, bool]
+    fields convert booleans to floats when using mode='json'.
+    """
+    # Use regular dump to preserve boolean types
+    data = model.model_dump(exclude_unset=True, exclude_none=True)
+
+    # Ensure the result is JSON-serializable by converting any non-JSON types
+    json_safe_data = _ensure_json_serializable(data)
+
+    # Add schema path comment and convert to YAML
     path = uploaded_schema_path(model.__class__)
-    return f'# yaml-language-server: $schema={path}\n\n' + yaml.dump(
-        model.model_dump(mode='json', exclude_unset=True, exclude_none=True),
-        sort_keys=False,
-        allow_unicode=True,
+    schema_comment = f'# yaml-language-server: $schema={path}\n\n'
+
+    yaml_content = yaml.safe_dump(
+        json_safe_data, sort_keys=False, allow_unicode=True, **kwargs
     )
 
+    return schema_comment + yaml_content
+
+
+def _ensure_json_serializable(obj):
+    """Recursively ensure an object is JSON-serializable while preserving booleans."""
+    from datetime import date, datetime
+    from enum import Enum
+    from pathlib import Path
+    from uuid import UUID
+
+    from rbx.autoenum import AutoEnum
+
+    if isinstance(obj, dict):
+        return {k: _ensure_json_serializable(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, tuple):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, set):
+        return [_ensure_json_serializable(item) for item in obj]
+    elif isinstance(obj, AutoEnum):
+        return str(obj)
+    elif isinstance(obj, Enum):
+        return obj.value
+    elif isinstance(obj, (str, int, float, bool)) or obj is None:
+        return obj
+    elif isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+    elif isinstance(obj, UUID):
+        return str(obj)
+    elif isinstance(obj, Path):
+        return str(obj)
+    else:
+        # For any other type, try to convert to string
+        return str(obj)
+
 
 def model_from_yaml(model: Type[T], s: str) -> T:
     return model(**yaml.safe_load(s))