classiq 0.63.1__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/qmod/qmod_variable.py

@@ -23,11 +23,8 @@ from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.qmod_qarray_proxy import (
-    ILLEGAL_SLICE_BOUNDS_MSG,
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
-    SLICE_OUT_OF_BOUNDS_MSG,
-    SUBSCRIPT_OUT_OF_BOUNDS_MSG,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -66,7 +63,12 @@ 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,
+    varname,
+    version_portable_get_args,
+)
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -94,28 +96,42 @@ def _no_current_expandable() -> Iterator[None]:
         QCallable.CURRENT_EXPANDABLE = current_expandable
 
 
+def _infer_variable_name(name: Any, depth: int) -> Any:
+    if name is not None:
+        return name
+    name = varname(depth + 1)
+    if name is None:
+        raise ClassiqValueError(
+            "Could not infer variable name. Please specify the variable name explicitly"
+        )
+    return name
+
+
 class QVar(Symbolic):
+    CONSTRUCTOR_DEPTH: int = 1
+
     def __init__(
         self,
-        origin: Union[str, HandleBinding],
+        origin: Union[None, str, HandleBinding] = None,
         *,
         expr_str: Optional[str] = None,
         depth: int = 2,
     ) -> None:
-        super().__init__(str(origin), True)
+        name = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
+        super().__init__(str(name), True)
         source_ref = (
             get_source_ref(sys._getframe(depth))
-            if isinstance(origin, str)
-            else origin.source_ref
+            if isinstance(name, str)
+            else name.source_ref
         )
         self._base_handle: HandleBinding = (
-            HandleBinding(name=origin) if isinstance(origin, str) else origin
+            HandleBinding(name=name) if isinstance(name, str) else name
         )
-        if isinstance(origin, str) and QCallable.CURRENT_EXPANDABLE is not None:
+        if isinstance(name, str) and QCallable.CURRENT_EXPANDABLE is not None:
             QCallable.CURRENT_EXPANDABLE.add_local_handle(
-                origin, self.get_qmod_type(), source_ref
+                name, self.get_qmod_type(), source_ref
             )
-        self._expr_str = expr_str if expr_str is not None else str(origin)
+        self._expr_str = expr_str if expr_str is not None else str(name)
 
     def get_handle_binding(self) -> HandleBinding:
         return self._base_handle
@@ -176,13 +192,16 @@ Input = Annotated[_Q, PortDeclarationDirection.Input]
 
 
 class QScalar(QVar, SymbolicExpr):
+    CONSTRUCTOR_DEPTH: int = 2
+
     def __init__(
         self,
-        origin: Union[str, HandleBinding],
+        origin: Union[None, str, HandleBinding] = None,
         *,
         _expr_str: Optional[str] = None,
         depth: int = 2,
     ) -> None:
+        origin = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
         QVar.__init__(self, origin, expr_str=_expr_str, depth=depth)
         SymbolicExpr.__init__(self, str(origin), True)
 
@@ -282,9 +301,11 @@ _P = ParamSpec("_P")
 
 
 class QNum(Generic[_P], QScalar):
+    CONSTRUCTOR_DEPTH: int = 3
+
     def __init__(
         self,
-        name: Union[str, HandleBinding],
+        name: Union[None, str, HandleBinding] = None,
         size: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         is_signed: Union[bool, Expression, SymbolicExpr, None] = None,
         fraction_digits: Union[int, CInt, Expression, None] = None,
@@ -330,8 +351,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:
@@ -390,10 +415,12 @@ class QNum(Generic[_P], QScalar):
 
 
 class QArray(ArrayBase[_P], QVar):
+    CONSTRUCTOR_DEPTH: int = 3
+
     # TODO [CAD-18620]: improve type hints
     def __init__(
         self,
-        name: Union[str, HandleBinding],
+        name: Union[None, str, HandleBinding] = None,
         element_type: Union[_GenericAlias, QuantumType] = QBit,
         length: Optional[Union[int, SymbolicExpr, Expression]] = None,
         _expr_str: Optional[str] = None,
@@ -417,14 +444,6 @@ class QArray(ArrayBase[_P], QVar):
     def _get_subscript(self, index: Union[slice, int, SymbolicExpr]) -> Any:
         if isinstance(index, SymbolicExpr) and index.is_quantum:
             raise ClassiqValueError("Non-classical parameter for slicing")
-        if (
-            isinstance(index, int)
-            and self._length is not None
-            and self._length.is_evaluated()
-        ):
-            length = self._length.to_int_value()
-            if index < 0 or index >= length:
-                raise ClassiqValueError(SUBSCRIPT_OUT_OF_BOUNDS_MSG)
 
         return _create_qvar_for_qtype(
             self.get_qmod_type().element_type,
@@ -442,20 +461,6 @@ class QArray(ArrayBase[_P], QVar):
             slice_.stop, (int, SymbolicExpr)
         ):
             raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-        if (
-            isinstance(slice_.start, int)
-            and isinstance(slice_.stop, int)
-            and slice_.start >= slice_.stop
-        ):
-            raise ClassiqValueError(
-                ILLEGAL_SLICE_BOUNDS_MSG.format(slice_.start, slice_.stop)
-            )
-        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
-            ):
-                raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 
         return QArray(
             name=SlicedHandleBinding(
@@ -492,16 +497,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:
@@ -537,16 +544,19 @@ class QArray(ArrayBase[_P], QVar):
 
 
 class QStruct(QVar):
+    CONSTRUCTOR_DEPTH: int = 2
+
     _struct_name: str
     _fields: Mapping[str, QVar]
 
     def __init__(
         self,
-        name: Union[str, HandleBinding],
+        origin: Union[None, str, HandleBinding] = None,
         _struct_name: Optional[str] = None,
         _fields: Optional[Mapping[str, QVar]] = None,
         _expr_str: Optional[str] = None,
     ) -> None:
+        name = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
         if _struct_name is None or _fields is None:
             with _no_current_expandable():
                 temp_var = QStruct.to_qvar(name, type(self), _expr_str)
@@ -601,15 +611,13 @@ class QStruct(QVar):
                 for field_name, (field_class, field_type) in field_types.items()
             }
         return QStruct(
-            name=origin,
+            origin,
             _struct_name=type_hint.__name__,
             _fields=field_vars,
             _expr_str=expr_str,
         )
 
     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,8 +153,10 @@ class QFunc(BaseQFunc):
         return model
 
     def _create_generative_model(self, model_stub: Model) -> Model:
-        from classiq.model_expansions.interpreter import Interpreter
-        from classiq.qmod.semantics.static_semantics_visitor import (
+        from classiq.model_expansions.interpreters.frontend_generative_interpreter import (
+            FrontendGenerativeInterpreter,
+        )
+        from classiq.qmod.semantics.annotation.call_annotation 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 = FrontendGenerativeInterpreter(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/semantics/annotation/call_annotation.py

@@ -0,0 +1,92 @@
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumLambdaFunction,
+)
+
+from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.error_manager import ErrorManager
+from classiq.qmod.semantics.lambdas import get_renamed_parameters
+
+
+def _annotate_function_call_decl(
+    fc: QuantumFunctionCall,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    if fc._func_decl is None:
+        func_decl = function_dict.get(fc.func_name)
+        if func_decl is None:
+            raise ClassiqError(
+                f"Error resolving function {fc.func_name}, the function is not found in included library."
+            )
+        fc.set_func_decl(func_decl)
+
+    for arg, param in zip(fc.positional_args, fc.func_decl.positional_arg_declarations):
+        if not isinstance(param, AnonQuantumOperandDeclaration):
+            continue
+        args: list
+        if isinstance(arg, list):
+            args = arg
+        else:
+            args = [arg]
+        for qlambda in args:
+            if isinstance(qlambda, QuantumLambdaFunction):
+                qlambda.set_op_decl(param)
+
+
+class _CallLambdaAnnotator(Visitor):
+    def __init__(
+        self, quantum_functions: Mapping[str, QuantumFunctionDeclaration]
+    ) -> None:
+        self._quantum_functions = dict(quantum_functions)
+        self._current_operands: dict[str, QuantumOperandDeclaration] = {}
+
+    @contextmanager
+    def set_operands(
+        self, operands: dict[str, QuantumOperandDeclaration]
+    ) -> Iterator[None]:
+        previous_operands = self._current_operands
+        self._current_operands = operands
+        yield
+        self._current_operands = previous_operands
+
+    def visit_NativeFunctionDefinition(self, func: NativeFunctionDefinition) -> None:
+        with self.set_operands(func.operand_declarations_dict):
+            self.generic_visit(func)
+
+    def visit_QuantumLambdaFunction(self, lambda_func: QuantumLambdaFunction) -> None:
+        lambda_operands = get_renamed_parameters(lambda_func)[1]
+        with self.set_operands(self._current_operands | lambda_operands):
+            self.generic_visit(lambda_func)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        _annotate_function_call_decl(
+            call, self._quantum_functions | self._current_operands
+        )
+        self.generic_visit(call)
+
+
+def resolve_function_calls(
+    root: Any,
+    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    all_functions: Mapping[str, QuantumFunctionDeclaration] = {
+        **BUILTIN_FUNCTION_DECLARATIONS,
+        **quantum_function_dict,
+    }
+    with ErrorManager().ignore_errors_context():
+        QStructAnnotator().visit(quantum_function_dict)
+        QStructAnnotator().visit(root)
+        _CallLambdaAnnotator(all_functions).visit(root)

classiq/qmod/semantics/lambdas.py

@@ -0,0 +1,25 @@
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+
+from classiq import AnonClassicalParameterDeclaration
+
+
+def get_renamed_parameters(
+    lambda_func: QuantumLambdaFunction,
+) -> tuple[list[str], dict[str, QuantumOperandDeclaration], list[PortDeclaration]]:
+    renamed_parameters: list[str] = []
+    renamed_operands: dict[str, QuantumOperandDeclaration] = {}
+    renamed_ports: list[PortDeclaration] = []
+    for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
+        param_name = lambda_func.pos_rename_params[idx]
+        if isinstance(param, AnonClassicalParameterDeclaration):
+            renamed_parameters.append(param_name)
+        elif isinstance(param, AnonQuantumOperandDeclaration):
+            renamed_operands[param_name] = param.rename(param_name)
+        else:
+            renamed_ports.append(param.rename(param_name))
+    return renamed_parameters, renamed_operands, renamed_ports

classiq/qmod/semantics/static_semantics_visitor.py

@@ -2,7 +2,6 @@ import ast
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from typing import (
-    Any,
     Optional,
 )
 
@@ -15,9 +14,6 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.classical_parameter_declaration import (
-    AnonClassicalParameterDeclaration,
-)
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -33,7 +29,6 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
-    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
@@ -51,9 +46,10 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 from classiq.qmod.builtins.functions import (
     BUILTIN_FUNCTION_DECLARATIONS,
 )
-from classiq.qmod.semantics.annotation import annotate_function_call_decl
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
-from classiq.qmod.semantics.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.lambdas import get_renamed_parameters
 from classiq.qmod.semantics.validation.constants_validation import (
     check_duplicate_constants,
 )
@@ -202,13 +198,6 @@ class StaticSemanticsVisitor(Visitor):
     def visit_QuantumOperation(self, op: QuantumOperation) -> None:
         with self._error_manager.node_context(op):
             if isinstance(op, QuantumFunctionCall):
-                annotate_function_call_decl(
-                    op,
-                    {
-                        **self._functions_dict,
-                        **self.current_scope.operands,
-                    },
-                )
                 validate_call_arguments(
                     op,
                     {
@@ -243,8 +232,8 @@ class StaticSemanticsVisitor(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, lambda_func: QuantumLambdaFunction) -> None:
-        renamed_parameters, renamed_operands, renamed_ports = (
-            self._get_renamed_parameters(lambda_func)
+        renamed_parameters, renamed_operands, renamed_ports = get_renamed_parameters(
+            lambda_func
         )
         scope = StaticScope(
             parameters=self.current_scope.parameters + renamed_parameters,
@@ -259,22 +248,6 @@ class StaticSemanticsVisitor(Visitor):
         with self.scoped_visit(scope):
             self.generic_visit(lambda_func)
 
-    def _get_renamed_parameters(
-        self, lambda_func: QuantumLambdaFunction
-    ) -> tuple[list[str], dict[str, QuantumOperandDeclaration], list[PortDeclaration]]:
-        renamed_parameters: list[str] = []
-        renamed_operands: dict[str, QuantumOperandDeclaration] = {}
-        renamed_ports: list[PortDeclaration] = []
-        for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
-            param_name = lambda_func.pos_rename_params[idx]
-            if isinstance(param, AnonClassicalParameterDeclaration):
-                renamed_parameters.append(param_name)
-            elif isinstance(param, AnonQuantumOperandDeclaration):
-                renamed_operands[param_name] = param.rename(param_name)
-            else:
-                renamed_ports.append(param.rename(param_name))
-        return renamed_parameters, renamed_operands, renamed_ports
-
     def visit_HandleBinding(self, handle: HandleBinding) -> None:
         resolve_handle(self.current_scope, handle)
 
@@ -375,26 +348,15 @@ class StaticSemanticsVisitor(Visitor):
                 )
 
 
-def resolve_function_calls(
-    root: Any,
-    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    with ErrorManager().ignore_errors_context():
-        QStructAnnotator().visit(quantum_function_dict)
-        QStructAnnotator().visit(root)
-        StaticSemanticsVisitor(
-            {**BUILTIN_FUNCTION_DECLARATIONS, **quantum_function_dict},
-            [],
-        ).visit(root)
-
-
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
     _check_function_name_collisions(model, error_type)
     QStructAnnotator().visit(model)
+    functions = {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict}
+    resolve_function_calls(model, functions)
     StaticSemanticsVisitor(
-        {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},
+        functions,
         [const.name for const in model.constants],
     ).visit(model)
     if error_type is not None:

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,25 @@ 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
+
+
+def varname(depth: int) -> Optional[str]:
+    frame = sys._getframe(depth)
+    codes = inspect.getframeinfo(frame).code_context
+    if codes is None or len(codes) != 1:
+        return None
+    code = codes[0]
+    if "=" not in code:
+        return None
+    var_name = code.split("=")[0].strip()
+    if ":" in var_name:
+        var_name = var_name.split(":")[0].strip()
+    if not var_name.isidentifier():
+        return None
+    return var_name

{classiq-0.63.1.dist-info → classiq-0.65.1.dist-info}/METADATA

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