classiq 0.75.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/qmod/pretty_print/pretty_printer.py

@@ -264,7 +264,7 @@ class PythonPrettyPrinter(ModelVisitor):
         if port_decl.direction is not PortDeclarationDirection.Inout:
             self._imports[port_decl.direction.name] = 1
             var_type = f"{port_decl.direction.name}[{var_type}]"
-        if port_decl.type_qualifier is not TypeQualifier.Quantum:
+        if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]:
             self._imports[port_decl.type_qualifier.name] = 1
             var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
         return var_type

classiq/qmod/python_classical_type.py

@@ -19,7 +19,7 @@ from classiq.interface.generator.functions.classical_type import (
     Real,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.generator.functions.type_name import Enum, Struct
+from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.utilities import version_portable_get_args
@@ -59,8 +59,7 @@ class PythonClassicalType:
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
-            self.register_struct(py_type)
-            return Struct(name=py_type.__name__)
+            return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
@@ -68,8 +67,8 @@ class PythonClassicalType:
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
-    def register_struct(self, py_type: type) -> None:
-        pass
+    def register_struct(self, py_type: type) -> TypeName:
+        return Struct(name=py_type.__name__)
 
     def register_enum(self, py_type: EnumMeta) -> None:
         pass

classiq/qmod/qmod_constant.py

@@ -1,6 +1,6 @@
 import inspect
 from dataclasses import is_dataclass
-from typing import Any, Optional, cast, get_origin
+from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
@@ -17,7 +17,7 @@ from classiq.qmod.generative import (
     interpret_expression,
     is_generative_mode,
 )
-from classiq.qmod.model_state_container import ModelStateContainer
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.utilities import qmod_val_to_expr_str
@@ -42,11 +42,12 @@ class QConstant(SymbolicExpr):
 
     def add_to_model(self) -> None:
         from classiq.qmod.builtins.constants import __all__ as builtin_constants
+        from classiq.qmod.semantics.validation.constants_validation import (
+            check_duplicate_constants,
+        )
 
-        if self.name in builtin_constants:
+        if self.name in builtin_constants or QConstant.CURRENT_QMODULE is None:
             return
-        if QConstant.CURRENT_QMODULE is None:
-            raise ClassiqError(QMODULE_ERROR_MESSAGE)
 
         expr = qmod_val_to_expr_str(self._value)
         if (
@@ -57,6 +58,7 @@ class QConstant(SymbolicExpr):
 
         constant = self._get_constant_node()
         QConstant.CURRENT_QMODULE.constants[self.name] = constant
+        check_duplicate_constants([constant])
         if is_generative_mode():
             get_frontend_interpreter().add_constant(constant)
 
@@ -106,8 +108,10 @@ class QConstant(SymbolicExpr):
     def __getitem__(self, item: Any) -> CParam:
         self.add_to_model()
 
-        assert QConstant.CURRENT_QMODULE is not None
-
+        if QConstant.CURRENT_QMODULE is None:
+            QConstant.set_current_model(QMODULE)
+        if TYPE_CHECKING:
+            assert QConstant.CURRENT_QMODULE is not None
         qmod_type = python_type_to_qmod(
             self._py_type, qmodule=QConstant.CURRENT_QMODULE
         )
@@ -141,3 +145,7 @@ class QConstant(SymbolicExpr):
         if is_generative_mode():
             return interpret_expression(len_expr)
         return cast(int, CParamScalar(len_expr))
+
+    def __str__(self) -> str:
+        self.add_to_model()
+        return super().__str__()

classiq/qmod/qmod_variable.py

@@ -70,6 +70,8 @@ from classiq.qmod.generative import (
 )
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 from classiq.qmod.utilities import (
@@ -696,6 +698,8 @@ def _register_qstruct(
     if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
         return
 
+    # temp assignment for recursive qstruct definitions
+    qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
     _validate_fields(type_hint)
     struct_decl = QStructDeclaration(
         name=struct_name,
@@ -705,6 +709,8 @@ def _register_qstruct(
         },
     )
     qmodule.qstruct_decls[struct_name] = struct_decl
+    QStructAnnotator().visit(struct_decl)
+    validate_qstruct(struct_decl)
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:
@@ -749,5 +755,5 @@ def _get_root_type(py_type: Any) -> type[QVar]:
     )
     root_type = get_origin(non_annotated_type) or non_annotated_type
     if not issubclass(root_type, QVar):
-        raise ClassiqInternalError(f"Invalid quantum type {root_type}")
+        raise ClassiqValueError(f"Invalid quantum type {root_type.__name__!r}")
     return root_type

classiq/qmod/quantum_function.py

@@ -14,7 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.model.model import Model
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
@@ -31,6 +31,7 @@ from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.utilities import mangle_keyword
 
 
@@ -104,7 +105,7 @@ class QFunc(BaseQFunc):
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         name = self._py_callable.__name__
-        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+        if name in self._qmodule.native_defs:
             return self._qmodule.native_defs[name]
         return infer_func_decl(self._py_callable, qmodule=self._qmodule)
 
@@ -250,15 +251,23 @@ class GenerativeQFunc(BaseQFunc):
     ) -> None:
         super().__init__(py_callable, compilation_metadata)
         self._func_decl = func_decl
+        self._inferred_func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        if self._func_decl is None:
-            self._func_decl = infer_func_decl(self._py_callable, self._qmodule)
-        return self._func_decl
+        if self._func_decl is not None:
+            return self._func_decl
+        if self._inferred_func_decl is None:
+            self._inferred_func_decl = infer_func_decl(self._py_callable, self._qmodule)
+        return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
-        self._qmodule.generative_functions[self.func_decl.name] = self
+        if self.func_decl.name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[self.func_decl.name] = self
+            if self._func_decl is None:
+                self._inferred_func_decl = infer_func_decl(
+                    self._py_callable, self._qmodule
+                )
         super().__call__(*args, **kwargs)
 
     def create_model(
@@ -268,6 +277,10 @@ class GenerativeQFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
+        self._qmodule.reset()
+        if self.func_decl.name == MAIN_FUNCTION_NAME:
+            validate_main_function(self.func_decl)
+
         def _dec_main(*args: Any, **kwargs: Any) -> None:
             self(*args, **kwargs)
 

classiq/qmod/semantics/lambdas.py

@@ -1,3 +1,4 @@
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -14,8 +15,11 @@ def get_renamed_parameters(
     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]
+    for param, param_name in zip_strict(
+        lambda_func.func_decl.positional_arg_declarations,
+        lambda_func.pos_rename_params,
+        strict=False,
+    ):
         if isinstance(param, AnonClassicalParameterDeclaration):
             renamed_parameters.append(param_name)
         elif isinstance(param, AnonQuantumOperandDeclaration):

classiq/qmod/semantics/validation/main_validation.py

@@ -1,16 +1,22 @@
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
 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.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
 
 from classiq import ClassicalParameterDeclaration
 
 
-def validate_main_function(func: NativeFunctionDefinition) -> None:
+def validate_main_function(func: NamedParamsQuantumFunctionDeclaration) -> None:
     for param in func.positional_arg_declarations:
         _validate_main_param(param)
 
@@ -18,6 +24,8 @@ def validate_main_function(func: NativeFunctionDefinition) -> None:
 def _validate_main_param(param: PositionalArg) -> None:
     if isinstance(param, ClassicalParameterDeclaration):
         _validate_main_classical_param_type(param.classical_type, param.name)
+    if isinstance(param, PortDeclaration):
+        _validate_main_quantum_param_type(param)
 
 
 def _validate_main_classical_param_type(
@@ -30,3 +38,8 @@ def _validate_main_classical_param_type(
         )
     if isinstance(param, ClassicalArray):
         _validate_main_classical_param_type(param.element_type, param_name)
+
+
+def _validate_main_quantum_param_type(param: PortDeclaration) -> None:
+    if param.direction != PortDeclarationDirection.Output:
+        raise ClassiqValueError("Function 'main' cannot declare quantum inputs")

classiq/qmod/symbolic.py

@@ -1,5 +1,4 @@
 import sys
-from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,6 +11,9 @@ from typing import (
 import numpy as np
 
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    subscript_to_str,
+)
 
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -24,6 +26,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 pi = SymbolicExpr("pi", False)
 E = SymbolicExpr("E", False)
@@ -306,27 +309,13 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
-def _subscript_to_str(index: Any) -> str:
-    if not isinstance(index, slice):
-        return str(index)
-    expr = ""
-    if index.start is not None:
-        expr += str(index.start)
-    expr += ":"
-    if index.stop is not None:
-        expr += str(index.stop)
-    if index.step is not None:
-        expr += f":{index.step}"
-    return expr
-
-
 def subscript(
-    array: Union[
-        Sequence[Union[float, CReal, CParamScalar]], CArray[CReal], np.ndarray
-    ],
+    array: Union[list, CArray[CReal], np.ndarray],
     index: Any,
 ) -> CParamScalar:
-    return CParamScalar(expr=f"{_unwrap_numpy(array)}[{_subscript_to_str(index)}]")
+    return CParamScalar(
+        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{subscript_to_str(index)}]"
+    )
 
 
 __all__ = [

classiq/qmod/symbolic_expr.py

@@ -177,3 +177,29 @@ class SymbolicEquality(SymbolicExpr):
         super().__init__(sym_expr._expr, sym_expr.is_quantum)
         self.lhs = lhs
         self.rhs = rhs
+
+
+class SymbolicSubscriptAndField(SymbolicExpr):
+    def __getattr__(self, item: str) -> SymbolicSubscriptAndField:
+        return SymbolicSubscriptAndField(f"{self}.{item}", is_quantum=self.is_quantum)
+
+    def __getitem__(self, item: Any) -> SymbolicExpr:
+        if isinstance(item, slice):
+            start = item.start
+            stop = item.stop
+            step = item.step
+            item_is_quantum = (
+                (isinstance(start, SymbolicExpr) and start.is_quantum)
+                or (isinstance(stop, SymbolicExpr) and stop.is_quantum)
+                or (isinstance(step, SymbolicExpr) and step.is_quantum)
+            )
+            start_str = "" if start is None else qmod_val_to_expr_str(start)
+            stop_str = "" if stop is None else qmod_val_to_expr_str(stop)
+            step_str = "" if step is None else qmod_val_to_expr_str(step)
+            item_str = f"{start_str}:{stop_str}:{step_str}"
+        else:
+            item_is_quantum = isinstance(item, SymbolicExpr) and item.is_quantum
+            item_str = qmod_val_to_expr_str(item)
+        return SymbolicSubscriptAndField(
+            f"{self}[{item_str}]", is_quantum=self.is_quantum or item_is_quantum
+        )

classiq/synthesis.py

@@ -1,6 +1,4 @@
-from typing import Any, NewType, Optional, Union
-
-import pydantic
+from typing import Any, Optional, Union
 
 from classiq.interface.analyzer.result import QasmCode
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
@@ -12,43 +10,33 @@ from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedM
 from classiq import QuantumProgram
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
-
-SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
+from classiq.qmod.quantum_function import BaseQFunc
 
-CANT_PARSE_QUANTUM_PROGRAM_MSG = (
-    "Can not parse quantum_program into GeneratedCircuit, \n"
-)
+SerializedQuantumProgram = QuantumProgram
 
 
-def show(quantum_program: SerializedQuantumProgram, display_url: bool = True) -> None:
+def show(quantum_program: QuantumProgram, display_url: bool = True) -> None:
     """
     Displays the interactive representation of the quantum program in the Classiq IDE.
 
     Args:
         quantum_program:
-            The serialized quantum program to be displayed.
+            The quantum program to be displayed.
         display_url:
             Whether to print the url
 
     Links:
         [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
     """
-    try:
-        circuit = QuantumProgram.model_validate_json(quantum_program)
-    except pydantic.ValidationError as exc:
-        raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
-    circuit.show()  # type: ignore[attr-defined]
+    QuantumProgram.model_validate(quantum_program)
+    quantum_program.show()  # type: ignore[attr-defined]
 
 
-async def quantum_program_from_qasm_async(qasm: str) -> SerializedQuantumProgram:
-    quantum_program = await ApiWrapper.get_generated_circuit_from_qasm(
-        QasmCode(code=qasm)
-    )
-    return SerializedQuantumProgram(quantum_program.model_dump_json())
+async def quantum_program_from_qasm_async(qasm: str) -> QuantumProgram:
+    return await ApiWrapper.get_generated_circuit_from_qasm(QasmCode(code=qasm))
 
 
-def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
+def quantum_program_from_qasm(qasm: str) -> QuantumProgram:
     """
     generate a quantum program from a QASM file.
 
@@ -56,25 +44,24 @@ def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
         qasm: A QASM2/3 string.
 
     Returns:
-        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+        QuantumProgram: Quantum program. (See: QuantumProgram)
     """
     return async_utils.run(quantum_program_from_qasm_async(qasm))
 
 
 async def synthesize_async(
     serialized_model: SerializedModel,
-) -> SerializedQuantumProgram:
+) -> QuantumProgram:
     model = Model.model_validate_json(serialized_model)
-    quantum_program = await ApiWrapper.call_generation_task(model)
-    return SerializedQuantumProgram(quantum_program.model_dump_json(indent=2))
+    return await ApiWrapper.call_generation_task(model)
 
 
 def synthesize(
-    model: Union[SerializedModel, QFunc, GenerativeQFunc],
+    model: Union[SerializedModel, BaseQFunc],
     auto_show: bool = False,
     constraints: Optional[Constraints] = None,
     preferences: Optional[Preferences] = None,
-) -> SerializedQuantumProgram:
+) -> QuantumProgram:
     """
     Synthesize a model with the Classiq engine to receive a quantum program.
     [More details](https://docs.classiq.io/latest/reference-manual/synthesis/)
@@ -86,9 +73,9 @@ def synthesize(
         preferences: Preferences for the synthesis of the model. See Preferences (Optional).
 
     Returns:
-        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+        QuantumProgram: Quantum program. (See: QuantumProgram)
     """
-    if isinstance(model, (QFunc, GenerativeQFunc)):
+    if isinstance(model, BaseQFunc):
         func_name = model._py_callable.__name__
         if func_name != MAIN_FUNCTION_NAME:
             raise ClassiqError(
@@ -252,7 +239,6 @@ def update_execution_preferences(
 
 __all__ = [
     "SerializedModel",
-    "SerializedQuantumProgram",
     "set_constraints",
     "set_execution_preferences",
     "set_preferences",

classiq/visualization.py

@@ -0,0 +1,35 @@
+from typing import NewType
+
+from classiq.interface.analyzer.result import DataID
+from classiq.interface.exceptions import ClassiqAPIError
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+SerializedVisualModel = NewType("SerializedVisualModel", str)
+
+
+async def visualize_async(
+    data_id: DataID,
+) -> SerializedVisualModel:
+    try:
+        visual_model = await ApiWrapper.call_get_visual_model(data_id.id)
+    except ClassiqAPIError as error:
+        if error.status_code != 404:
+            raise error
+        analyzer_data = await ApiWrapper.get_analyzer_app_data(data_id)
+        visual_model = await ApiWrapper.call_visualization_task(analyzer_data)
+    return SerializedVisualModel(visual_model.model_dump_json(indent=2))
+
+
+def visualize(
+    data_id: DataID,
+) -> SerializedVisualModel:
+    result = async_utils.run(visualize_async(data_id))
+    return result
+
+
+__all__ = [
+    "SerializedVisualModel",
+    "visualize",
+]

{classiq-0.75.0.dist-info → classiq-0.76.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.75.0
+Version: 0.76.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL