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

classiq/qmod/symbolic_expr.py

@@ -4,6 +4,8 @@ import ast
 from enum import Enum as PythonEnum
 from typing import Any
 
+import sympy
+
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
@@ -33,10 +35,14 @@ class SymbolicExpr(Symbolic):
 
     @staticmethod
     def _binary_op(lhs: Any, rhs: Any, op: str) -> SymbolicExpr:
-        if not isinstance(lhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            lhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {lhs!r} for binary operation {op!r}")
 
-        if not isinstance(rhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            rhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {rhs!r} for binary operation {op!r}")
 
         lhs_str = qmod_val_to_expr_str(lhs)
@@ -171,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/qmod/write_qmod.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
@@ -17,6 +17,8 @@ def write_qmod(
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+    *args: Any,
+    **kwargs: Any,
 ) -> None:
     """
     Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
@@ -27,6 +29,8 @@ def write_qmod(
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
+        args: (placeholder)
+        kwargs: (placeholder)
 
     Returns:
         None

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.74.0.dist-info → classiq-0.76.0.dist-info}/METADATA

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