classiq 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/qmod/qmod_variable.py

@@ -48,6 +48,7 @@ from classiq.interface.model.quantum_expressions.amplitude_loading_operation imp
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_type import (
     QuantumBit,
@@ -57,10 +58,10 @@ from classiq.interface.model.quantum_type import (
 )
 from classiq.interface.source_reference import SourceReference
 
-from classiq.qmod.cparam import ArrayBase, CBool, CInt, CParamScalar
+from classiq.qmod.cparam import ArrayBase, CInt, CParamScalar
 from classiq.qmod.generative import (
     generative_mode_context,
-    get_frontend_interpreter,
+    interpret_expression,
     is_generative_mode,
 )
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
@@ -95,10 +96,6 @@ def _no_current_expandable() -> Iterator[None]:
         QCallable.CURRENT_EXPANDABLE = current_expandable
 
 
-def _evaluate_expression(expr: str) -> Any:
-    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value
-
-
 class QVar(Symbolic):
     def __init__(
         self,
@@ -171,7 +168,7 @@ class QVar(Symbolic):
     def size(self) -> Union[CParamScalar, int]:
         if is_generative_mode():
             with generative_mode_context(False):
-                return _evaluate_expression(str(self.size))
+                return interpret_expression(str(self.size))
         return CParamScalar(f"get_field({self}, 'size')")
 
 
@@ -192,7 +189,10 @@ class QScalar(QVar, SymbolicExpr):
         SymbolicExpr.__init__(self, str(origin), True)
 
     def _insert_arith_operation(
-        self, expr: SymbolicTypes, inplace: bool, source_ref: SourceReference
+        self,
+        expr: SymbolicTypes,
+        kind: ArithmeticOperationKind,
+        source_ref: SourceReference,
     ) -> None:
         # Fixme: Arithmetic operations are not yet supported on slices (see CAD-12670)
         if TYPE_CHECKING:
@@ -201,7 +201,7 @@ class QScalar(QVar, SymbolicExpr):
             ArithmeticOperation(
                 expression=Expression(expr=str(expr)),
                 result_var=self.get_handle_binding(),
-                inplace_result=inplace,
+                operation_kind=kind,
                 source_ref=source_ref,
             )
         )
@@ -225,7 +225,9 @@ class QScalar(QVar, SymbolicExpr):
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
 
-        self._insert_arith_operation(other, False, get_source_ref(sys._getframe(1)))
+        self._insert_arith_operation(
+            other, ArithmeticOperationKind.Assignment, get_source_ref(sys._getframe(1))
+        )
         return self
 
     def __ixor__(self, other: Any) -> Self:
@@ -234,7 +236,20 @@ class QScalar(QVar, SymbolicExpr):
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
 
-        self._insert_arith_operation(other, True, get_source_ref(sys._getframe(1)))
+        self._insert_arith_operation(
+            other, ArithmeticOperationKind.InplaceXor, get_source_ref(sys._getframe(1))
+        )
+        return self
+
+    def __iadd__(self, other: Any) -> Self:
+        if not isinstance(other, get_args(SymbolicTypes)):
+            raise TypeError(
+                f"Invalid argument {other!r} for in-place arithmetic operation"
+            )
+
+        self._insert_arith_operation(
+            other, ArithmeticOperationKind.InplaceAdd, get_source_ref(sys._getframe(1))
+        )
         return self
 
     def __imul__(self, other: Any) -> Self:
@@ -273,18 +288,21 @@ class QNum(Generic[_P], QScalar):
         self,
         name: Union[str, HandleBinding],
         size: Union[int, CInt, Expression, None] = None,
-        is_signed: Union[bool, CBool, Expression, None] = None,
+        is_signed: Union[bool, Expression, SymbolicExpr, None] = None,
         fraction_digits: Union[int, CInt, Expression, None] = None,
         _expr_str: Optional[str] = None,
     ):
-        if (
-            size is None
-            and (is_signed is not None or fraction_digits is not None)
-            or size is not None
-            and (is_signed is None or fraction_digits is None)
-        ):
+        if size is None and (is_signed is not None or fraction_digits is not None):
             raise ClassiqValueError(
-                "Assign none or all of size, is_signed, and fraction_digits"
+                "Cannot assign 'is_signed' and 'fraction_digits' without 'size'"
+            )
+        if is_signed is not None and fraction_digits is None:
+            raise ClassiqValueError(
+                "Cannot assign 'is_signed' without 'fraction_digits'"
+            )
+        if is_signed is None and fraction_digits is not None:
+            raise ClassiqValueError(
+                "Cannot assign 'fraction_digits' without 'is_signed'"
             )
         self._size = (
             size
@@ -308,11 +326,13 @@ class QNum(Generic[_P], QScalar):
         type_args = version_portable_get_args(type_hint)
         if len(type_args) == 0:
             return None, None, None
-        if len(type_args) != 3:
+        if len(type_args) not in (1, 3):
             raise ClassiqValueError(
                 "QNum receives three type arguments: QNum[size: int | CInt, "
                 "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]
 
     @classmethod
@@ -354,14 +374,14 @@ class QNum(Generic[_P], QScalar):
     def fraction_digits(self) -> Union[CParamScalar, int]:
         if is_generative_mode():
             with generative_mode_context(False):
-                return _evaluate_expression(str(self.fraction_digits))
+                return interpret_expression(str(self.fraction_digits))
         return CParamScalar(f"get_field({self}, 'fraction_digits')")
 
     @property
     def is_signed(self) -> Union[CParamScalar, bool]:
         if is_generative_mode():
             with generative_mode_context(False):
-                return _evaluate_expression(str(self.is_signed))
+                return interpret_expression(str(self.is_signed))
         return CParamScalar(f"get_field({self}, 'is_signed')")
 
     # Support comma-separated generic args in older Python versions
@@ -466,7 +486,7 @@ class QArray(ArrayBase[_P], QVar):
         def len(self) -> Union[CParamScalar, int]:
             if is_generative_mode():
                 with generative_mode_context(False):
-                    return _evaluate_expression(str(self.len))
+                    return interpret_expression(str(self.len))
             if self._length is not None:
                 return CParamScalar(f"{self._length}")
             return CParamScalar(f"get_field({self}, 'len')")

classiq/qmod/quantum_expandable.py

@@ -122,8 +122,17 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def _get_positional_args(self) -> List[ArgType]:
         result: List[ArgType] = []
+        rename_params = self.infer_rename_params()
+        if rename_params is not None and len(rename_params) != len(
+            self.func_decl.positional_arg_declarations
+        ):
+            op_name = (
+                f" {self.func_decl.name!r}" if self.func_decl.name is not None else ""
+            )
+            raise ClassiqValueError(
+                f"Operand{op_name} takes {len(self.func_decl.positional_arg_declarations)} arguments but the received function takes {len(rename_params)} argument"
+            )
         for idx, arg in enumerate(self.func_decl.positional_arg_declarations):
-            rename_params = self.infer_rename_params()
             actual_name = (
                 rename_params[idx] if rename_params is not None else arg.get_name()
             )
@@ -303,6 +312,10 @@ def prepare_arg(
             return [prepare_arg(arg_decl, v, func_name, param_name) for v in val]
 
         if not isinstance(val, QCallable):
+            if not callable(val):
+                raise ClassiqValueError(
+                    f"Operand argument to {param_name!r} must be a callable object"
+                )
             new_arg_decl = decl_without_type_attributes(arg_decl)
             val = QLambdaFunction(new_arg_decl, val)
             val.expand()

classiq/qmod/semantics/static_semantics_visitor.py

@@ -51,6 +51,9 @@ from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation import annotate_function_call_decl
 from classiq.qmod.semantics.error_manager import ErrorManager
+from classiq.qmod.semantics.validation.constants_validation import (
+    check_duplicate_constants,
+)
 from classiq.qmod.semantics.validation.func_call_validation import (
     check_no_overlapping_quantum_args,
     validate_call_arguments,
@@ -110,6 +113,7 @@ class StaticSemanticsVisitor(Visitor):
 
     def visit_Model(self, model: Model) -> None:
         check_duplicate_types([*model.enums, *model.types, *model.qstructs])
+        check_duplicate_constants(model.constants)
         for qstruct in model.qstructs:
             check_qstruct_has_fields(qstruct)
             if check_qstruct_fields_are_defined(
@@ -318,6 +322,12 @@ class StaticSemanticsVisitor(Visitor):
 
         for handle_metadata in inouts:
             handle_binding = handle_metadata.handle
+
+            if handle_binding.name not in self.current_scope.variable_states:
+                ErrorManager().add_error(
+                    f"Variable {handle_binding.name!r} is not defined"
+                )
+                return
             handle_wiring_state = self.current_scope.variable_states[
                 handle_binding.name
             ]

classiq/qmod/semantics/validation/constants_validation.py

@@ -0,0 +1,16 @@
+from typing import Sequence
+
+from classiq.interface.generator.constant import Constant
+
+from classiq.qmod.builtins import BUILTIN_CONSTANTS
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+def check_duplicate_constants(constants: Sequence[Constant]) -> None:
+    known_constants = {constant.name: constant for constant in BUILTIN_CONSTANTS}
+    for constant in constants:
+        if constant.name in known_constants:
+            with ErrorManager().node_context(constant):
+                ErrorManager().add_error(f"Constant {constant.name!r} already exists")
+        else:
+            known_constants[constant.name] = constant

{classiq-0.46.1.dist-info → classiq-0.48.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.46.1
+Version: 0.48.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies
 Author-email: support@classiq.io
-Requires-Python: >=3.8,<3.12
+Requires-Python: >=3.8,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
@@ -34,16 +35,20 @@ Requires-Dist: Pyomo (>=6.5,<6.6)
 Requires-Dist: black (>=24.0,<25.0)
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: ipywidgets (>=7.7.1,<8.0.0) ; extra == "analyzer-sdk"
+Requires-Dist: jupyterlab (>=4.2.5,<5.0.0) ; extra == "analyzer-sdk"
 Requires-Dist: keyring (>=23.5.0,<24.0.0)
 Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
+Requires-Dist: notebook (>=7.2.2,<8.0.0) ; extra == "analyzer-sdk"
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
-Requires-Dist: numpy (>=1.20.1,<2.0.0)
+Requires-Dist: numpy (>=1.20.1,<2.0.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: packaging (>=23.2,<24.0)
 Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
 Requires-Dist: pydantic (>=1.9.1,<2.0.0)
-Requires-Dist: scipy (>=1.10.1,<2.0.0)
+Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
+Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
 Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"