classiq 0.63.1__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -22,6 +22,7 @@ from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     ExecutionJobsQueryResultsV1,
 )
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
 from classiq.interface.hardware import HardwareInformation, Provider
@@ -120,6 +121,35 @@ class ApiWrapper:
         )
         return _parse_job_response(result, generator_result.QuantumProgram)
 
+    @classmethod
+    async def call_create_execution_session(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> str:
+        raw_result = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX,
+            model=circuit,
+            http_client=http_client,
+        )
+        return raw_result["id"]
+
+    @classmethod
+    async def call_create_session_job(
+        cls,
+        session_id: str,
+        primitives_input: PrimitivesInput,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> execution_request.ExecutionJobDetails:
+        data = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX + f"/{session_id}",
+            model=primitives_input,
+            http_client=http_client,
+        )
+        return execution_request.ExecutionJobDetails.model_validate(data)
+
     @classmethod
     async def call_convert_quantum_program(
         cls,

classiq/analyzer/url_utils.py

@@ -1,6 +1,5 @@
 import urllib
 from urllib.parse import urljoin
-from uuid import UUID
 
 from classiq.interface.server import routes
 
@@ -21,7 +20,7 @@ def versioned_url_params(circuit_version: str) -> str:
     )
 
 
-def circuit_page_uri(circuit_id: UUID, circuit_version: str) -> str:
-    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", str(circuit_id))
+def circuit_page_uri(circuit_id: str, circuit_version: str) -> str:
+    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", circuit_id)
     url += versioned_url_params(circuit_version=circuit_version)
     return url

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -7,6 +7,8 @@ from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.qmod.builtins.structs import (
     MoleculeProblem as QmodMoleculeProblem,
     Molecule as QmodMolecule,
@@ -441,16 +443,13 @@ def _get_chemistry_quantum_main(
     use_hartree_fock: bool,
     ansatz_parameters: AnsatzParameters,
 ) -> NativeFunctionDefinition:
-    body = []
+    body: list[QuantumStatement] = []
     body.append(
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[
-                Expression(
-                    expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
-                ),
-                HandleBinding(name="qbv"),
-            ],
+        Allocate(
+            size=Expression(
+                expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
+            ),
+            target=HandleBinding(name="qbv"),
         ),
     )
     if use_hartree_fock:

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -14,6 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -89,12 +90,9 @@ def construct_combi_opt_py_model(
                     ),
                 ],
                 body=[
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr="get_field(target, 'len')"),
-                            HandleBinding(name="target"),
-                        ],
+                    Allocate(
+                        size=Expression(expr="get_field(target, 'len')"),
+                        target=HandleBinding(name="target"),
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -21,11 +21,8 @@ from classiq.open_library.functions.utility_functions import (
     apply_to_all,
     hadamard_transform,
 )
-from classiq.qmod.builtins.functions import (
-    RX,
-    allocate,
-)
-from classiq.qmod.builtins.operations import phase, repeat
+from classiq.qmod.builtins.functions import RX
+from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc

classiq/applications/finance/finance_model_constructor.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -78,19 +79,13 @@ def construct_finance_model(
                 ],
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_unitary_qubits}"),
-                            HandleBinding(name="unitary_port"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{num_unitary_qubits}"),
+                        target=HandleBinding(name="unitary_port"),
                     ),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{phase_port_size}"),
-                            HandleBinding(name="phase_port"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{phase_port_size}"),
+                        target=HandleBinding(name="phase_port"),
                     ),
                     QuantumFunctionCall(
                         function="qmci",

classiq/applications/grover/grover_model_constructor.py

@@ -2,6 +2,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.model import Model, SerializedModel
@@ -121,12 +122,9 @@ def construct_grover_model(
                 ),
                 body=[
                     VariableDeclarationStatement(name="packed_vars"),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="packed_vars"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{num_qubits}"),
+                        target=HandleBinding(name="packed_vars"),
                     ),
                     QuantumFunctionCall(
                         function="grover_search",

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -6,11 +6,13 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
 from classiq.qmod.utilities import qmod_val_to_expr_str
@@ -61,7 +63,7 @@ def _pauli_feature_map_function_params(
 
 def get_qsvm_qmain_body(
     feature_map_function_name: str, **kwargs: Any
-) -> list[QuantumFunctionCall]:
+) -> list[QuantumStatement]:
     if feature_map_function_name == "bloch_sphere_feature_map":
         params, size_expr = _bloch_sphere_feature_map_function_params(**kwargs)
     elif feature_map_function_name == "pauli_feature_map":
@@ -70,9 +72,9 @@ def get_qsvm_qmain_body(
         raise ClassiqValueError(INVALID_FEATURE_MAP_FUNC_NAME_MSG)
 
     return [
-        QuantumFunctionCall(
-            function="allocate",
-            positional_args=[Expression(expr=size_expr), HandleBinding(name="qbv")],
+        Allocate(
+            size=Expression(expr=size_expr),
+            target=HandleBinding(name="qbv"),
         ),
         QuantumFunctionCall(
             function=feature_map_function_name,

classiq/execution/execution_session.py

@@ -1,6 +1,5 @@
 import json
 import random
-from functools import cached_property
 from types import TracebackType
 from typing import Callable, Optional, Union, cast
 
@@ -110,6 +109,8 @@ class ExecutionSession:
 
         self._async_client = client().async_client()
 
+        self._session_id: str | None = None
+
     def __enter__(self) -> "ExecutionSession":
         return self
 
@@ -127,22 +128,22 @@ class ExecutionSession:
         """
         async_utils.run(self._async_client.aclose())
 
-    @cached_property
-    def _execution_input(self) -> dict:
-        return async_utils.run(
-            ApiWrapper.call_convert_quantum_program(self.program, self._async_client)
-        )
+    def get_session_id(self) -> str:
+        if self._session_id is None:
+            self._session_id = async_utils.run(
+                ApiWrapper.call_create_execution_session(
+                    self.program, self._async_client
+                )
+            )
+        return self._session_id
 
     def _execute(self, primitives_input: PrimitivesInput) -> ExecutionJob:
         primitives_input.random_seed = self._random_seed
         self._random_seed = self._rng.randint(0, 2**32 - 1)
-        execution_input = self._execution_input.copy()
-        # The use of `model_dump_json` is necessary for complex numbers serialization
-        execution_input["primitives_input"] = json.loads(
-            primitives_input.model_dump_json()
-        )
         result = async_utils.run(
-            ApiWrapper.call_execute_execution_input(execution_input, self._async_client)
+            ApiWrapper.call_create_session_job(
+                self.get_session_id(), primitives_input, self._async_client
+            )
         )
         return ExecutionJob(details=result)
 
@@ -360,7 +361,7 @@ class ExecutionSession:
             output_name: The name of the register to filter
             condition: Filter out values of the statevector for which this callable is False
         """
-        if "_execution_input" in self.__dict__:
+        if self._session_id is not None:
             raise ClassiqError(
                 "set_measured_state_filter must be called before use of the first primitive (sample, estimate...)"
             )

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.63.1'
+SEMVER_VERSION = '0.65.1'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/result.py

@@ -1,5 +1,4 @@
 from typing import Annotated, Literal, Optional, Union
-from uuid import UUID
 
 import pydantic
 from pydantic import Field
@@ -34,7 +33,7 @@ class RbResults(VersionedModel):
 
 
 class DataID(pydantic.BaseModel):
-    id: UUID
+    id: str
 
 
 class QasmCode(pydantic.BaseModel):

classiq/interface/backend/backend_preferences.py

@@ -22,7 +22,7 @@ from classiq.interface.backend.quantum_backend_providers import (
     ProviderTypeVendor,
     ProviderVendor,
 )
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning
 from classiq.interface.hardware import Provider
 
 
@@ -225,14 +225,6 @@ class AwsBackendPreferences(BackendPreferences):
         description="Run through Classiq's credentials while using user's allocated budget.",
     )
 
-    @pydantic.field_validator("s3_bucket_name", mode="before")
-    @classmethod
-    def _validate_s3_bucket_name(cls, s3_bucket_name: str) -> str:
-        s3_bucket_name = s3_bucket_name.strip()
-        if not s3_bucket_name.startswith("amazon-braket-"):
-            raise ClassiqValueError('S3 bucket name should start with "amazon-braket-"')
-        return s3_bucket_name
-
 
 class IBMBackendProvider(BaseModel):
     """

classiq/interface/executor/result.py

@@ -20,7 +20,7 @@ from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
-from classiq.interface.helpers.dotdict import get_recursive_dotdict
+from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
@@ -51,8 +51,11 @@ class SampledState(BaseModel):
 
     @pydantic.field_validator("state", mode="after")
     @classmethod
-    def _convert_state_to_dotdict(cls, state: ParsedState) -> DotAccessParsedState:
-        return {name: get_recursive_dotdict(value) for name, value in state.items()}
+    def _make_state_sdk_compatible(cls, state: ParsedState) -> DotAccessParsedState:
+        return {
+            name: get_sdk_compatible_python_object(value)
+            for name, value in state.items()
+        }
 
 
 ParsedCounts: TypeAlias = list[SampledState]

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -3,7 +3,10 @@ from typing import TYPE_CHECKING, Any, Union
 
 from sympy import Integer
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+    ClassiqValueError,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
@@ -18,12 +21,7 @@ if TYPE_CHECKING:
 
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
-SLICE_OUT_OF_BOUNDS_MSG = "Slice indices out of bounds"
-SUBSCRIPT_OUT_OF_BOUNDS_MSG = "Subscript index out of bounds"
 ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
-ILLEGAL_SLICE_BOUNDS_MSG = (
-    "The quantum array slice start value ({}) must be lower than its stop value ({})."
-)
 
 
 class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
@@ -48,7 +46,7 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         if isinstance(index, Integer):
             index = int(index)
         if index < 0 or index >= self._length:
-            raise ClassiqValueError(SUBSCRIPT_OUT_OF_BOUNDS_MSG)
+            raise ClassiqInternalExpansionError
 
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
@@ -66,12 +64,12 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
             slice_ = slice(slice_.start, int(slice_.stop))
         if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
             raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-        if slice_.start >= slice_.stop:
-            raise ClassiqValueError(
-                ILLEGAL_SLICE_BOUNDS_MSG.format(slice_.start, slice_.stop)
-            )
-        if slice_.start < 0 or slice_.stop > self._length:
-            raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
+        if (
+            slice_.start >= slice_.stop
+            or slice_.start < 0
+            or slice_.stop > self._length
+        ):
+            raise ClassiqInternalExpansionError
 
         return QmodQArrayProxy(
             SlicedHandleBinding(

classiq/interface/generator/functions/type_name.py

@@ -75,6 +75,12 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_instantiated for field_type in self.fields.values()
         )
 
+    @property
+    def is_evaluated(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_evaluated for field_type in self.fields.values()
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/helpers/datastructures.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+
+class DotDict(dict):
+    def __getattr__(self, key: str) -> Any:
+        return super().get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        super().__setitem__(key, value)
+
+    def __delattr__(self, key: str) -> None:
+        super().__delitem__(key)
+
+
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+
+def get_sdk_compatible_python_object(obj: Any) -> Any:
+    if isinstance(obj, list):
+        return LenList([get_sdk_compatible_python_object(item) for item in obj])
+    if isinstance(obj, dict):
+        return DotDict({k: get_sdk_compatible_python_object(v) for k, v in obj.items()})
+    return obj

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "6"
+INTERFACE_VERSION = "7"

classiq/interface/model/allocate.py

@@ -0,0 +1,16 @@
+from collections.abc import Mapping
+from typing import Literal, Optional
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+
+class Allocate(QuantumOperation):
+    kind: Literal["Allocate"]
+    size: Optional[Expression] = None
+    target: ConcreteHandleBinding
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {"out": self.target}

classiq/interface/model/handle_binding.py

@@ -243,15 +243,23 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _get_collapsed_stop(self) -> Expression:
         if TYPE_CHECKING:
             assert isinstance(self.base_handle, SlicedHandleBinding)
-        if self.end.is_evaluated() and self.base_handle.end.is_evaluated():
+        if self._is_evaluated() and self.base_handle.start.is_evaluated():
             return Expression(
-                expr=str(self.base_handle.end.to_int_value() - self.end.to_int_value())
+                expr=str(
+                    self.end.to_int_value()
+                    - self.start.to_int_value()
+                    + self.base_handle.start.to_int_value()
+                )
             )
-        return Expression(expr=f"({self.base_handle.end})-({self.end})")
+        return Expression(
+            expr=f"({self.end})-({self.start})+({self.base_handle.start})"
+        )
 
     def replace_prefix(
         self, prefix: HandleBinding, replacement: HandleBinding
     ) -> HandleBinding:
+        if self == prefix:
+            return replacement
         if (
             isinstance(prefix, SlicedHandleBinding)
             and self.base_handle == prefix.base_handle

classiq/interface/model/quantum_type.py

@@ -63,6 +63,10 @@ class QuantumType(HashableASTNode):
     def is_instantiated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def is_evaluated(self) -> bool:
+        raise NotImplementedError
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -96,6 +100,10 @@ class QuantumBit(QuantumScalar):
     def is_instantiated(self) -> bool:
         return True
 
+    @property
+    def is_evaluated(self) -> bool:
+        return True
+
 
 class QuantumBitvector(QuantumType):
     element_type: "ConcreteQuantumType" = Field(
@@ -154,6 +162,14 @@ class QuantumBitvector(QuantumType):
     def is_instantiated(self) -> bool:
         return self.length is not None and self.element_type.is_instantiated
 
+    @property
+    def is_evaluated(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.element_type.is_evaluated
+        )
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -227,6 +243,16 @@ class QuantumNumeric(QuantumScalar):
     def is_instantiated(self) -> bool:
         return self.size is not None
 
+    @property
+    def is_evaluated(self) -> bool:
+        if self.size is None or not self.size.is_evaluated():
+            return False
+        if self.is_signed is not None and not self.is_signed.is_evaluated():
+            return False
+        return not (
+            self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
+        )
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/model/statement_block.py

@@ -2,6 +2,7 @@ from typing import Annotated, Union
 
 from pydantic import Field
 
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -26,6 +27,7 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Annotated[
     Union[
+        Allocate,
         QuantumFunctionCall,
         ArithmeticOperation,
         AmplitudeLoadingOperation,

classiq/interface/server/routes.py

@@ -1,6 +1,7 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
 EXECUTION_PREFIX = "/execution"
+EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 
@@ -24,12 +25,16 @@ TASKS_SUFFIX = "/tasks"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
+ANALYZER_GET_VISUAL_MODEL = "/get_visual_model"
+ANALYZER_GET_IDE_DATA = "/get_ide_data"
 IDE_EVENT_TASK = f"{TASKS_SUFFIX}/event"
 DATA_DOG_EVENT_TASK = f"{TASKS_SUFFIX}/data_dog_event"
 
 ANALYZER_DATA_TASK_UPLOAD_FILE = f"{TASKS_SUFFIX}/data/file_upload"
 ANALYZER_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_DATA_TASK}"
 ANALYZER_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_QASM_TASK}"
+ANALYZER_GET_VISUAL_MODEL_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_VISUAL_MODEL}"
+ANALYZER_GET_IDE_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_IDE_DATA}"
 IDE_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_EVENT_TASK}"
 DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -33,7 +33,6 @@ from classiq.interface.generator.functions.type_name import TypeName
 from classiq.model_expansions.model_tables import (
     HandleIdentifier,
     HandleTable,
-    SymbolTable,
 )
 from classiq.model_expansions.sympy_conversion.arithmetics import (
     BitwiseAnd,
@@ -48,13 +47,14 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
+from classiq.qmod.model_state_container import QMODULE
 
 
 def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
     if isinstance(qmod_type, TypeName):
         if (
             isinstance(val, QmodStructInstance)
-            and val.struct_declaration == SymbolTable.type_table[qmod_type.name]
+            and val.struct_declaration == QMODULE.type_decls[qmod_type.name]
         ):
             return {
                 field_name: qmod_val_to_python(val.fields[field_name], field_type)
@@ -97,10 +97,10 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
 
 def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
     if isinstance(qmod_type, TypeName):
-        if qmod_type.name in SymbolTable.enum_table:
+        if qmod_type.name in QMODULE.enum_decls:
             return val
 
-        struct_decl = SymbolTable.type_table[qmod_type.name]
+        struct_decl = QMODULE.type_decls[qmod_type.name]
         if not isinstance(val, Mapping):
             raise ClassiqInternalExpansionError(
                 f"Bad value for struct {struct_decl.name}"
@@ -138,7 +138,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        SymbolTable.type_table[struct_type_symbol.name],
+        QMODULE.type_decls[struct_type_symbol.name],
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -179,7 +179,7 @@ def get_field(
 
 
 def get_type(struct_type: Symbol) -> TypeProxy:
-    return TypeProxy(SymbolTable.type_table[struct_type.name])
+    return TypeProxy(QMODULE.type_decls[struct_type.name])
 
 
 def _unwrap_sympy_numeric(n: Any) -> Any: