classiq 0.63.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -0,0 +1,108 @@
+from functools import singledispatchmethod
+
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+from classiq.model_expansions.quantum_operations import (
+    BindEmitter,
+    ClassicalIfEmitter,
+    QuantumFunctionCallEmitter,
+    RepeatEmitter,
+    VariableDeclarationStatementEmitter,
+)
+from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+
+
+class GenerativeInterpreter(BaseInterpreter):
+    @property
+    def is_shallow(self) -> bool:
+        return True
+
+    @singledispatchmethod
+    def emit(self, statement: QuantumStatement) -> None:  # type:ignore[override]
+        raise NotImplementedError(f"Cannot emit {statement!r}")
+
+    @emit.register
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        QuantumFunctionCallEmitter(self).emit(call)
+
+    @emit.register
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self).emit(bind)
+
+    @emit.register
+    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
+        ShallowEmitter(
+            self, "assignment_operation", components=["expression", "result_var"]
+        ).emit(op)
+
+    @emit.register
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        ShallowEmitter(
+            self, "inplace_binary_operation", components=["target", "value"]
+        ).emit(op)
+
+    @emit.register
+    def emit_variable_declaration(
+        self, variable_declaration: VariableDeclarationStatement
+    ) -> None:
+        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+
+    @emit.register
+    def emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        ClassicalIfEmitter(self).emit(classical_if)
+
+    @emit.register
+    def emit_within_apply(self, within_apply: WithinApply) -> None:
+        ShallowEmitter(
+            self,
+            WITHIN_APPLY_NAME,
+            components=["within", "apply", "compute", "action"],
+        ).emit(within_apply)
+
+    @emit.register
+    def emit_invert(self, invert: Invert) -> None:
+        ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+
+    @emit.register
+    def emit_repeat(self, repeat: Repeat) -> None:
+        RepeatEmitter(self).emit(repeat)
+
+    @emit.register
+    def emit_control(self, control: Control) -> None:
+        ShallowEmitter(
+            self,
+            CONTROL_OPERATOR_NAME,
+            components=["expression", "body", "else_block"],
+        ).emit(control)
+
+    @emit.register
+    def emit_power(self, power: Power) -> None:
+        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
+            power
+        )
+
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)

classiq/model_expansions/model_tables.py

@@ -1,98 +1,7 @@
-from abc import ABC, abstractmethod
-from enum import IntEnum
-from typing import ClassVar, Generic, Optional, TypeVar
+from typing import Optional
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 from classiq.interface.generator.functions.classical_type import QmodPyObject
-from classiq.interface.generator.types.enum_declaration import EnumDeclaration
-from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
-from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
-from classiq.qmod.model_state_container import QMODULE
-
-DeclarationType = TypeVar(
-    "DeclarationType", EnumDeclaration, StructDeclaration, QStructDeclaration
-)
-
-
-class TypeTable(Generic[DeclarationType], ABC):
-    def __init__(self, user_types: list[DeclarationType]) -> None:
-        self._all_types: dict[str, DeclarationType] = self.builtins.copy()
-        for t in user_types:
-            assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
-            self._all_types[t.name] = t
-
-    @property
-    @abstractmethod
-    def builtins(self) -> dict[str, DeclarationType]:
-        pass
-
-    def __getitem__(self, key: str) -> DeclarationType:
-        return self._all_types[key]
-
-    def __setitem__(self, key: str, value: DeclarationType) -> None:
-        self._all_types[key] = value
-
-    def __contains__(self, key: str) -> bool:
-        return key in self._all_types
-
-    def all_types(self) -> dict[str, DeclarationType]:
-        return self._all_types
-
-
-class EnumTable(TypeTable[EnumDeclaration]):
-    def __init__(self, user_types: list[EnumDeclaration]) -> None:
-        super().__init__(user_types)
-
-    @property
-    def builtins(self) -> dict[str, EnumDeclaration]:
-        return BUILTIN_ENUM_DECLARATIONS
-
-    @property
-    def enums(self) -> dict[str, IntEnum]:
-        return {
-            enum_decl.name: enum_decl.create_enum()
-            for enum_decl in self.all_types().values()
-        }
-
-
-class StructTable(TypeTable[StructDeclaration]):
-    @property
-    def builtins(self) -> dict[str, StructDeclaration]:
-        return BUILTIN_STRUCT_DECLARATIONS
-
-
-class QStructTable(TypeTable[QStructDeclaration]):
-    @property
-    def builtins(self) -> dict[str, QStructDeclaration]:
-        return {}
-
-
-class SymbolTable:
-    enum_table: ClassVar[EnumTable] = EnumTable([])
-    type_table: ClassVar[StructTable] = StructTable([])
-    qstruct_table: ClassVar[QStructTable] = QStructTable([])
-
-    @classmethod
-    def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
-        cls.enum_table = EnumTable(user_enums)
-        QMODULE.enum_decls = {enum_decl.name: enum_decl for enum_decl in user_enums}
-
-    @classmethod
-    def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
-        cls.type_table = StructTable(user_types)
-        QMODULE.type_decls = {
-            struct_decl.name: struct_decl for struct_decl in user_types
-        }
-
-    @classmethod
-    def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:
-        cls.qstruct_table = QStructTable(user_qstructs)
-        QMODULE.qstruct_decls = {
-            qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
-        }
 
 
 class HandleTable:

classiq/model_expansions/quantum_operations/__init__.py

@@ -1,14 +1,5 @@
 from classiq.model_expansions.quantum_operations.bind import BindEmitter
 from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
-from classiq.model_expansions.quantum_operations.control import ControlEmitter
-from classiq.model_expansions.quantum_operations.inplace_binary_operation import (
-    InplaceBinaryOperationEmitter,
-)
-from classiq.model_expansions.quantum_operations.invert import InvertEmitter
-from classiq.model_expansions.quantum_operations.power import PowerEmitter
-from classiq.model_expansions.quantum_operations.quantum_assignment_operation import (
-    QuantumAssignmentOperationEmitter,
-)
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     QuantumFunctionCallEmitter,
 )
@@ -16,4 +7,3 @@ from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
 from classiq.model_expansions.quantum_operations.variable_decleration import (
     VariableDeclarationStatementEmitter,
 )
-from classiq.model_expansions.quantum_operations.within_apply import WithinApplyEmitter

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -55,11 +55,11 @@ from classiq.qmod.builtins.functions import allocate, free
 from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
-    def __init__(self, interpreter: "Interpreter") -> None:
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
         VarSplitter.__init__(self, interpreter._builder.current_scope)
 
@@ -107,7 +107,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         is_atomic = function.is_atomic
         if (
-            self._interpreter._is_shallow
+            self._interpreter.is_shallow
             and self._is_function_purely_declarative(function)
             and self._are_args_purely_declarative(args)
         ):

classiq/model_expansions/quantum_operations/emitter.py

@@ -40,13 +40,13 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
 
 
 class Emitter(Generic[QuantumStatementT]):
-    def __init__(self, interpreter: "Interpreter") -> None:
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
         self._interpreter = interpreter
 
         self._machine_precision = self._interpreter._model.preferences.machine_precision

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -7,11 +7,11 @@ from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
-    def __init__(self, interpreter: "Interpreter") -> None:
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model
 

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -24,7 +24,7 @@ from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 QuantumOperationT = TypeVar("QuantumOperationT", bound=QuantumOperation)
@@ -38,7 +38,7 @@ _REVERSE_BLOCK_RENAMES = {rename: name for name, rename in _BLOCK_RENAMES.items(
 class ShallowEmitter(Emitter[QuantumOperation]):
     def __init__(
         self,
-        interpreter: "Interpreter",
+        interpreter: "BaseInterpreter",
         operation_name: str,
         *,
         components: Optional[list[str]] = None,

classiq/model_expansions/scope_initialization.py

@@ -29,10 +29,13 @@ from classiq.model_expansions.evaluators.parameter_types import (
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.functions import (
     CORE_LIB_DECLS,
     STD_QMOD_OPERATORS,
 )
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 
@@ -142,3 +145,8 @@ def init_top_level_scope(
     add_functions_to_scope(model.functions, scope)
     add_constants_to_scope(model.constants, scope)
     _init_builtins_scope(scope)
+
+
+def init_builtin_types() -> None:
+    QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
+    QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS

classiq/qmod/declaration_inferrer.py

@@ -32,7 +32,6 @@ from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
 
-from classiq.model_expansions.model_tables import SymbolTable
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import ModelStateContainer
@@ -60,7 +59,6 @@ class _PythonClassicalType(PythonClassicalType):
 
         enum_decl = declaration_from_enum(py_type)
         self.qmodule.enum_decls[py_type.__name__] = enum_decl
-        SymbolTable.enum_table[py_type.__name__] = enum_decl
 
     def register_struct(self, py_type: type) -> None:
         if (
@@ -77,7 +75,6 @@ class _PythonClassicalType(PythonClassicalType):
             },
         )
         self.qmodule.type_decls[py_type.__name__] = struct_decl
-        SymbolTable.type_table[py_type.__name__] = struct_decl
 
 
 def python_type_to_qmod(

classiq/qmod/generative.py

@@ -6,10 +6,10 @@ from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 _GENERATIVE_MODE: bool = False
-_FRONTEND_INTERPRETER: Optional["Interpreter"] = None
+_FRONTEND_INTERPRETER: Optional["BaseInterpreter"] = None
 
 
 def is_generative_mode() -> bool:
@@ -27,12 +27,12 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
         _GENERATIVE_MODE = previous
 
 
-def set_frontend_interpreter(interpreter: "Interpreter") -> None:
+def set_frontend_interpreter(interpreter: "BaseInterpreter") -> None:
     global _FRONTEND_INTERPRETER
     _FRONTEND_INTERPRETER = interpreter
 
 
-def get_frontend_interpreter() -> "Interpreter":
+def get_frontend_interpreter() -> "BaseInterpreter":
     if _FRONTEND_INTERPRETER is None:
         raise ClassiqError("Interpreter was not set")
     return _FRONTEND_INTERPRETER

classiq/qmod/qfunc.py

@@ -20,8 +20,10 @@ def set_global_generative_switch() -> Iterator[None]:
     global _GENERATIVE_SWITCH
     previous = _GENERATIVE_SWITCH
     _GENERATIVE_SWITCH = True
-    yield
-    _GENERATIVE_SWITCH = previous
+    try:
+        yield
+    finally:
+        _GENERATIVE_SWITCH = previous
 
 
 @overload

classiq/qmod/qmod_variable.py

@@ -66,7 +66,11 @@ from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
-from classiq.qmod.utilities import get_source_ref, version_portable_get_args
+from classiq.qmod.utilities import (
+    get_source_ref,
+    unwrap_forward_ref,
+    version_portable_get_args,
+)
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -330,8 +334,12 @@ class QNum(Generic[_P], QScalar):
                 "is_signed: bool | CBool, fraction_digits: int | CInt]"
             )
         if len(type_args) == 1:
-            return type_args[0], None, None
-        return type_args[0], type_args[1], type_args[2]
+            return unwrap_forward_ref(type_args[0]), None, None
+        return (
+            unwrap_forward_ref(type_args[0]),
+            unwrap_forward_ref(type_args[1]),
+            unwrap_forward_ref(type_args[2]),
+        )
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
@@ -492,16 +500,18 @@ class QArray(ArrayBase[_P], QVar):
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return QBit, None
+        first_arg = unwrap_forward_ref(type_args[0])
         if len(type_args) == 1:
-            if isinstance(type_args[0], (str, int)):
-                return QBit, type_args[0]
-            return type_args[0], None
+            if isinstance(first_arg, (str, int)):
+                return QBit, first_arg
+            return first_arg, None
         if len(type_args) != 2:
             raise ClassiqValueError(
                 "QArray receives two type arguments: QArray[element_type: QVar, "
                 "length: int | CInt]"
             )
-        return cast(tuple[type[QVar], Any], type_args)
+        second_arg = unwrap_forward_ref(type_args[1])
+        return cast(tuple[type[QVar], Any], (first_arg, second_arg))
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
@@ -608,8 +618,6 @@ class QStruct(QVar):
         )
 
     def _add_qmod_qstruct(self, *, qmodule: ModelStateContainer) -> None:
-        from classiq.model_expansions.model_tables import SymbolTable
-
         if self._struct_name in qmodule.qstruct_decls:
             return
 
@@ -618,7 +626,6 @@ class QStruct(QVar):
             fields={name: qvar.get_qmod_type() for name, qvar in self._fields.items()},
         )
         qmodule.qstruct_decls[self._struct_name] = struct_decl
-        SymbolTable.qstruct_table[self._struct_name] = struct_decl
 
 
 def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:

classiq/qmod/quantum_function.py

@@ -153,7 +153,9 @@ class QFunc(BaseQFunc):
         return model
 
     def _create_generative_model(self, model_stub: Model) -> Model:
-        from classiq.model_expansions.interpreter import Interpreter
+        from classiq.model_expansions.interpreters.generative_interpreter import (
+            GenerativeInterpreter,
+        )
         from classiq.qmod.semantics.static_semantics_visitor import (
             resolve_function_calls,
         )
@@ -167,9 +169,7 @@ class QFunc(BaseQFunc):
                 for gen_func in generative_functions
             },
         )
-        interpreter = Interpreter(
-            model_stub, generative_functions, is_normalizer=True, is_shallow=True
-        )
+        interpreter = GenerativeInterpreter(model_stub, generative_functions)
         set_frontend_interpreter(interpreter)
         return interpreter.expand()
 
@@ -244,6 +244,8 @@ class ExternalQFunc(QTerminalCallable):
 
 
 class GenerativeQFunc(BaseQFunc):
+    FRAME_DEPTH = 3
+
     def __init__(
         self,
         py_callable: Callable,

classiq/qmod/utilities.py

@@ -5,7 +5,7 @@ import keyword
 import sys
 from enum import Enum as PythonEnum
 from types import FrameType
-from typing import Any, Literal, Optional, get_args, get_origin, overload
+from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
 
 from classiq.interface.source_reference import SourceReference
 
@@ -97,3 +97,9 @@ def qmod_val_to_expr_str(val: Any) -> str:
         return f"{type(val).__name__}.{val.name}"
 
     return str(val)
+
+
+def unwrap_forward_ref(x: Any) -> Any:
+    if isinstance(x, ForwardRef):
+        return x.__forward_arg__
+    return x

{classiq-0.63.0.dist-info → classiq-0.64.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.63.0
+Version: 0.64.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary