classiq 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/qmod/qmod_variable.py

@@ -452,11 +452,8 @@ class QArray(ArrayBase[_P], QVar):
             )
         if self._length is not None and self._length.is_evaluated():
             length = self._length.to_int_value()
-            if (
-                isinstance(slice_.start, int)
-                and slice_.start < 0
-                or isinstance(slice_.stop, int)
-                and slice_.stop > length
+            if (isinstance(slice_.start, int) and slice_.start < 0) or (
+                isinstance(slice_.stop, int) and slice_.stop > length
             ):
                 raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 

classiq/qmod/quantum_expandable.py

@@ -18,7 +18,7 @@ import pydantic
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import (
     NativePythonClassicalTypes,
@@ -30,7 +30,6 @@ from classiq.interface.model.classical_parameter_declaration import (
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -39,7 +38,11 @@ from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumCallable,
+    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 (
@@ -232,7 +235,9 @@ class QTerminalCallable(QCallable):
             raise NotImplementedError("Operand lists don't support slicing")
         if isinstance(key, CParam) and not isinstance(key, CParamScalar):
             raise ClassiqValueError("Non-classical parameter for slicing")
-        return QTerminalCallable(self._decl, index_=key)
+        if not isinstance(self._decl, AnonQuantumOperandDeclaration):
+            raise ClassiqInternalError
+        return QTerminalCallable(self._decl.element_declaration, index_=key)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
@@ -267,6 +272,13 @@ class QTerminalCallable(QCallable):
             self.func_decl, self._index, source_ref_, *args, **kwargs
         )
 
+    def get_arg(self) -> QuantumCallable:
+        if self._index is None:
+            return self._decl.name
+        return OperandIdentifier(
+            name=self._decl.name, index=Expression(expr=str(self._index))
+        )
+
 
 @overload
 def prepare_arg(
@@ -329,6 +341,8 @@ def prepare_arg(
 
         if isinstance(val, QExpandable):
             val.expand()
+        elif isinstance(val, QTerminalCallable):
+            return val.get_arg()
         return val.func_decl.name
 
 

classiq/qmod/quantum_function.py

@@ -76,6 +76,18 @@ class QFunc(BaseQFunc):
         functools.update_wrapper(self, py_callable)
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
+    @property
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        if type(self.func_decl) is NamedParamsQuantumFunctionDeclaration:
+            return self.func_decl
+        return NamedParamsQuantumFunctionDeclaration(
+            **{
+                k: v
+                for k, v in self.func_decl.model_dump().items()
+                if k in NamedParamsQuantumFunctionDeclaration.model_fields
+            }
+        )
+
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._qmodule.native_defs.get(
@@ -181,6 +193,10 @@ class ExternalQFunc(QTerminalCallable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._decl
 
+    @property
+    def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
+        return self.func_decl
+
     def get_implementation(self) -> NativeFunctionDefinition:
         model = QFunc(self._py_callable).create_model()
         return [
@@ -224,12 +240,9 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
         for name, annotation in annotations.items()
         if not (
             name == "return"
-            or isclass(annotation)
-            and issubclass(annotation, CParam)
-            or isclass(annotation)
-            and is_dataclass(annotation)
-            or isclass(annotation)
-            and isinstance(annotation, EnumMeta)
+            or (isclass(annotation) and issubclass(annotation, CParam))
+            or (isclass(annotation) and is_dataclass(annotation))
+            or (isclass(annotation) and isinstance(annotation, EnumMeta))
             or get_origin(annotation) is CArray
             or (get_origin(annotation) or annotation) is QCallable
             or (get_origin(annotation) or annotation) is QCallableList

classiq/qmod/semantics/static_semantics_visitor.py

@@ -1,3 +1,4 @@
+import ast
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from typing import (
@@ -6,7 +7,9 @@ from typing import (
 )
 
 from classiq.interface.exceptions import ClassiqSemanticError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import PortDirection
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -25,6 +28,9 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 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.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -41,7 +47,10 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+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.qstruct_annotator import QStructAnnotator
@@ -52,6 +61,9 @@ from classiq.qmod.semantics.validation.func_call_validation import (
     check_no_overlapping_quantum_args,
     validate_call_arguments,
 )
+from classiq.qmod.semantics.validation.function_name_collisions_validation import (
+    _check_function_name_collisions,
+)
 from classiq.qmod.semantics.validation.handle_validation import resolve_handle
 from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.semantics.validation.types_validation import (
@@ -266,6 +278,26 @@ class StaticSemanticsVisitor(Visitor):
     def visit_HandleBinding(self, handle: HandleBinding) -> None:
         resolve_handle(self.current_scope, handle)
 
+    def visit_Expression(self, expr: Expression) -> None:
+        if len(self._scope) == 0:
+            return
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = [
+            HandleMetadata(handle=handle)
+            for handle in vrc.var_handles
+            if handle.name in self.current_scope.variable_states
+            and (
+                not isinstance(handle, FieldHandleBinding)
+                or handle.field not in CLASSICAL_ATTRIBUTES
+            )
+        ]
+        self._handle_inouts(handles)
+
+    def visit_QuantumExpressionOperation(self, op: QuantumExpressionOperation) -> None:
+        self.visit_Expression(op.expression)
+        self.visit_QuantumOperation(op)
+
     def _handle_state_changing_ios(
         self,
         ios: Sequence[HandleMetadata],
@@ -314,9 +346,6 @@ class StaticSemanticsVisitor(Visitor):
         )
 
     def _handle_inouts(self, inouts: Sequence[HandleMetadata]) -> None:
-        sliced_handles = set()
-        whole_handles = set()
-
         for handle_metadata in inouts:
             handle_binding = handle_metadata.handle
 
@@ -345,18 +374,6 @@ class StaticSemanticsVisitor(Visitor):
                     f"{location}"
                 )
 
-            if isinstance(
-                handle_binding, (SlicedHandleBinding, SubscriptHandleBinding)
-            ):
-                sliced_handles.add(handle_binding.name)
-            else:
-                whole_handles.add(handle_binding.name)
-
-        for handle in sliced_handles & whole_handles:
-            self._error_manager.add_error(
-                f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
-            )
-
 
 def resolve_function_calls(
     root: Any,
@@ -374,6 +391,7 @@ def resolve_function_calls(
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
+    _check_function_name_collisions(model, error_type)
     QStructAnnotator().visit(model)
     StaticSemanticsVisitor(
         {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},

classiq/qmod/semantics/validation/func_call_validation.py

@@ -10,6 +10,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
     QuantumLambdaFunction,
     QuantumOperand,
 )
@@ -56,16 +57,19 @@ def _check_operand_against_declaration(
             )
         return
     operand_arg_decl: AnonQuantumFunctionDeclaration
-    if isinstance(operand_argument, str):
-        if operand_argument not in function_dict:
+    operand_argument_for_decl = operand_argument
+    if isinstance(operand_argument_for_decl, OperandIdentifier):
+        operand_argument_for_decl = operand_argument_for_decl.name
+    if isinstance(operand_argument_for_decl, str):
+        if operand_argument_for_decl not in function_dict:
             ErrorManager().add_error(
                 f"{operand_argument!r} argument to {func_name!r} is not a "
                 f"registered function."
             )
             return
-        operand_arg_decl = function_dict[operand_argument]
-    elif isinstance(operand_argument, QuantumLambdaFunction):
-        operand_arg_decl = operand_argument.func_decl
+        operand_arg_decl = function_dict[operand_argument_for_decl]
+    elif isinstance(operand_argument_for_decl, QuantumLambdaFunction):
+        operand_arg_decl = operand_argument_for_decl.func_decl
     else:
         raise ClassiqError(
             f"{str(operand_argument)!r} argument to {func_name!r} is not a "

classiq/qmod/semantics/validation/function_name_collisions_validation.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from classiq.interface.model.model import Model
+
+from classiq.qmod.builtins.functions import CORE_LIB_DECLS
+
+
+def _check_function_name_collisions(
+    model: Model, error_type: Optional[type[Exception]]
+) -> None:
+    if error_type is None:
+        return
+    redefined_functions = [
+        function.name
+        for function in CORE_LIB_DECLS
+        if function.name in model.function_dict
+    ]
+    if len(redefined_functions) == 1:
+        raise error_type(
+            f"Cannot redefine built-in function {redefined_functions[0]!r}"
+        )
+    elif len(redefined_functions) > 1:
+        raise error_type(f"Cannot redefine built-in functions: {redefined_functions}")

classiq/qmod/symbolic.py

@@ -303,70 +303,70 @@ def subscript(
 
 
 __all__ = [
-    "pi",
+    "Catalan",
     "E",
-    "I",
-    "GoldenRatio",
     "EulerGamma",
-    "Catalan",
-    "sin",
-    "cos",
-    "tan",
-    "cot",
-    "sec",
-    "csc",
-    "asin",
+    "GoldenRatio",
+    "I",
+    "Piecewise",
+    "abs",
     "acos",
-    "atan",
+    "acosh",
     "acot",
-    "asec",
+    "acoth",
     "acsc",
-    "sinh",
-    "cosh",
-    "tanh",
-    "coth",
-    "sech",
-    "csch",
+    "asec",
+    "asech",
+    "asin",
     "asinh",
-    "acosh",
+    "atan",
     "atanh",
-    "acoth",
-    "asech",
-    "exp",
-    "log",
-    "ln",
-    "sqrt",
-    "abs",
-    "floor",
+    "bell",
+    "bernoulli",
+    "besseli",
+    "besselj",
+    "besselk",
+    "bessely",
+    "beta",
+    "binomial",
+    "catalan",
     "ceiling",
+    "cos",
+    "cosh",
+    "cot",
+    "coth",
+    "csc",
+    "csch",
+    "dirichlet_eta",
     "erf",
     "erfc",
+    "euler",
+    "exp",
+    "factorial",
+    "floor",
     "gamma",
-    "beta",
-    "besselj",
-    "bessely",
-    "besseli",
-    "besselk",
-    "dirichlet_eta",
-    "polygamma",
+    "ln",
+    "log",
     "loggamma",
-    "factorial",
-    "binomial",
-    "subfactorial",
-    "primorial",
-    "bell",
-    "bernoulli",
-    "euler",
-    "catalan",
-    "Piecewise",
-    "max",
-    "min",
     "logical_and",
-    "logical_or",
     "logical_not",
+    "logical_or",
+    "max",
+    "min",
     "mod_inverse",
+    "pi",
+    "polygamma",
+    "primorial",
+    "sec",
+    "sech",
+    "sin",
+    "sinh",
+    "sqrt",
+    "subfactorial",
     "subscript",
     "sum",
+    "tan",
+    "tanh",
 ]
 
 

{classiq-0.60.0.dist-info → classiq-0.61.0.dist-info}/METADATA

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