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

classiq/qmod/native/pretty_printer.py

@@ -11,18 +11,22 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -37,7 +41,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
+from classiq.interface.model.quantum_if_operation import QuantumIf
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_type import (
     QuantumBit,
@@ -47,11 +51,12 @@ from classiq.interface.model.quantum_type import (
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
 )
+from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq import Bool, ClassicalList, Integer, Pauli, Real, Struct, StructDeclaration
 from classiq.qmod.native.expression_to_qmod import transform_expression
@@ -208,33 +213,57 @@ class DSLPrettyPrinter(Visitor):
         )
         return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}{gen_time_arg_list}({quantum_args});\n"
 
-    def visit_QuantumIfOperation(self, op: QuantumIfOperation) -> str:
+    def visit_Control(self, control: Control) -> str:
+        control_code = f"{self._indent}control ({self.visit(control.control)}) {{\n"
+        control_code += self._visit_body(control.body)
+        control_code += f"{self._indent}}}\n"
+        return control_code
+
+    def visit_QuantumIf(self, op: QuantumIf) -> str:
         quantum_if = f"{self._indent}quantum_if ({self.visit(op.expression)}) {{\n"
-        operand = op.then
-        if not isinstance(operand, QuantumLambdaFunction):
-            raise AssertionError(
-                "Expected quantum_if to be implemented using a lambda function"
-            )
-        quantum_if += self._visit_body(operand.body)
+        quantum_if += self._visit_body(op.then)
         quantum_if += f"{self._indent}}}\n"
         return quantum_if
 
-    def visit_WithinApplyOperation(self, op: WithinApplyOperation) -> str:
-        action = op.action
-        compute = op.compute
-        if not isinstance(action, QuantumLambdaFunction) or not isinstance(
-            compute, QuantumLambdaFunction
-        ):
-            raise AssertionError(
-                "Expected within-apply to be implemented using a lambda functions"
-            )
+    def visit_ClassicalIf(self, op: ClassicalIf) -> str:
+        classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
+        if not op.then:
+            raise AssertionError('Expected non empty "then" block')
+        classical_if += self._visit_body(op.then)
+
+        if op.else_:
+            classical_if += f"{self._indent}}} else {{\n"
+            classical_if += self._visit_body(op.else_)
+
+        classical_if += f"{self._indent}}}\n"
+        return classical_if
+
+    def visit_WithinApply(self, op: WithinApply) -> str:
         within_apply_code = f"{self._indent}within {{\n"
-        within_apply_code += self._visit_body(compute.body)
+        within_apply_code += self._visit_body(op.compute)
         within_apply_code += f"{self._indent}}} apply {{\n"
-        within_apply_code += self._visit_body(action.body)
+        within_apply_code += self._visit_body(op.action)
         within_apply_code += f"{self._indent}}}\n"
         return within_apply_code
 
+    def visit_Repeat(self, repeat: Repeat) -> str:
+        repeat_code = f"{self._indent}repeat ({self.visit(repeat.iter_var)}: {self.visit(repeat.count)}) {{\n"
+        repeat_code += self._visit_body(repeat.body)
+        repeat_code += f"{self._indent}}}\n"
+        return repeat_code
+
+    def visit_Power(self, power: Power) -> str:
+        power_code = f"{self._indent}power ({self.visit(power.power)}) {{\n"
+        power_code += self._visit_body(power.body)
+        power_code += f"{self._indent}}}\n"
+        return power_code
+
+    def visit_Invert(self, invert: Invert) -> str:
+        invert_code = f"{self._indent}invert {{\n"
+        invert_code += self._visit_body(invert.body)
+        invert_code += f"{self._indent}}}\n"
+        return invert_code
+
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
         self._level += 1

classiq/qmod/qmod_constant.py

@@ -3,12 +3,16 @@ from typing import Any, Optional
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import QStructBase
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    QStructBase,
+)
 
 from classiq.exceptions import ClassiqError
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import QParam, QParamStruct
+from classiq.qmod.qmod_parameter import QParam, QParamList, QParamStruct
 
 
 class QConstant:
@@ -72,5 +76,25 @@ class QConstant:
             QConstant.CURRENT_QMODULE, self.name, py_type.__name__, name
         )
 
+    def __getitem__(self, item: Any) -> QParam:
+        self.add_to_model()
+
+        assert QConstant.CURRENT_QMODULE is not None
+
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
+
+        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+            raise ClassiqError("Invalid subscript to non-list constant")
+
+        return QParamList(
+            self.name,
+            qmod_type,
+            QConstant.CURRENT_QMODULE,
+        )[item]
+
     def __str__(self) -> str:
         return self.name

classiq/qmod/qmod_parameter.py

@@ -60,9 +60,10 @@ class QParamList(QParam):
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
+            "len(<expr>) is not supported for QMod lists - use <expr>.len instead"
         )
 
+    @property
     def len(self) -> QParamScalar:
         return QParamScalar(f"len({self})")
 

classiq/qmod/qmod_variable.py

@@ -1,8 +1,7 @@
 import abc
 import sys
 from contextlib import contextmanager
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import (
+from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
     ForwardRef,
@@ -14,6 +13,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    _GenericAlias,
     get_args,
     get_origin,
     overload,
@@ -25,7 +25,11 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -50,6 +54,7 @@ from classiq.qmod.utilities import version_portable_get_args
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
 SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
 UNSUPPORTED_ELEMENT_TYPE = "Only QBit is supported as element type for QArray"
+QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -280,34 +285,52 @@ class QArray(ArrayBase[_P], QVar):
         name: str,
         element_type: _GenericAlias = QBit,
         length: Optional[Union[int, QParam[int]]] = None,
+        # TODO [CAD-18620]: improve type hints
         slice_: Optional[Tuple[int, int]] = None,
+        index_: Optional[Union[int, QParam[int]]] = None,
     ) -> None:
         if element_type is not QBit:
             raise ClassiqValueError(UNSUPPORTED_ELEMENT_TYPE)
         self._element_type = element_type
         self._length = length
         self._slice = slice_
+        self._index = index_
         super().__init__(name)
 
     def get_handle_binding(self) -> HandleBinding:
-        if self._slice is None:
-            return HandleBinding(name=self._name)
-        return SlicedHandleBinding(
-            name=self._name,
-            start=Expression(expr=str(self._slice[0])),
-            end=Expression(expr=str(self._slice[1])),
-        )
+        if self._index is not None:
+            return SubscriptHandleBinding(
+                name=self._name,
+                index=Expression(expr=str(self._index)),
+            )
+
+        if self._slice is not None:
+            return SlicedHandleBinding(
+                name=self._name,
+                start=Expression(expr=str(self._slice[0])),
+                end=Expression(expr=str(self._slice[1])),
+            )
+
+        return HandleBinding(name=self._name)
 
     def __getitem__(self, key: Union[slice, int, QParam]) -> "QArray":
-        offset = self._slice[0] if self._slice is not None else 0
+        if self._index is not None:
+            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+
+        # TODO [CAD-18620]: improve type hints
+        new_index: Optional[Any] = None
+
         if isinstance(key, slice):
             if key.step is not None:
                 raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-            new_slice = (offset + key.start, offset + key.stop)
+            new_slice = self._get_new_slice(key.start, key.stop)
+
         else:
             if isinstance(key, QParam) and not isinstance(key, QParamScalar):
                 raise ClassiqValueError("Non-classical parameter for slicing")
-            new_slice = (offset + key, offset + key + 1)
+            new_slice = self._get_new_slice(key, key + 1)
+            new_index = new_slice[0]
+
         if (
             self._slice is not None
             and not isinstance(new_slice[1], Symbolic)
@@ -322,19 +345,29 @@ class QArray(ArrayBase[_P], QVar):
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
         # prevent addition to local handles, since this is used for slicing existing local handles
         with _no_current_expandable():
-            return QArray(self._name, length=self._length, slice_=new_slice)
+            return QArray(
+                self._name, length=self._length, slice_=new_slice, index_=new_index
+            )
+
+    # TODO [CAD-18620]: improve type hints
+    def _get_new_slice(self, start: Any, end: Any) -> Tuple[Any, Any]:
+        if self._slice is not None:
+            return (self._slice[0] + start, self._slice[0] + end)
+        return (start, end)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<var>) is not supported for quantum variables - use <var>.len() instead"
+            "len(<var>) is not supported for quantum variables - use <var>.len instead"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
+        @property
         def len(self) -> QParamScalar:
             if self._length is not None:
                 return QParamScalar(f"{self._length}")

classiq/qmod/quantum_callable.py

@@ -68,6 +68,7 @@ class QCallable(Generic[P], ABC):
 class QCallableList(QCallable, Generic[P], ABC):
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
         def __getitem__(self, key: Union[slice, int, QParam]) -> "QTerminalCallable":

classiq/qmod/quantum_expandable.py

@@ -32,10 +32,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumLambdaFunction,
-    QuantumOperand,
-)
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -161,15 +158,17 @@ class QTerminalCallable(QCallable):
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<func>) is not supported for quantum callables - use <func>.len() instead (Only if it is an operand list)"
+            "len(<func>) is not supported for quantum callables - use <func>.len instead (Only if it is an operand list)"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
+        @property
         def len(self) -> QParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
@@ -193,8 +192,8 @@ class QTerminalCallable(QCallable):
 
 @overload
 def prepare_arg(
-    arg_decl: PositionalArg, val: Union[QCallable, Callable[[Any], None]]
-) -> QuantumOperand: ...
+    arg_decl: PositionalArg, val: Union[QCallable, Callable[..., None]]
+) -> QuantumLambdaFunction: ...
 
 
 @overload

classiq/qmod/quantum_function.py

@@ -34,6 +34,10 @@ def create_model(
     preferences: Optional[Preferences] = None,
     classical_execution_function: Optional[CFunc] = None,
 ) -> SerializedModel:
+    if entry_point.func_decl.name != "main":
+        raise ClassiqError(
+            f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
+        )
     return entry_point.create_model(
         constraints, execution_preferences, preferences, classical_execution_function
     ).get_model()

classiq/qmod/symbolic.py

@@ -1,5 +1,5 @@
 import sys
-from typing import Optional, Tuple, Type, get_args, get_origin, overload
+from typing import List, Optional, Tuple, Type, get_args, get_origin, overload
 
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod import model_state_container
@@ -346,5 +346,5 @@ __all__ = [
 ]
 
 
-def __dir__():
+def __dir__() -> List[str]:
     return __all__

{classiq-0.38.0.dist-info → classiq-0.39.0.dist-info}/METADATA

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