rbx.cp 0.5.40__py3-none-any.whl → 0.5.45__py3-none-any.whl

rbx/box/package.py

@@ -1,5 +1,8 @@
+import atexit
 import functools
+import os
 import pathlib
+import shutil
 import sys
 from typing import Dict, List, Optional, Tuple
 
@@ -201,7 +204,9 @@ def get_digest_as_string(
 
 
 def get_new_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
-    return get_sandbox_type()(file_cacher=get_file_cacher(root), temp_dir=TEMP_DIR)
+    sandbox = get_sandbox_type()(file_cacher=get_file_cacher(root), temp_dir=TEMP_DIR)
+    atexit.register(lambda: sandbox.cleanup(delete=True))
+    return sandbox
 
 
 @functools.cache
@@ -209,6 +214,13 @@ def get_singleton_sandbox(root: pathlib.Path = pathlib.Path()) -> SandboxBase:
     return get_new_sandbox(root)
 
 
+@functools.cache
+def get_singleton_interactor_sandbox(
+    root: pathlib.Path = pathlib.Path(),
+) -> SandboxBase:
+    return get_new_sandbox(root)
+
+
 @functools.cache
 def get_build_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
     return find_problem(root) / 'build'
@@ -266,6 +278,23 @@ def get_checker(root: pathlib.Path = pathlib.Path()) -> CodeItem:
     )
 
 
+@functools.cache
+def get_interactor_or_nil(root: pathlib.Path = pathlib.Path()) -> Optional[CodeItem]:
+    package = find_problem_package_or_die(root)
+    return package.interactor
+
+
+@functools.cache
+def get_interactor(root: pathlib.Path = pathlib.Path()) -> CodeItem:
+    interactor = get_interactor_or_nil(root)
+    if interactor is None:
+        console.console.print(
+            '[error]Problem does not have an interactor configured.[/error]'
+        )
+        raise typer.Exit(1)
+    return interactor
+
+
 @functools.cache
 def get_solutions(root: pathlib.Path = pathlib.Path()) -> List[Solution]:
     package = find_problem_package_or_die(root)
@@ -364,9 +393,35 @@ def get_compilation_files(code: CodeItem) -> List[Tuple[pathlib.Path, pathlib.Pa
     return res
 
 
+@functools.cache
+def get_shared_dir(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    shared_dir = get_problem_cache_dir(root) / '.shared'
+    shared_dir.mkdir(parents=True, exist_ok=True)
+    return shared_dir
+
+
 @functools.cache
 def get_empty_sentinel_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
-    path = get_problem_cache_dir(root) / '.empty'
+    path = get_shared_dir(root) / '.empty'
+    path.write_text('')
+    return path
+
+
+@functools.cache
+def get_fifos(root: pathlib.Path = pathlib.Path()) -> Tuple[pathlib.Path, pathlib.Path]:
+    path = get_shared_dir(root) / '.fifos'
+    shutil.rmtree(path, ignore_errors=True)
+    path.mkdir(parents=True, exist_ok=True)
+    fifo_in = path / 'fifo.in'
+    fifo_out = path / 'fifo.out'
+    os.mkfifo(fifo_in)
+    os.mkfifo(fifo_out)
+    return fifo_in, fifo_out
+
+
+@functools.cache
+def get_merged_capture_path(root: pathlib.Path = pathlib.Path()) -> pathlib.Path:
+    path = get_shared_dir(root) / '.merged_capture'
     path.write_text('')
     return path
 

rbx/box/packaging/boca/packager.py

@@ -169,7 +169,8 @@ class BocaPackager(BasePackager):
             compile_text = compile_text.replace('{{rbxFlags}}', flags[language])
         return compile_text
 
-    def _copy_solutions(self, into_path: pathlib.Path):
+    def _copy_solutions(self, into_path: pathlib.Path, fix_java: bool = True):
+        into_path = into_path / 'solutions'
         for solution in package.get_solutions():
             dest_path = (
                 into_path

rbx/box/packaging/main.py

@@ -2,6 +2,7 @@ import pathlib
 import tempfile
 from typing import Type
 
+import syncer
 import typer
 
 from rbx import annotations, console
@@ -13,20 +14,21 @@ from rbx.box.statements.build_statements import build_statement
 app = typer.Typer(no_args_is_help=True, cls=annotations.AliasGroup)
 
 
-def run_packager(
+async def run_packager(
     packager_cls: Type[BasePackager],
     verification: environment.VerificationParam,
+    **kwargs,
 ) -> pathlib.Path:
     from rbx.box import builder
 
-    if not builder.verify(verification=verification):
+    if not await builder.verify(verification=verification):
         console.console.print(
             '[error]Build or verification failed, check the report.[/error]'
         )
         raise typer.Exit(1)
 
     pkg = package.find_problem_package_or_die()
-    packager = packager_cls()
+    packager = packager_cls(**kwargs)
 
     statement_types = packager.statement_types()
     built_statements = []
@@ -55,27 +57,33 @@ def run_packager(
 
 
 @app.command('polygon', help='Build a package for Polygon.')
-def polygon(
+@syncer.sync
+async def polygon(
     verification: environment.VerificationParam,
 ):
     from rbx.box.packaging.polygon.packager import PolygonPackager
 
-    run_packager(PolygonPackager, verification=verification)
+    await run_packager(PolygonPackager, verification=verification)
 
 
 @app.command('boca', help='Build a package for BOCA.')
-def boca(
+@syncer.sync
+async def boca(
     verification: environment.VerificationParam,
 ):
     from rbx.box.packaging.boca.packager import BocaPackager
 
-    run_packager(BocaPackager, verification=verification)
+    await run_packager(BocaPackager, verification=verification)
 
 
 @app.command('moj', help='Build a package for MOJ.')
-def moj(
+@syncer.sync
+async def moj(
     verification: environment.VerificationParam,
+    for_boca: bool = typer.Option(
+        False, help='Build a package for BOCA instead of MOJ.'
+    ),
 ):
     from rbx.box.packaging.moj.packager import MojPackager
 
-    run_packager(MojPackager, verification=verification)
+    await run_packager(MojPackager, verification=verification, for_boca=for_boca)

rbx/box/packaging/moj/packager.py

@@ -10,11 +10,16 @@ from rbx.box.environment import get_extension_or_default
 from rbx.box.packaging.boca.extension import BocaExtension
 from rbx.box.packaging.boca.packager import BocaPackager
 from rbx.box.packaging.packager import BuiltStatement
-from rbx.config import get_default_app_path
+from rbx.box.schema import ExpectedOutcome
+from rbx.config import get_default_app_path, get_testlib
 from rbx.grading.judge.digester import digest_cooperatively
 
 
 class MojPackager(BocaPackager):
+    def __init__(self, for_boca: bool = False):
+        super().__init__()
+        self.for_boca = for_boca
+
     def _get_problem_info(self) -> str:
         statement = self._get_main_statement()
         return (
@@ -23,17 +28,20 @@ class MojPackager(BocaPackager):
             f'descfile={self._get_problem_name()}.pdf\n'
         )
 
-    def _get_limits(self) -> str:
+    def _get_tl(self) -> str:
         extension = get_extension_or_default('boca', BocaExtension)
 
         pkg = package.find_problem_package_or_die()
-        tl = pkg.timeLimit
+        res = f'TL[default]={pkg.timeLimit / 1000}\n'
+        for language in extension.languages:
+            res += f'TL[{language}]={self._get_pkg_timelimit(language) / 1000}\n'
+        return res
+
+    def _get_limits(self) -> str:
+        pkg = package.find_problem_package_or_die()
         ml = pkg.memoryLimit
         ol = pkg.outputLimit
-        conf = f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml}\n' f'TL[default]={tl / 1000}\n'
-        for language in extension.languages:
-            conf += f'TL[{language}]={self._get_pkg_timelimit(language) / 1000}\n'
-        return conf
+        return f'ULIMITS[-f]={ol}\n' f'ULIMITS[-v]={ml * 1024}\n'
 
     def _get_compare(self) -> str:
         extension = get_extension_or_default('boca', BocaExtension)
@@ -57,6 +65,24 @@ class MojPackager(BocaPackager):
     def _get_checker(self) -> str:
         return package.get_checker().path.read_text()
 
+    def _copy_solutions_moj(self, into_path: pathlib.Path):
+        into_path = into_path / 'sols'
+        has_good = False
+        for solution in package.get_solutions():
+            tag = 'wrong'
+            if solution.outcome == ExpectedOutcome.ACCEPTED:
+                tag = 'good'
+                has_good = True
+            elif solution.outcome.is_slow():
+                tag = 'slow'
+            dest_path = into_path / tag / solution.path.name
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(str(solution.path), dest_path)
+
+        if not has_good:
+            console.console.print('[error]No good solution found.[/error]')
+            raise typer.Exit(1)
+
     def name(self) -> str:
         return 'moj'
 
@@ -80,10 +106,22 @@ class MojPackager(BocaPackager):
         limits_path.parent.mkdir(parents=True, exist_ok=True)
         limits_path.write_text(self._get_limits())
 
+        # Prepare TL
+        if self.for_boca:
+            tl_path = into_path / 'tl'
+            tl_path.parent.mkdir(parents=True, exist_ok=True)
+            tl_path.write_text(self._get_tl())
+
         # Prepare compare
         compare_path = into_path / 'scripts' / 'compare.sh'
         compare_path.parent.mkdir(parents=True, exist_ok=True)
         compare_path.write_text(self._get_compare())
+        compare_path.chmod(0o755)
+
+        # Prepare testlib
+        testlib_path = into_path / 'scripts' / 'testlib.h'
+        testlib_path.parent.mkdir(parents=True, exist_ok=True)
+        testlib_path.write_text(get_testlib().read_text())
 
         # Prepare checker
         checker_path = into_path / 'scripts' / 'checker.cpp'
@@ -99,9 +137,10 @@ class MojPackager(BocaPackager):
         )
 
         # Copy solutions
-        solutions_path = into_path / 'solutions'
-        solutions_path.mkdir(parents=True, exist_ok=True)
-        self._copy_solutions(solutions_path)
+        if self.for_boca:
+            self._copy_solutions(into_path, fix_java=False)
+        else:
+            self._copy_solutions_moj(into_path)
 
         # Prepare IO
         inputs_path = into_path / 'tests' / 'input'

rbx/box/retries.py

@@ -3,7 +3,7 @@ import pathlib
 import shutil
 import tempfile
 from contextlib import contextmanager
-from typing import Callable, List, Optional
+from typing import Awaitable, Callable, List, Optional
 
 from rbx.box import package
 from rbx.box.setter_config import RepeatsConfig, get_setter_config
@@ -104,18 +104,18 @@ class Retrier:
         self.retries_for_stress = self.config.retries_for_stress
         self.retry_index = 0
 
-    def repeat(
+    async def repeat(
         self,
-        func: Callable[[int], Evaluation],
+        func: Callable[[int], Awaitable[Evaluation]],
     ) -> Evaluation:
         self.retry_index += 1
-        eval = func(self.retry_index)
+        eval = await func(self.retry_index)
         if self.should_repeat(eval):
             with _temp_retry_dir() as temp_dir:
                 # Move files to temp dir to open run for repeat.
                 recover = _move_logs_to_temp_dir(eval, temp_dir)
                 # Actually repeat and choose the best evaluation.
-                next_eval = self.repeat(func)
+                next_eval = await self.repeat(func)
                 chosen_eval = _merge_evaluations(eval, next_eval)
 
                 if id(chosen_eval) == id(eval):

rbx/box/schema.py

@@ -82,16 +82,16 @@ class ExpectedOutcome(AutoEnum):
     RUNTIME_ERROR = alias('runtime error', 'rte', 're')  # type: ignore
     """Expected outcome solutions that finish with non-zero code (RTE)."""
 
-    TIME_LIMIT_EXCEEDED = alias('time limit exceeded', 'timeout', 'tle')  # type: ignore
+    TIME_LIMIT_EXCEEDED = alias('time limit exceeded', 'timeout', 'tle', 'tl')  # type: ignore
     """Expected outcome for solutions that do not finish in time."""
 
-    MEMORY_LIMIT_EXCEEDED = alias('memory limit exceeded', 'mle')  # type: ignore
+    MEMORY_LIMIT_EXCEEDED = alias('memory limit exceeded', 'mle', 'ml')  # type: ignore
     """Expected outcome for solutions that use more memory than allowed."""
 
-    OUTPUT_LIMIT_EXCEEDED = alias('output limit exceeded', 'ole')  # type: ignore
+    OUTPUT_LIMIT_EXCEEDED = alias('output limit exceeded', 'ole', 'ol')  # type: ignore
     """Expected outcome for solutions that use more output than allowed."""
 
-    TLE_OR_RTE = alias('tle or rte', 'tle/rte', 'tle+rte')  # type: ignore
+    TLE_OR_RTE = alias('tle or rte', 'tle/rte', 'tle+rte', 'tle or re', 'tle+re')  # type: ignore
     """Expected outcome for solutions that finish with either TLE or RTE.
 
     Especially useful for environments where TLE and RTE are indistinguishable."""
@@ -156,6 +156,14 @@ class ValidatorOutcome(AutoEnum):
     """Expected outcome for invalid tests."""
 
 
+class TaskType(AutoEnum):
+    BATCH = alias('batch')  # type: ignore
+    """Batch task."""
+
+    COMMUNICATION = alias('communication')  # type: ignore
+    """Communication task."""
+
+
 class CodeItem(BaseModel):
     model_config = ConfigDict(extra='forbid')
 
@@ -404,6 +412,10 @@ class Package(BaseModel):
     # Name of the problem.
     name: str = NameField(description='The name of the problem.')
 
+    type: TaskType = Field(
+        default=TaskType.BATCH, description='The type of the problem.'
+    )
+
     timeLimit: int = Field(description='Time limit of the problem, in milliseconds.')
 
     memoryLimit: int = Field(description='Memory limit of the problem, in MB.')
@@ -423,6 +435,10 @@ class Package(BaseModel):
         default=None, description='The checker for this problem.'
     )
 
+    interactor: Optional[CodeItem] = Field(
+        default=None, description='The interactor for this problem.'
+    )
+
     validator: Optional[CodeItem] = Field(
         default=None, description='The validator for this problem.'
     )

rbx/box/solutions.py

@@ -17,11 +17,13 @@ from pydantic import BaseModel
 
 from rbx import console, utils
 from rbx.box import checkers, package
-from rbx.box.code import SanitizationLevel, compile_item, find_language_name, run_item
+from rbx.box.code import (
+    SanitizationLevel,
+    compile_item,
+    find_language_name,
+)
 from rbx.box.deferred import Deferred
 from rbx.box.environment import (
-    EnvironmentSandbox,
-    ExecutionConfig,
     VerificationLevel,
 )
 from rbx.box.formatting import get_formatted_memory, get_formatted_time
@@ -31,26 +33,26 @@ from rbx.box.generators import (
     generate_output_for_testcase,
     generate_standalone,
 )
-from rbx.box.retries import Retrier
 from rbx.box.schema import (
     ExpectedOutcome,
     GeneratorCall,
     Limits,
     Solution,
+    TaskType,
     Testcase,
     TestcaseGroup,
 )
+from rbx.box.tasks import (
+    get_limits_for_language,
+    run_solution_on_testcase,
+)
 from rbx.box.testcase_extractors import extract_generation_testcases
 from rbx.box.testcase_utils import TestcaseEntry, find_built_testcases
 from rbx.grading.steps import (
-    DigestOrDest,
-    DigestOrSource,
     Evaluation,
     Outcome,
-    TestcaseIO,
-    TestcaseLog,
 )
-from rbx.utils import StatusProgress, model_to_yaml
+from rbx.utils import StatusProgress
 
 StructuredEvaluation = Dict[str, Dict[str, List[Optional[Deferred[Evaluation]]]]]
 
@@ -152,102 +154,13 @@ def compile_solutions(
     return compiled_solutions
 
 
-def get_limits_for_language(
-    lang: Optional[str],
-    verification: VerificationLevel,
-    timelimit_override: Optional[int],
-) -> Limits:
-    pkg = package.find_problem_package_or_die()
-    time = timelimit_override or pkg.timelimit_for_language(lang)
-    isDoubleTL = verification.value >= VerificationLevel.FULL.value
-    memory = pkg.memorylimit_for_language(lang)
-    return Limits(
-        time=time, memory=memory, output=pkg.outputLimit, isDoubleTL=isDoubleTL
-    )
-
-
-def _run_solution_on_testcase(
-    solution: Solution,
-    compiled_digest: str,
-    checker_digest: Optional[str],
-    testcase: Testcase,
-    output_dir: pathlib.Path,
-    testcase_index: int = 0,
-    verification: VerificationLevel = VerificationLevel.NONE,
-    timelimit_override: Optional[int] = None,
-) -> Evaluation:
-    def run_fn(retry_index: int) -> Evaluation:
-        actual_sandbox = package.get_singleton_sandbox()
-
-        limits = get_limits_for_language(
-            solution.language, verification, timelimit_override
-        )
-
-        sandbox = EnvironmentSandbox()
-        sandbox.timeLimit = limits.time
-        if limits.isDoubleTL and sandbox.timeLimit is not None:
-            # Double TL.
-            sandbox.timeLimit = sandbox.timeLimit * 2
-        sandbox.wallTimeLimit = sandbox.timeLimit
-        if sandbox.timeLimit is not None and actual_sandbox.use_soft_timeout():
-            sandbox.wallTimeLimit = sandbox.timeLimit * 2
-        sandbox.memoryLimit = limits.memory
-        sandbox.fileSizeLimit = limits.output
-        extra_config = ExecutionConfig(sandbox=sandbox)
-
-        output_path = output_dir / testcase.inputPath.with_suffix('.out').name
-        error_path = output_path.with_suffix('.err')
-        log_path = output_path.with_suffix('.log')
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        run_log = run_item(
-            solution,
-            DigestOrSource.create(compiled_digest),
-            stdin=DigestOrSource.create(testcase.inputPath),
-            stdout=DigestOrDest.create(output_path),
-            stderr=DigestOrDest.create(error_path),
-            extra_config=extra_config,
-            retry_index=retry_index,
-        )
-
-        if checker_digest is not None:
-            checker_result = checkers.check(
-                checker_digest,
-                run_log,
-                testcase,
-                program_output=output_path,
-            )
-        else:
-            checker_result = checkers.check_with_no_output(run_log)
-
-        eval = Evaluation(
-            result=checker_result,
-            testcase=TestcaseIO(
-                index=testcase_index,
-                input=testcase.inputPath,
-                output=testcase.outputPath,
-            ),
-            log=TestcaseLog(
-                **(run_log.model_dump() if run_log is not None else {}),
-                stdout_absolute_path=output_path.absolute(),
-                stderr_absolute_path=error_path.absolute(),
-                log_absolute_path=log_path.absolute(),
-            ),
-        )
-
-        log_path.write_text(model_to_yaml(eval))
-        return eval
-
-    retrier = Retrier()
-    return retrier.repeat(run_fn)
-
-
 def _run_solution(
     solution: Solution,
     compiled_digest: str,
     checker_digest: Optional[str],
     solution_index: int,
     group_name: str,
+    interactor_digest: Optional[str] = None,
     progress: Optional[StatusProgress] = None,
     verification: VerificationLevel = VerificationLevel.NONE,
     timelimit_override: Optional[int] = None,
@@ -267,12 +180,13 @@ def _run_solution(
             )
 
         async def run_fn(i=i, testcase=testcase, output_path=output_path):
-            return _run_solution_on_testcase(
+            return await run_solution_on_testcase(
                 solution,
                 compiled_digest,
                 checker_digest,
                 testcase,
                 output_path,
+                interactor_digest=interactor_digest,
                 testcase_index=i,
                 verification=verification,
                 timelimit_override=timelimit_override,
@@ -343,7 +257,15 @@ def _produce_solution_items(
 ) -> List[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
-    checker_digest = checkers.compile_checker() if check else None
+    if pkg.type == TaskType.COMMUNICATION:
+        checker_digest = (
+            checkers.compile_checker() if check and pkg.checker is not None else None
+        )
+        interactor_digest = checkers.compile_interactor()
+    else:
+        checker_digest = checkers.compile_checker() if check else None
+        interactor_digest = None
+
     compiled_solutions = compile_solutions(
         progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
     )
@@ -374,6 +296,7 @@ def _produce_solution_items(
                 checker_digest,
                 solution_index,
                 group_name,
+                interactor_digest=interactor_digest,
                 progress=progress,
                 verification=verification,
                 timelimit_override=timelimit_override,
@@ -451,7 +374,7 @@ async def _generate_testcase_interactively(
             copied_to=testcase,
         )
     elif testcase_entry is not None:
-        extracted = extract_generation_testcases([testcase_entry])
+        extracted = await extract_generation_testcases([testcase_entry])
         if not extracted:
             console.console.print(
                 f'[error]Failed searching for testcase [item]{testcase_entry}[/item].[/error]'
@@ -483,7 +406,7 @@ async def _generate_testcase_interactively(
 
     # 1. Generate testcase.
     if generation_metadata is not None:
-        generate_standalone(
+        await generate_standalone(
             generation_metadata,
             progress=progress,
             validate=True,
@@ -531,10 +454,20 @@ async def _generate_testcase_interactively(
             raise
 
     if main_solution_digest is not None:
+        pkg = package.find_problem_package_or_die()
+        if pkg.type == TaskType.COMMUNICATION:
+            interactor_digest = checkers.compile_interactor(progress)
+        else:
+            interactor_digest = None
+
         if progress:
             progress.update('Generating output for test...')
         # TODO: Add stderr path
-        generate_output_for_testcase(main_solution_digest, testcase)
+        await generate_output_for_testcase(
+            main_solution_digest,
+            testcase,
+            interactor_digest=interactor_digest,
+        )
 
     if check and testcase.outputPath is not None and not testcase.outputPath.is_file():
         # Output was not created, throw an error.
@@ -559,9 +492,13 @@ def _run_interactive_solutions(
 ) -> Iterator[EvaluationItem]:
     pkg = package.find_problem_package_or_die()
 
-    if check and progress:
-        progress.update('Compiling checker...')
-    checker_digest = checkers.compile_checker() if check else None
+    if pkg.type == TaskType.COMMUNICATION:
+        checker_digest = checkers.compile_checker() if check else None
+        interactor_digest = checkers.compile_interactor()
+    else:
+        checker_digest = checkers.compile_checker() if check else None
+        interactor_digest = None
+
     compiled_solutions = compile_solutions(
         progress=progress, tracked_solutions=tracked_solutions, sanitized=sanitized
     )
@@ -581,12 +518,13 @@ def _run_interactive_solutions(
         output_dir = irun_dir / f'{i}'
 
         async def run_fn(solution=solution, output_dir=output_dir):
-            return _run_solution_on_testcase(
+            return await run_solution_on_testcase(
                 solution,
                 compiled_solutions[solution.path],
                 checker_digest,
                 testcase,
                 output_dir,
+                interactor_digest=interactor_digest,
                 verification=verification,
             )
 

rbx/box/solutions_test.py

@@ -1,4 +1,3 @@
-import asyncio
 import pathlib
 
 import pytest
@@ -17,15 +16,15 @@ from rbx.grading.steps import Outcome
 
 
 @pytest.mark.test_pkg('box1')
-def test_solutions(pkg_from_testdata: pathlib.Path):
-    generate_testcases()
+async def test_solutions(pkg_from_testdata: pathlib.Path):
+    await generate_testcases()
     entries = [
-        entry.group_entry for entry in extract_generation_testcases_from_groups()
+        entry.group_entry for entry in await extract_generation_testcases_from_groups()
     ]
-    generate_outputs_for_testcases(entries)
+    await generate_outputs_for_testcases(entries)
 
     result = run_solutions(verification=VerificationLevel.FULL)
-    res = asyncio.run(convert_list_of_solution_evaluations_to_dict(result.items))
+    res = await convert_list_of_solution_evaluations_to_dict(result.items)
 
     # First solution should pass all tests.
     assert all(chk.result.outcome == Outcome.ACCEPTED for chk in res[0]['gen1'])

rbx/box/state.py

@@ -5,6 +5,7 @@ import dataclasses
 class State:
     run_through_cli: bool = False
     sanitized: bool = False
+    debug_logs: bool = False
 
 
 STATE = State()