classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/interface/model/quantum_expressions/control_state.py

@@ -4,7 +4,7 @@ from classiq.exceptions import ClassiqValueError
 def min_unsigned_bit_length(number: int) -> int:
     if number < 0:
         raise ClassiqValueError(
-            f"Quantum register is not signed but control value "  # noqa: B907
+            f"Quantum register is not signed but control value "
             f"'{number}' is negative"
         )
     return 1 if number == 0 else number.bit_length()
@@ -28,7 +28,7 @@ def to_twos_complement(value: int, bits: int, is_signed: bool) -> str:
     required_bits = min_bit_length(value, is_signed)
     if bits < required_bits:
         raise ClassiqValueError(
-            f"Cannot express '{value}' using {bits} bits: "  # noqa: B907
+            f"Cannot express '{value}' using {bits} bits: "
             f"at least {required_bits} bits are required"
         )
     if value >= 0:

classiq/interface/model/quantum_function_call.py

@@ -1,49 +1,35 @@
 import itertools
 import re
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Set, Union
+from typing import Any, Dict, List, Mapping, Optional, Set, Union
 
 import pydantic
 from pydantic import BaseModel
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.function_params import NAME_REGEX
-from classiq.interface.generator.functions import FunctionDeclaration
+from classiq.interface.generator.functions.function_declaration import (
+    FunctionDeclaration,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.quantum_function_call import (
-    BAD_CALL_NAME_ERROR_MSG,
-    SUFFIX_MARKER,
-    randomize_suffix,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.call_synthesis_data import CallSynthesisData
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
-from classiq.interface.model.operator_synthesis_data import OperatorSynthesisData
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
-from classiq.interface.model.quantum_expressions.arithmetic_operation import (
-    ArithmeticOperation,
-)
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.quantum_lambda_function import (
+    LambdaListComprehension,
+    QuantumCallable,
+    QuantumLambdaFunction,
+    QuantumOperand,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import get_unique_handle_names
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
 
 from classiq.exceptions import ClassiqError, ClassiqValueError
 
@@ -108,7 +94,13 @@ def _validate_no_mixing_sliced_and_whole_handles(
         )
 
 
-ArgValue = Union[Expression, "QuantumOperand", SlicedHandleBinding, HandleBinding]
+ArgValue = Union[
+    Expression,
+    QuantumOperand,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+    HandleBinding,
+]
 
 
 class OperandIdentifier(BaseModel):
@@ -121,13 +113,6 @@ class QuantumFunctionCall(QuantumOperation):
         description="The function that is called"
     )
     params: Dict[str, Expression] = pydantic.Field(default_factory=dict)
-    release_by_inverse: bool = pydantic.Field(
-        default=False, description="Release zero inputs in inverse call."
-    )
-    should_control: bool = pydantic.Field(
-        default=True,
-        description="False value indicates this call shouldn't be controlled even if the flow is controlled.",
-    )
     inputs: Dict[str, HandleBinding] = pydantic.Field(
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
@@ -142,12 +127,7 @@ class QuantumFunctionCall(QuantumOperation):
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
-    name: PydanticNonEmptyString = pydantic.Field(
-        default=None,
-        description="The name of the function instance. "
-        "If not set, determined automatically.",
-    )
-    operands: Dict[str, "QuantumOperand"] = pydantic.Field(
+    operands: Dict[str, QuantumOperand] = pydantic.Field(
         description="Function calls passed to the operator",
         default_factory=dict,
     )
@@ -157,8 +137,8 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
-    _operator_synthesis_data: OperatorSynthesisData = pydantic.PrivateAttr(
-        default_factory=OperatorSynthesisData
+    _synthesis_data: CallSynthesisData = pydantic.PrivateAttr(
+        default_factory=CallSynthesisData
     )
 
     @property
@@ -207,33 +187,6 @@ class QuantumFunctionCall(QuantumOperation):
             result.extend(self.outputs.values())
         return result
 
-    def __eq__(self, other: Any) -> bool:
-        return isinstance(other, QuantumFunctionCall) and self.name == other.name
-
-    def __hash__(self) -> int:
-        return hash(self.name)
-
-    @pydantic.validator("name", pre=True, always=True)
-    def _create_name(cls, name: Optional[str], values: Dict[str, Any]) -> str:
-        """
-        generates a name to a user defined-functions as follows:
-        <function_name>_<SUFFIX_MARKER>_<random_suffix>
-        """
-        if name is not None:
-            match = re.fullmatch(pattern=NAME_REGEX, string=name)
-            if match is None:
-                raise ValueError(BAD_CALL_NAME_ERROR_MSG)
-            return name
-
-        function = values.get("function")
-        if isinstance(function, OperandIdentifier):
-            function = function.name
-
-        suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
-        if not function:
-            return name if name else suffix
-        return f"{function}_{suffix}"
-
     @property
     def pos_param_args(self) -> Dict[str, Expression]:
         return dict(
@@ -324,17 +277,11 @@ class QuantumFunctionCall(QuantumOperation):
                     qlambda.set_op_decl(op_decl)
 
     @property
-    def operator_synthesis_data(self) -> OperatorSynthesisData:
-        return self._operator_synthesis_data
-
-    def set_operator_synthesis_data(
-        self, operator_synthesis_data: OperatorSynthesisData
-    ) -> None:
-        self._operator_synthesis_data = operator_synthesis_data
+    def synthesis_data(self) -> CallSynthesisData:
+        return self._synthesis_data
 
-    @staticmethod
-    def _has_repetitions(name_list: Sequence[str]) -> bool:
-        return len(set(name_list)) < len(name_list)
+    def merge_synthesis_data(self, other: CallSynthesisData) -> None:
+        self._synthesis_data = self._synthesis_data.merge(other)
 
     @pydantic.root_validator()
     def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -349,67 +296,6 @@ class QuantumFunctionCall(QuantumOperation):
         return values
 
 
-ConcreteQuantumStatement = Union[
-    QuantumFunctionCall,
-    ArithmeticOperation,
-    AmplitudeLoadingOperation,
-    VariableDeclarationStatement,
-    BindOperation,
-    NumericReinterpretationOperation,
-    InplaceBinaryOperation,
-    QuantumIfOperation,
-]
-
-
-class QuantumLambdaFunction(BaseModel):
-    """
-    The definition of an anonymous function passed as operand to higher-level functions
-    """
-
-    rename_params: Dict[str, str] = pydantic.Field(
-        default_factory=dict,
-        description="Mapping of the declared param to the actual variable name used ",
-    )
-
-    body: List[ConcreteQuantumStatement] = pydantic.Field(
-        description="A list of function calls passed to the operator"
-    )
-
-    _func_decl: Optional[QuantumOperandDeclaration] = pydantic.PrivateAttr(default=None)
-
-    @property
-    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
-        return self._func_decl
-
-    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
-        self._func_decl = fd
-
-
-class LambdaListComprehension(BaseModel):
-    """
-    Specification of a list of lambda functions iteratively
-    """
-
-    count: Expression = pydantic.Field(
-        description="The number of lambda functions in the list"
-    )
-
-    index_var: str = pydantic.Field(
-        description="The name of the integer variable holding the iteration index"
-    )
-
-    func: QuantumLambdaFunction = pydantic.Field(
-        description="A lambda function definition replicated for index values 0 to count-1"
-    )
-
-
-QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
-
-QuantumFunctionCall.update_forward_refs()
-QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
-
-
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
     if isinstance(operand, list):
         return operand

classiq/interface/model/quantum_function_declaration.py

@@ -108,6 +108,14 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
     ) -> None:
         pass
 
+    @property
+    def port_names(self) -> List[str]:
+        return list(self.port_declarations.keys())
+
+    @property
+    def operand_names(self) -> List[str]:
+        return list(self.operand_declarations.keys())
+
     def ports_by_direction(
         self, direction: PortDirection
     ) -> Mapping[str, PortDeclaration]:

classiq/interface/model/quantum_if_operation.py

@@ -5,7 +5,7 @@ from sympy import Equality
 from sympy.core.numbers import Integer
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qnum_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
 from classiq.interface.model.quantum_expressions.control_state import (
     min_bit_length,
     to_twos_complement,
@@ -17,8 +17,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.exceptions import ClassiqValueError
 
 if TYPE_CHECKING:
-    from classiq.interface.model.quantum_function_call import QuantumOperand
-
+    from classiq.interface.model.quantum_lambda_function import QuantumOperand
 
 QUANTUM_IF_INOUT_NAME = "ctrl"
 QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (

classiq/interface/model/quantum_lambda_function.py

@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+import pydantic
+from pydantic import BaseModel
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+from classiq.interface.model.within_apply_operation import WithinApplyOperation
+
+
+class QuantumLambdaFunction(BaseModel):
+    """
+    The definition of an anonymous function passed as operand to higher-level functions
+    """
+
+    rename_params: Dict[str, str] = pydantic.Field(
+        default_factory=dict,
+        description="Mapping of the declared param to the actual variable name used ",
+    )
+
+    body: "StatementBlock" = pydantic.Field(
+        description="A list of function calls passed to the operator"
+    )
+
+    _func_decl: Optional[QuantumOperandDeclaration] = pydantic.PrivateAttr(default=None)
+
+    @property
+    def func_decl(self) -> Optional[QuantumOperandDeclaration]:
+        return self._func_decl
+
+    def set_op_decl(self, fd: QuantumOperandDeclaration) -> None:
+        self._func_decl = fd
+
+
+class LambdaListComprehension(BaseModel):
+    """
+    Specification of a list of lambda functions iteratively
+    """
+
+    count: Expression = pydantic.Field(
+        description="The number of lambda functions in the list"
+    )
+
+    index_var: str = pydantic.Field(
+        description="The name of the integer variable holding the iteration index"
+    )
+
+    func: QuantumLambdaFunction = pydantic.Field(
+        description="A lambda function definition replicated for index values 0 to count-1"
+    )
+
+
+QuantumCallable = Union[str, QuantumLambdaFunction]
+QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
+
+QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
+WithinApplyOperation.update_forward_refs(QuantumOperand=QuantumOperand)

classiq/interface/model/quantum_type.py

@@ -1,13 +1,19 @@
 from typing import Any, Dict, Literal, Optional, Union
 
 import pydantic
-from pydantic import Extra
+from pydantic import Extra, Field
+from typing_extensions import Annotated
 
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+    QmodQScalarProxy,
+)
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
@@ -40,8 +46,16 @@ class QuantumType(HashablePydanticBaseModel):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
+    def get_proxy(self, name: str) -> QmodSizedProxy:
+        return QmodSizedProxy(size=self.size_in_bits)
+
+
+class QuantumScalar(QuantumType):
+    def get_proxy(self, name: str) -> QmodQScalarProxy:
+        return QmodQScalarProxy(name, size=self.size_in_bits)
+
 
-class QuantumBit(QuantumType):
+class QuantumBit(QuantumScalar):
     kind: Literal["qbit"]
 
     def __init__(self, **kwargs: Any) -> None:
@@ -69,83 +83,69 @@ class QuantumBitvector(QuantumArray):
             self._size_in_bits = self.length.to_int_value()
 
 
-class QuantumNumeric(QuantumType):
+class QuantumNumeric(QuantumScalar):
+    kind: Literal["qnum"]
+
     size: Optional[Expression] = pydantic.Field()
-    kind: str = pydantic.Field()
+    is_signed: Optional[Expression] = pydantic.Field()
+    fraction_digits: Optional[Expression] = pydantic.Field()
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qnum")
 
-    _is_signed: bool = pydantic.PrivateAttr(default=False)
-
-    _fraction_digits: int = pydantic.PrivateAttr(default=0)
+    @pydantic.root_validator
+    def _validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        has_sign = values["is_signed"] is not None
+        has_fraction_digits = values["fraction_digits"] is not None
+        if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
+            raise ClassiqValueError(
+                "Assign neither or both of is_signed and fraction_digits"
+            )
+        return values
 
     @property
-    def size_in_bits_expr(self) -> Optional[Expression]:
-        return self.size
+    def has_sign(self) -> bool:
+        return self.is_signed is not None
 
     @property
-    def is_signed(self) -> bool:
-        return self._is_signed
-
-    def set_signed(self, val: bool) -> None:
-        self._is_signed = val
+    def sign_value(self) -> bool:
+        return False if self.is_signed is None else self.is_signed.to_bool_value()
 
     @property
-    def fraction_digits(self) -> int:
-        return self._fraction_digits
+    def has_fraction_digits(self) -> bool:
+        return self.fraction_digits is not None
 
-    def set_fraction_digits(self, val: int) -> None:
-        self._fraction_digits = val
+    @property
+    def fraction_digits_value(self) -> int:
+        return (
+            0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
+        )
 
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
 
-
-class QuantumInteger(QuantumNumeric):
-    kind: Literal["qint"]
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qint")
-
-
-class QuantumFixedReal(QuantumNumeric):
-    fraction_places: Expression = pydantic.Field()
-
-    kind: Literal["qfixed"]
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qfixed")
-
-    @property
-    def fraction_digits(self) -> int:
-        return self.fraction_places.to_int_value()
-
-    def set_fraction_digits(self, val: int) -> None:
-        if val != self.fraction_places.to_int_value():
-            raise ClassiqValueError(
-                "Cannot assign value of fixed-point number with incompatible fraction digits"
-            )
+    def get_proxy(self, name: str) -> QmodQNumProxy:
+        return QmodQNumProxy(
+            name,
+            size=self.size_in_bits,
+            fraction_digits=self.fraction_digits_value,
+            is_signed=self.sign_value,
+        )
 
 
-ConcreteQuantumType = Union[
-    QuantumBit,
-    QuantumBitvector,
-    QuantumNumeric,
-    QuantumInteger,
-    QuantumFixedReal,
+ConcreteQuantumType = Annotated[
+    Union[QuantumBit, QuantumBitvector, QuantumNumeric],
+    Field(discriminator="kind", default_factory=QuantumBitvector),
 ]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:
     result = QuantumNumeric()
     result.set_size_in_bits(reg_info.size)
-    result.set_signed(reg_info.is_signed)
-    result.set_fraction_digits(reg_info.fraction_places)
+    result.is_signed = Expression(expr=str(reg_info.is_signed))
+    result.fraction_digits = Expression(expr=str(reg_info.fraction_places))
     return result
 
 
@@ -153,10 +153,11 @@ UNRESOLVED_SIZE = 1000
 
 
 def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
-    signed = qtype.is_signed if isinstance(qtype, QuantumNumeric) else False
-    if isinstance(qtype, (QuantumFixedReal, QuantumNumeric)):
-        fraction_places = qtype.fraction_digits
+    if isinstance(qtype, QuantumNumeric):
+        signed = qtype.sign_value
+        fraction_places = qtype.fraction_digits_value
     else:
+        signed = False
         fraction_places = 0
     return RegisterUserInput(
         name=name,

classiq/interface/model/quantum_variable_declaration.py

@@ -13,7 +13,7 @@ from classiq.interface.model.quantum_type import (
 
 class QuantumVariableDeclaration(BaseModel):
     name: str
-    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
+    quantum_type: ConcreteQuantumType
     size: Optional[Expression] = pydantic.Field(default=None)
 
     @pydantic.validator("size")

classiq/interface/model/statement_block.py

@@ -0,0 +1,32 @@
+from typing import List, Union
+
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApplyOperation
+
+ConcreteQuantumStatement = Union[
+    QuantumFunctionCall,
+    ArithmeticOperation,
+    AmplitudeLoadingOperation,
+    VariableDeclarationStatement,
+    BindOperation,
+    InplaceBinaryOperation,
+    QuantumIfOperation,
+    WithinApplyOperation,
+]
+
+StatementBlock = List[ConcreteQuantumStatement]
+
+QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/model/validations/handles_validator.py

@@ -2,8 +2,7 @@ from typing import Dict, Mapping, Set, Union
 
 from classiq.interface.generator.function_params import PortDirection
 from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
-    APPLY,
-    OPERAND_FIELD_NAME,
+    APPLY_OPERATOR,
 )
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -11,9 +10,10 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
+    QuantumOperand,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import HandleState, ValidationHandle
@@ -23,6 +23,7 @@ from classiq.interface.model.validations.handle_validation_base import (
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.model.within_apply_operation import WithinApplyOperation
 
 from classiq.exceptions import ClassiqValueError
 
@@ -57,12 +58,14 @@ class HandleValidator(HandleValidationBase):
     def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
         return self._handles_to_state
 
-    def handle_call(self, call: QuantumOperation) -> None:
-        if isinstance(call, QuantumFunctionCall) and call.function == APPLY.name:
-            self._handle_apply(call)
-        self._handle_inputs(call.wiring_inputs)
-        self._handle_outputs(call.wiring_outputs)
-        self._handle_inouts(call.wiring_inouts)
+    def handle_operation(self, op: QuantumOperation) -> None:
+        if isinstance(op, QuantumFunctionCall) and op.function == APPLY_OPERATOR.name:
+            self._handle_apply(op.operands[APPLY_OPERATOR.operand_names[0]])
+        elif isinstance(op, WithinApplyOperation):
+            self._handle_apply(op.action)
+        self._handle_inputs(op.wiring_inputs)
+        self._handle_outputs(op.wiring_outputs)
+        self._handle_inouts(op.wiring_inouts)
 
     def handle_variable_declaration(
         self, declaration: VariableDeclarationStatement
@@ -130,8 +133,7 @@ class HandleValidator(HandleValidationBase):
                 f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
             )
 
-    def _handle_apply(self, call: QuantumFunctionCall) -> None:
-        operand = call.operands[OPERAND_FIELD_NAME]
+    def _handle_apply(self, operand: QuantumOperand) -> None:
         if not isinstance(operand, QuantumLambdaFunction):
             return
         local_variables: Set[str] = set()

classiq/interface/model/within_apply_operation.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_lambda_function import QuantumOperand
+
+
+class WithinApplyOperation(QuantumOperation):
+    compute: "QuantumOperand"
+    action: "QuantumOperand"

classiq/interface/pyomo_extension/pyomo_sympy_bimap.py

@@ -1,10 +1,13 @@
+from typing import Any
+
 import sympy
 from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 
 
 # This code is a pure copy paste from pyomo.core.expr.sympy_tools.PyomoSympyBimap.getSympySymbol
 # except one line.
-def get_sympy_symbol(self, pyomo_object):
+def get_sympy_symbol(self: PyomoSympyBimap, pyomo_object: Any) -> sympy.Symbol:
     if pyomo_object in self.pyomo2sympy:
         return self.pyomo2sympy[pyomo_object]
     # Pyomo currently ONLY supports Real variables (not complex

classiq/interface/server/routes.py

@@ -44,6 +44,11 @@ TASKS_SOLVE_SUFFIX = "/tasks/solve"
 MODEL_GENERATE_PREFIX = "/generate_model"
 CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"
 
+CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
+GROVER_QMOD_PATH = "/generate_model/grover/qmod"
+FINANCE_QMOD_PATH = "/generate_model/finance/qmod"
+
+
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"