classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/quantum_function.py

@@ -3,14 +3,17 @@ import functools
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
-from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
+from typing import Any, Callable, Optional, get_origin
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.model.model import Model
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    FunctionSynthesisData,
+    NativeFunctionDefinition,
+)
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
@@ -32,6 +35,7 @@ class QFunc(QExpandable):
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable)
         functools.update_wrapper(self, py_callable)
+        self._synthesis_data: Optional[FunctionSynthesisData] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -40,6 +44,14 @@ class QFunc(QExpandable):
             infer_func_decl(self._py_callable, qmodule=self._qmodule),
         )
 
+    @property
+    def synthesis_data(self) -> Optional[FunctionSynthesisData]:
+        return self._synthesis_data
+
+    @synthesis_data.setter
+    def synthesis_data(self, value: FunctionSynthesisData) -> None:
+        self._synthesis_data = value
+
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
         self.expand()
@@ -58,7 +70,7 @@ class QFunc(QExpandable):
         self._qmodule.constants = dict()
         QConstant.set_current_model(self._qmodule)
         self.expand()
-        model_extra_settings: List[Tuple[str, Any]] = [
+        model_extra_settings: list[tuple[str, Any]] = [
             ("constraints", constraints),
             ("execution_preferences", execution_preferences),
             ("preferences", preferences),
@@ -82,7 +94,17 @@ class QFunc(QExpandable):
             return
         super().expand()
         self._qmodule.native_defs[self.func_decl.name] = NativeFunctionDefinition(
-            **{**self.func_decl.model_dump(), **{"body": self.body}}
+            **{
+                **self.func_decl.model_dump(),
+                **{
+                    "body": self.body,
+                    "synthesis_data": (
+                        self.synthesis_data
+                        if self.synthesis_data is not None
+                        else FunctionSynthesisData()
+                    ),
+                },
+            },
         )
 
     def _add_constants_from_classical_code(
@@ -115,6 +137,7 @@ class ExternalQFunc(QTerminalCallable):
     _decl: NamedParamsQuantumFunctionDeclaration
 
     def __init__(self, py_callable: Callable) -> None:
+        self._py_callable = py_callable
         decl = infer_func_decl(py_callable)
 
         py_callable.__annotations__.pop("return", None)
@@ -131,6 +154,12 @@ class ExternalQFunc(QTerminalCallable):
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._decl
 
+    def get_implementation(self) -> NativeFunctionDefinition:
+        model = QFunc(self._py_callable).create_model()
+        return [
+            func for func in model.functions if func.name == self._py_callable.__name__
+        ][0]
+
 
 class GenerativeQFunc(QExpandable):
     def __init__(
@@ -161,7 +190,7 @@ class IllegalParamsError(ClassiqError):
         super().__init__(message + self._HINT)
 
 
-def _validate_no_gen_params(annotations: Dict[str, Any]) -> None:
+def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
     _illegal_params = {
         name: annotation
         for name, annotation in annotations.items()

classiq/qmod/semantics/annotation.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall

classiq/qmod/semantics/error_manager.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator, List, Optional, Type
+from typing import Optional
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
@@ -16,9 +17,9 @@ class ErrorManager:
         if hasattr(self, "_instantiated"):
             return
         self._instantiated = True
-        self._errors: List[SourceReferencedError] = []
-        self._current_nodes_stack: List[ASTNode] = []
-        self._call_stack: List[str] = []
+        self._errors: list[SourceReferencedError] = []
+        self._current_nodes_stack: list[ASTNode] = []
+        self._call_stack: list[str] = []
         self._ignore_errors: bool = False
 
     @contextmanager
@@ -31,7 +32,7 @@ class ErrorManager:
             self._ignore_errors = previous
 
     @property
-    def annotated_errors(self) -> List[str]:
+    def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
 
     def add_error(self, error: str) -> None:
@@ -48,7 +49,7 @@ class ErrorManager:
                 )
             )
 
-    def get_errors(self) -> List[SourceReferencedError]:
+    def get_errors(self) -> list[SourceReferencedError]:
         return self._errors
 
     def clear(self) -> None:
@@ -58,7 +59,7 @@ class ErrorManager:
     def has_errors(self) -> bool:
         return len(self._errors) > 0
 
-    def report_errors(self, error_type: Type[Exception]) -> None:
+    def report_errors(self, error_type: type[Exception]) -> None:
         if self.has_errors():
             errors = self.annotated_errors
             self.clear()

classiq/qmod/semantics/static_semantics_visitor.py

@@ -1,15 +1,8 @@
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from typing import (
     Any,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
     Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
 )
 
 from classiq.interface.exceptions import ClassiqSemanticError
@@ -59,6 +52,7 @@ from classiq.qmod.semantics.validation.func_call_validation import (
     validate_call_arguments,
 )
 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 (
     check_cstruct_has_fields,
     check_duplicate_types,
@@ -79,10 +73,10 @@ class StaticScope:
 
     def __init__(
         self,
-        parameters: List[str],
-        operands: Dict[str, QuantumOperandDeclaration],
-        variables_to_states: Dict[str, HandleState],
-        variables_to_types: Dict[str, ConcreteQuantumType],
+        parameters: list[str],
+        operands: dict[str, QuantumOperandDeclaration],
+        variables_to_states: dict[str, HandleState],
+        variables_to_types: dict[str, ConcreteQuantumType],
     ) -> None:
         self.parameters = parameters
         self.operands = operands
@@ -94,9 +88,9 @@ class StaticSemanticsVisitor(Visitor):
     def __init__(
         self,
         functions_dict: Mapping[str, QuantumFunctionDeclaration],
-        constants: List[str],
+        constants: list[str],
     ) -> None:
-        self._scope: List[StaticScope] = []
+        self._scope: list[StaticScope] = []
         self._error_manager = ErrorManager()
         self._functions_dict = functions_dict
         self._constants = constants
@@ -122,6 +116,7 @@ class StaticSemanticsVisitor(Visitor):
                 check_qstruct_flexibility(qstruct)
         for cstruct in model.types:
             check_cstruct_has_fields(cstruct)
+        validate_main_function(model.main_func)
         self.visit_BaseModel(model)
 
     def visit_NativeFunctionDefinition(
@@ -141,7 +136,7 @@ class StaticSemanticsVisitor(Visitor):
             parameter_declaration_names = [
                 decl.name for decl in func_def.positional_arg_declarations
             ]
-            seen_names: Set[str] = set()
+            seen_names: set[str] = set()
             for name in parameter_declaration_names:
                 if name in seen_names:
                     self._error_manager.add_error(
@@ -254,12 +249,12 @@ class StaticSemanticsVisitor(Visitor):
 
     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] = []
+    ) -> 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.get_rename_params()[idx]
+            param_name = lambda_func.pos_rename_params[idx]
             if isinstance(param, AnonClassicalParameterDeclaration):
                 renamed_parameters.append(param_name)
             elif isinstance(param, AnonQuantumOperandDeclaration):
@@ -375,7 +370,7 @@ def resolve_function_calls(
 
 
 def static_semantics_analysis_pass(
-    model: Model, error_type: Optional[Type[Exception]] = ClassiqSemanticError
+    model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
     StaticSemanticsVisitor(
         {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},
@@ -385,7 +380,7 @@ def static_semantics_analysis_pass(
         ErrorManager().report_errors(error_type)
 
 
-EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
+EXPECTED_TERMINAL_STATES: dict[PortDeclarationDirection, HandleState] = {
     PortDeclarationDirection.Output: HandleState.INITIALIZED,
     PortDeclarationDirection.Inout: HandleState.INITIALIZED,
 }
@@ -393,8 +388,8 @@ EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
 
 def initialize_variables_to_state(
     port_declarations: Sequence[PortDeclaration],
-) -> Dict[str, HandleState]:
-    variables_to_state: Dict[str, HandleState] = dict()
+) -> dict[str, HandleState]:
+    variables_to_state: dict[str, HandleState] = dict()
 
     for port_decl in port_declarations:
         variables_to_state[port_decl.name] = (

classiq/qmod/semantics/validation/constants_validation.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.generator.constant import Constant
 

classiq/qmod/semantics/validation/func_call_validation.py

@@ -1,4 +1,4 @@
-from typing import List, Mapping
+from collections.abc import Mapping
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
@@ -83,7 +83,7 @@ def _check_operand_against_declaration(
 
 
 def check_no_overlapping_quantum_args(
-    args: List[HandleBinding], func_name: str
+    args: list[HandleBinding], func_name: str
 ) -> None:
     for idx, arg in enumerate(args):
         for other_arg in args[idx + 1 :]:

classiq/qmod/semantics/validation/main_validation.py

@@ -0,0 +1,33 @@
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+)
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+
+from classiq import ClassicalParameterDeclaration
+from classiq.qmod.semantics.error_manager import append_error
+
+
+def validate_main_function(func: NativeFunctionDefinition) -> None:
+    for param in func.positional_arg_declarations:
+        _validate_main_param(param)
+
+
+def _validate_main_param(param: PositionalArg) -> None:
+    if isinstance(param, ClassicalParameterDeclaration):
+        _validate_main_classical_param_type(param.classical_type, param.name)
+
+
+def _validate_main_classical_param_type(
+    param: ConcreteClassicalType, param_name: str
+) -> None:
+    if isinstance(param, ClassicalList):
+        append_error(
+            param,
+            f"Classical array parameter {param_name!r} of function 'main' must must "
+            f"specify array length",
+        )
+    if isinstance(param, ClassicalArray):
+        _validate_main_classical_param_type(param.element_type, param_name)

classiq/qmod/semantics/validation/types_validation.py

@@ -1,4 +1,5 @@
-from typing import Sequence, Union
+from collections.abc import Sequence
+from typing import Union
 
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration

classiq/qmod/symbolic.py

@@ -2,10 +2,7 @@ import sys
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     overload,
@@ -41,10 +38,10 @@ def symbolic_function(*args: Any, return_type: None = None) -> CParamScalar: ...
 
 
 @overload
-def symbolic_function(*args: Any, return_type: Type[T]) -> T: ...
+def symbolic_function(*args: Any, return_type: type[T]) -> T: ...
 
 
-def symbolic_function(*args: Any, return_type: Optional[Type[T]] = None) -> CParam:
+def symbolic_function(*args: Any, return_type: Optional[type[T]] = None) -> CParam:
     qmodule = (
         model_state_container.QMODULE
     )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
@@ -266,7 +263,7 @@ def catalan(x: SymbolicTypes) -> CParamScalar:
     return symbolic_function(x)
 
 
-def Piecewise(*args: Tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
+def Piecewise(*args: tuple[SymbolicTypes, SymbolicTypes]) -> CParamScalar:  # noqa: N802
     return symbolic_function(*args)
 
 
@@ -299,7 +296,7 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
 
 
 def subscript(
-    amplitudes: Union[List[float], List[CReal], List[CParamScalar], CArray[CReal]],
+    amplitudes: Union[list[float], list[CReal], list[CParamScalar], CArray[CReal]],
     index: QNum,
 ) -> CParamScalar:
     return CParamScalar(expr=f"{amplitudes}[{index}]")
@@ -373,5 +370,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/symbolic_type.py

@@ -1,5 +1,5 @@
-from typing import Tuple, Union
+from typing import Union
 
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
-SymbolicTypes = Union[SymbolicExpr, int, float, bool, Tuple["SymbolicTypes", ...]]
+SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]

classiq/qmod/synthesize_separately.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.model.native_function_definition import FunctionSynthesisData
+
+from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
+
+
+def synthesize_separately(qfunc: Union[QFunc, GenerativeQFunc, ExternalQFunc]) -> QFunc:
+    if isinstance(qfunc, QFunc):
+        qfunc.synthesis_data = FunctionSynthesisData(should_synthesize_separately=True)
+        return qfunc
+    if isinstance(qfunc, GenerativeQFunc):
+        raise ClassiqError("Generative functions can not be synthesized separately")
+    if isinstance(qfunc, ExternalQFunc):
+        raise ClassiqError("External functions can not be synthesized separately")

{classiq-0.52.0.dist-info → classiq-0.54.0.dist-info}/METADATA

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