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

classiq/model_expansions/transformers/var_splitter.py

@@ -0,0 +1,237 @@
+import ast
+from dataclasses import dataclass
+from itertools import chain
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType, Transformer
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumScalar,
+    QuantumType,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
+
+
+@dataclass(frozen=True)
+class SymbolPart:
+    source_handle: HandleBinding
+    target_var_name: str
+    target_var_type: QuantumType
+
+    @property
+    def target_var_handle(self) -> HandleBinding:
+        return HandleBinding(name=self.target_var_name)
+
+
+SymbolParts = dict[QuantumSymbol, list[SymbolPart]]
+PartNamer = Callable[[str], str]
+
+
+class VarSplitter:
+    def __init__(self, scope: Scope):
+        self._scope = scope
+
+    def split_symbols(self, expression: Expression, namer: PartNamer) -> SymbolParts:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+        symbol_names_to_split = dict.fromkeys(
+            handle.name
+            for handle in self._get_handles(vrc)
+            if isinstance(handle, NestedHandleBinding)
+        )
+
+        symbol_handles = {
+            symbol: list(
+                dict.fromkeys(
+                    handle.collapse()
+                    for handle in vrc.var_handles
+                    if handle.name == symbol.handle.name
+                )
+            )
+            for symbol_name in symbol_names_to_split
+            if isinstance(
+                symbol := self._scope[symbol_name].value,
+                QuantumSymbol,
+            )
+        }
+
+        return {
+            symbol: [
+                SymbolPart(
+                    source_handle=part.handle,
+                    target_var_name=namer(part.handle.identifier),
+                    target_var_type=part.quantum_type,
+                )
+                for part in self._get_symbol_parts(symbol, handles)
+            ]
+            for symbol, handles in symbol_handles.items()
+        }
+
+    def _get_handles(self, collector: VarRefCollector) -> list[HandleBinding]:
+        return [
+            handle
+            for handle in collector.var_handles
+            if isinstance(self._scope[handle.name].value, QuantumSymbol)
+        ]
+
+    def _get_symbol_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        for i in range(len(target_parts)):
+            for j in range(i + 1, len(target_parts)):
+                if target_parts[i].overlaps(target_parts[j]):
+                    raise ClassiqInternalExpansionError(
+                        f"Handles {str(target_parts[i])!r} and "
+                        f"{str(target_parts[j])!r} overlapping in expression"
+                    )
+        return self._get_symbol_parts_unsafe(symbol, target_parts)
+
+    def _get_symbol_parts_unsafe(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if all(
+            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
+            for target_part in target_parts
+        ) or isinstance(symbol.quantum_type, QuantumScalar):
+            return [symbol]
+
+        if isinstance(symbol.quantum_type, QuantumBitvector):
+            return self._get_array_parts(symbol, target_parts)
+
+        return self._get_struct_parts(symbol, target_parts)
+
+    def _get_array_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+
+        if not symbol.quantum_type.has_length:
+            raise ClassiqExpansionError(
+                f"Could not determine the length of quantum array " f"{symbol.handle}."
+            )
+        target_slices = {
+            target_part.start.to_int_value(): target_part.end.to_int_value()
+            for target_part in target_parts
+            if isinstance(target_part, SlicedHandleBinding)
+            and symbol.handle == target_part.base_handle
+        }
+
+        symbol_parts: list[QuantumSymbol] = []
+        idx = 0
+        while idx < symbol.quantum_type.length_value:
+            if idx in target_slices:
+                stop = target_slices[idx]
+                if stop <= idx:
+                    raise ClassiqInternalExpansionError(
+                        f"Illegal sliced handle {str(symbol[idx: stop].handle)!r}"
+                    )
+                symbol_parts.append(symbol[idx:stop])
+                idx = stop
+            else:
+                symbol_parts.extend(
+                    self._get_symbol_parts_unsafe(symbol[idx], target_parts)
+                )
+                idx += 1
+
+        return symbol_parts
+
+    def _get_struct_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        return list(
+            chain.from_iterable(
+                self._get_symbol_parts_unsafe(field_symbol, target_parts)
+                for field_symbol in symbol.fields.values()
+            )
+        )
+
+    @staticmethod
+    def get_bind_ops(symbol_parts: SymbolParts) -> list[BindOperation]:
+        return [
+            BindOperation(
+                in_handles=[symbol.handle],
+                out_handles=[part.target_var_handle for part in parts],
+            )
+            for symbol, parts in symbol_parts.items()
+        ]
+
+    @staticmethod
+    def get_var_decls(symbol_parts: SymbolParts) -> list[VariableDeclarationStatement]:
+        return [
+            VariableDeclarationStatement(
+                name=part.target_var_name,
+                quantum_type=part.target_var_type,
+            )
+            for part in chain.from_iterable(symbol_parts.values())
+        ]
+
+    def _check_all_handles_were_replaced(self, new_expr_str: str) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(new_expr_str))
+        for handle in self._get_handles(vrc):
+            if isinstance(handle, NestedHandleBinding):
+                raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
+
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
+        handle_replacements = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+
+        class ReplaceSplitVars(Transformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in handle_replacements.items():
+                    handle = handle.replace_prefix(handle_to_replace, replacement)
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._rewrite_expression(symbol_mapping, expr)
+
+        return ReplaceSplitVars().visit(subject)
+
+    def _rewrite_expression(
+        self,
+        symbol_mapping: SymbolParts,
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        handle_names = {
+            part.source_handle: part.target_var_name
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            collapsed_handle = handle.collapse()
+            if collapsed_handle in handle_names:
+                new_expr_str = new_expr_str.replace(
+                    str(handle), handle_names[collapsed_handle]
+                )
+        self._check_all_handles_were_replaced(new_expr_str)
+
+        return Expression(expr=new_expr_str)

classiq/qmod/builtins/classical_functions.py

@@ -1,5 +1,6 @@
 # This file was generated automatically - do not edit manually
 
+
 from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 

classiq/qmod/builtins/functions/state_preparation.py

@@ -415,7 +415,7 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
 @qfunc(external=True)
 def prepare_int(
     value: CInt,
-    out: Output[QNum[Literal["floor(log(value, 2)) + 1"], Literal[False], Literal[0]]],
+    out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],
 ) -> None:
     """
     [Qmod Classiq-library function]

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/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/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.57.0.dist-info}/METADATA

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