classiq 0.56.1__py3-none-any.whl → 0.58.0__py3-none-any.whl

classiq/qmod/create_model_function.py

@@ -71,7 +71,6 @@ def create_model(
             constraints,
             execution_preferences,
             preferences,
-            classical_execution_function,
         )
     else:
         if TYPE_CHECKING:
@@ -95,26 +94,21 @@ def _expand_generative_model(
     constraints: Optional[Constraints] = None,
     execution_preferences: Optional[ExecutionPreferences] = None,
     preferences: Optional[Preferences] = None,
-    classical_execution_function: Optional[CFunc] = None,
 ) -> Model:
     @QFunc
     def _dummy() -> None:
         pass
 
-    functions_compilation_metadata = {
-        dec_func._py_callable.__name__: dec_func.compilation_metadata
-        for dec_func in DEC_QFUNCS
-        if dec_func.compilation_metadata is not None
-    }
     model = _dummy.create_model(
         constraints,
         execution_preferences,
         preferences,
-        classical_execution_function,
-        functions_compilation_metadata,
     )
-    generative_functions = _get_generative_functions(gen_main, preferences)
-    model.functions = generative_functions
+    gen_expand_model = _get_generative_functions(gen_main, preferences)
+    model.functions = gen_expand_model.functions
+    model.functions_compilation_metadata = (
+        gen_expand_model.functions_compilation_metadata
+    )
     model.types = list(QMODULE.type_decls.values())
     model.enums = list(QMODULE.enum_decls.values())
     model.qstructs = list(QMODULE.qstruct_decls.values())
@@ -122,8 +116,9 @@ def _expand_generative_model(
 
 
 def _get_generative_functions(
-    gen_main: QFunc, preferences: Optional[Preferences]
-) -> list[NativeFunctionDefinition]:
+    gen_main: QFunc,
+    preferences: Optional[Preferences],
+) -> Model:
     # The Interpreter accepts a model and a list of generative functions.
     # Since the main function is generative, it can only be expanded using the
     # Interpreter.
@@ -132,14 +127,21 @@ def _get_generative_functions(
     # passing them to the Interpreter.
     gen_model = _get_wrapper_main(gen_main, preferences)
     gen_functions = _get_all_model_functions_as_generative_functions()
-    functions_dict = _interpret_generative_model(gen_model, gen_functions)
-    return list(functions_dict.values())
+    return _interpret_generative_model(gen_model, gen_functions)
 
 
-def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Model:
+def _get_wrapper_main(
+    gen_main: QFunc,
+    preferences: Optional[Preferences],
+) -> Model:
     extra_args = {}
     if preferences is not None:
         extra_args["preferences"] = preferences
+    functions_compilation_metadata = {
+        qfunc._py_callable.__name__: qfunc.compilation_metadata
+        for qfunc in DEC_QFUNCS + GEN_QFUNCS
+        if qfunc.compilation_metadata is not None
+    }
     return Model(
         functions=[
             NativeFunctionDefinition(
@@ -157,6 +159,7 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
                 ],
             ),
         ],
+        functions_compilation_metadata=functions_compilation_metadata,
         **extra_args,
     )
 
@@ -164,7 +167,9 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
 def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
     gen_functions = list(GEN_QFUNCS) + [
-        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+        GenerativeQFunc(
+            dec_func._py_callable, dec_func.func_decl, dec_func.compilation_metadata
+        )
         for dec_func in DEC_QFUNCS
     ]
     return [
@@ -174,6 +179,7 @@ def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
             else GenerativeQFunc(
                 gen_func._py_callable,
                 gen_func.func_decl.model_copy(update={"name": GEN_MAIN_NAME}),
+                gen_func.compilation_metadata,
             )
         )
         for gen_func in gen_functions
@@ -183,7 +189,7 @@ def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
 def _interpret_generative_model(
     gen_model: Model, gen_functions: list[GenerativeQFunc]
-) -> dict[str, NativeFunctionDefinition]:
+) -> Model:
     resolve_function_calls(
         gen_model,
         {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
@@ -201,5 +207,4 @@ def _interpret_generative_model(
         expanded_gen_main_name
     ].model_copy(update={"name": MAIN_FUNCTION_NAME})
     functions_dict.pop(expanded_gen_main_name)
-
-    return functions_dict
+    return expand_model.model_copy(update={"functions": list(functions_dict.values())})

classiq/qmod/native/pretty_printer.py

@@ -83,10 +83,13 @@ from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 class DSLPrettyPrinter(Visitor):
     def __init__(
-        self, decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION
+        self,
+        decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
+        rename_phase: bool = False,
     ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
+        self._rename_phase = rename_phase
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -165,7 +168,10 @@ class DSLPrettyPrinter(Visitor):
     def visit_QuantumVariableDeclaration(
         self, var_decl: QuantumVariableDeclaration
     ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
+        var_name = var_decl.name
+        if self._rename_phase and var_name == "phase":
+            var_name = "phase_var"
+        return f"{var_name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         dir_str = (
@@ -173,7 +179,12 @@ class DSLPrettyPrinter(Visitor):
             if port_decl.direction != PortDeclarationDirection.Inout
             else ""
         )
-        param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
+        port_name = (
+            port_decl.name
+            if not (self._rename_phase and port_decl.name == "phase")
+            else "phase_var"
+        )
+        param_name = f"{port_name}: " if port_decl.name is not None else ""
         return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
@@ -339,7 +350,11 @@ class DSLPrettyPrinter(Visitor):
         return f"lambda({positional_args}) {{\n{body}{self._indent}}}"
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
-        return var_ref.name
+        return (
+            var_ref.name
+            if not (self._rename_phase and var_ref.name == "phase")
+            else "phase_var"
+        )
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"

classiq/qmod/pretty_print/pretty_printer.py

@@ -3,6 +3,7 @@ from typing import Optional, Union, cast
 
 import black
 
+from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
@@ -86,16 +87,15 @@ class VariableDeclarationAssignment(Visitor):
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
-    def visit(self, node: NodeType) -> tuple[str, Optional[list[str]]]:
+    def visit(self, node: NodeType) -> tuple[str, list[str]]:
         res = super().visit(node)
         if not isinstance(res, tuple):
             raise AssertionError(f"Pretty printing for {type(node)} is not supported ")
         return res  # type: ignore[return-value]
 
-    def visit_QuantumBit(self, qtype: QuantumBit) -> tuple[str, Optional[list[str]]]:
+    def visit_QuantumBit(self, qtype: QuantumBit) -> tuple[str, list[str]]:
         self.pretty_printer._imports["QBit"] = 1
-
-        return "QBit", None
+        return "QBit", []
 
     def visit_QuantumBitvector(
         self, qtype: QuantumBitvector
@@ -111,19 +111,10 @@ class VariableDeclarationAssignment(Visitor):
         self, qtype: QuantumNumeric
     ) -> tuple[str, Optional[list[str]]]:
         self.pretty_printer._imports["QNum"] = 1
+        return "QNum", self.pretty_printer._get_qnum_properties(qtype)
 
-        params = []
-        if qtype.size is not None:
-            params = [
-                self.pretty_printer.visit(param)
-                for param in [qtype.size, qtype.is_signed, qtype.fraction_digits]
-                if param is not None
-            ]
-
-        return "QNum", params
-
-    def visit_TypeName(self, qtype: TypeName) -> tuple[str, None]:
-        return qtype.name, None
+    def visit_TypeName(self, qtype: TypeName) -> tuple[str, list[str]]:
+        return qtype.name, []
 
 
 class PythonPrettyPrinter(Visitor):
@@ -269,21 +260,46 @@ class PythonPrettyPrinter(Visitor):
         return f"QArray[{element_type}]"
 
     def visit_QuantumNumeric(self, qtype: QuantumNumeric) -> str:
-        params = ""
         self._imports["QNum"] = 1
-        if qtype.size is not None:
-            assert qtype.is_signed is not None
-            assert qtype.fraction_digits is not None
-
+        params = ""
+        qnum_properties = self._get_qnum_properties(qtype)
+        if len(qnum_properties) > 0:
             params = "[{}]".format(
-                ", ".join(
-                    _add_quotes(self.visit(param))
-                    for param in [qtype.size, qtype.is_signed, qtype.fraction_digits]
-                )
+                ", ".join(_add_quotes(param) for param in qnum_properties)
             )
-
         return f"QNum{params}"
 
+    def _get_qnum_properties(self, qtype: QuantumNumeric) -> list[str]:
+        params: list[str] = []
+        if qtype.size is None:
+            return params
+        params.append(self.visit(qtype.size))
+
+        is_signed_expr = qtype.is_signed
+        fraction_digits_expr = qtype.fraction_digits
+        if is_signed_expr is None:
+            if fraction_digits_expr is not None:
+                raise ClassiqInternalError
+            return params
+        if fraction_digits_expr is None:
+            raise ClassiqInternalError
+
+        is_unsigned = (
+            is_signed_expr.is_evaluated()
+            and not is_signed_expr.to_bool_value()
+            or is_signed_expr.expr == "UNSIGNED"
+        )
+        is_integer = (
+            fraction_digits_expr.is_evaluated()
+            and fraction_digits_expr.to_int_value() == 0
+        )
+        if is_unsigned and is_integer:
+            return params
+        params.append(self.visit(is_signed_expr))
+        params.append(self.visit(fraction_digits_expr))
+
+        return params
+
     def visit_AnonClassicalParameterDeclaration(
         self, cparam: AnonClassicalParameterDeclaration
     ) -> str:
@@ -325,7 +341,7 @@ class PythonPrettyPrinter(Visitor):
         type_name, params = VariableDeclarationAssignment(self).visit(
             local_decl.quantum_type
         )
-        params = [f'"{local_decl.name}"'] + (params or [])
+        params = [f'"{local_decl.name}"'] + params
         param_args = ", ".join(params)
         return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)} = {type_name}({param_args})\n"
 
@@ -516,7 +532,12 @@ class PythonPrettyPrinter(Visitor):
 
 
 def _add_quotes(exp: str) -> str:
-    if exp.lower() == "true" or exp.lower() == "false" or _convertible_to_number(exp):
+    if (
+        exp.lower() == "true"
+        or exp.lower() == "false"
+        or _convertible_to_number(exp)
+        or _is_constant(exp)
+    ):
         return exp
 
     return f'"{exp}"'
@@ -531,3 +552,7 @@ def _convertible_to_number(exp: str) -> bool:
         else:
             return True
     return False
+
+
+def _is_constant(exp: str) -> bool:
+    return exp in ("SIGNED", "UNSIGNED")

classiq/qmod/qfunc.py

@@ -1,9 +1,14 @@
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqInternalError
 
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.quantum_function import ExternalQFunc, GenerativeQFunc, QFunc
+from classiq.qmod.quantum_function import (
+    BaseQFunc,
+    ExternalQFunc,
+    GenerativeQFunc,
+    QFunc,
+)
 
 GEN_QFUNCS: list[GenerativeQFunc] = []
 DEC_QFUNCS: list[QFunc] = []
@@ -54,25 +59,22 @@ def qfunc(
     synthesize_separately: bool = False,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
+        qfunc: BaseQFunc
         if generative:
-            gen_qfunc = GenerativeQFunc(func)
+            qfunc = GenerativeQFunc(func)
+            GEN_QFUNCS.append(qfunc)
+        elif external:
             if synthesize_separately:
-                raise ClassiqError(
-                    "Generative functions can not be synthesized separately"
-                )
-            GEN_QFUNCS.append(gen_qfunc)
-            return gen_qfunc
-        if external:
-            if synthesize_separately:
-                raise ClassiqError(
-                    "External functions can not be synthesized separately"
+                raise ClassiqInternalError(
+                    "External functions can't be marked as synthesized separately"
                 )
             return ExternalQFunc(func)
-        dec_qfunc = QFunc(func)
+        else:
+            qfunc = QFunc(func)
+            DEC_QFUNCS.append(qfunc)
         if synthesize_separately:
-            dec_qfunc.should_synthesize_separately = True
-        DEC_QFUNCS.append(dec_qfunc)
-        return dec_qfunc
+            qfunc.update_compilation_metadata(should_synthesize_separately=True)
+        return qfunc
 
     if func is not None:
         return wrapper(func)

classiq/qmod/quantum_function.py

@@ -28,12 +28,35 @@ from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.utilities import mangle_keyword
 
 
-class QFunc(QExpandable):
+class BaseQFunc(QExpandable):
+    def __init__(
+        self,
+        py_callable: Callable,
+        compilation_metadata: Optional[CompilationMetadata] = None,
+    ) -> None:
+        super().__init__(py_callable)
+        self.compilation_metadata = compilation_metadata
+
+    def update_compilation_metadata(self, **kwargs: Any) -> None:
+        self.compilation_metadata = self._compilation_metadata.model_copy(update=kwargs)
+
+    @property
+    def _compilation_metadata(self) -> CompilationMetadata:
+        if self.compilation_metadata is None:
+            return CompilationMetadata()
+        return self.compilation_metadata
+
+
+class QFunc(BaseQFunc):
     FRAME_DEPTH = 2
 
-    def __init__(self, py_callable: Callable) -> None:
+    def __init__(
+        self,
+        py_callable: Callable,
+        compilation_metadata: Optional[CompilationMetadata] = None,
+    ) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
-        super().__init__(py_callable)
+        super().__init__(py_callable, compilation_metadata)
         functools.update_wrapper(self, py_callable)
         self.compilation_metadata: Optional[CompilationMetadata] = None
 
@@ -44,21 +67,6 @@ class QFunc(QExpandable):
             infer_func_decl(self._py_callable, qmodule=self._qmodule),
         )
 
-    @property
-    def should_synthesize_separately(self) -> bool:
-        if self.compilation_metadata is None:
-            return False
-        return self.compilation_metadata.should_synthesize_separately
-
-    @should_synthesize_separately.setter
-    def should_synthesize_separately(self, value: bool) -> None:
-        if self.compilation_metadata is None:
-            self.compilation_metadata = CompilationMetadata(
-                should_synthesize_separately=value
-            )
-        else:
-            self.compilation_metadata.should_synthesize_separately = value
-
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         super().__call__(*args, **kwargs)
         self.expand()
@@ -69,16 +77,13 @@ class QFunc(QExpandable):
         execution_preferences: Optional[ExecutionPreferences] = None,
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
-        functions_compilation_metadata: Optional[dict[str, CompilationMetadata]] = None,
     ) -> Model:
-        if functions_compilation_metadata is None:
-            functions_compilation_metadata = dict()
         self._qmodule.enum_decls = dict()
         self._qmodule.type_decls = dict()
         self._qmodule.qstruct_decls = dict()
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
-        self._qmodule.functions_compilation_metadata = functions_compilation_metadata
+        self._qmodule.functions_compilation_metadata = dict()
         QConstant.set_current_model(self._qmodule)
         self.expand()
         model_extra_settings: list[tuple[str, Any]] = [
@@ -167,13 +172,14 @@ class ExternalQFunc(QTerminalCallable):
         ][0]
 
 
-class GenerativeQFunc(QExpandable):
+class GenerativeQFunc(BaseQFunc):
     def __init__(
         self,
         py_callable: Callable,
         func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+        compilation_metadata: Optional[CompilationMetadata] = None,
     ) -> None:
-        super().__init__(py_callable)
+        super().__init__(py_callable, compilation_metadata)
         self._func_decl = func_decl
 
     @property

classiq/qmod/semantics/qstruct_annotator.py

@@ -0,0 +1,23 @@
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.visitor import Visitor
+
+from classiq.qmod.model_state_container import QMODULE
+
+
+class QStructAnnotator(Visitor):
+    def __init__(self) -> None:
+        self._visited: set[TypeName] = set()
+
+    def visit_TypeName(self, type_name: TypeName) -> None:
+        decl = QMODULE.qstruct_decls.get(type_name.name)
+        if decl is None or type_name.has_fields or (type_name in self._visited):
+            return
+        self._visited.add(type_name)
+        new_fields = {
+            field_name: field_type.model_copy()
+            for field_name, field_type in decl.fields.items()
+        }
+        # We first visit the new fields and then set to deal with recursive
+        # qstructs
+        self.visit(new_fields)
+        type_name.set_fields(new_fields)

classiq/qmod/semantics/static_semantics_visitor.py

@@ -44,6 +44,7 @@ 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.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.constants_validation import (
     check_duplicate_constants,
 )
@@ -70,7 +71,6 @@ HANDLE_BINDING_PART_MESSAGE = {
 
 
 class StaticScope:
-
     def __init__(
         self,
         parameters: list[str],
@@ -363,6 +363,8 @@ def resolve_function_calls(
     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},
             [],
@@ -372,6 +374,7 @@ def resolve_function_calls(
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
+    QStructAnnotator().visit(model)
     StaticSemanticsVisitor(
         {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict},
         [const.name for const in model.constants],

classiq/qmod/write_qmod.py

@@ -36,7 +36,9 @@ def write_qmod(
         model
     )
 
-    synthesis_options = model.model_dump(include={"constraints", "preferences"})
+    synthesis_options = model.model_dump(
+        include={"constraints", "preferences"}, exclude_none=True
+    )
 
     synthesis_options_path = Path(f"{name}.{_SYNTHESIS_OPTIONS_SUFFIX}")
     if directory is not None:

classiq/synthesis.py

@@ -20,13 +20,15 @@ CANT_PARSE_QUANTUM_PROGRAM_MSG = (
 )
 
 
-def show(quantum_program: SerializedQuantumProgram) -> None:
+def show(quantum_program: SerializedQuantumProgram, 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.
+        display_url:
+            Whether to print the url
 
     Links:
         [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)

{classiq-0.56.1.dist-info → classiq-0.58.0.dist-info}/METADATA

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