classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/qmod/symbolic_type.py

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

classiq/qmod/type_attribute_remover.py

@@ -0,0 +1,32 @@
+from classiq.interface.generator.visitor import Transformer
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+
+
+def decl_without_type_attributes(
+    operand_declaration: AnonQuantumOperandDeclaration,
+) -> AnonQuantumOperandDeclaration:
+    remover = AttributeRemover()
+    return operand_declaration.model_copy(
+        update=dict(
+            positional_arg_declarations=[
+                remover.visit(arg) if isinstance(arg, PortDeclaration) else arg
+                for arg in operand_declaration.positional_arg_declarations
+            ]
+        )
+    )
+
+
+class AttributeRemover(Transformer):
+    """Remove attributes that could be expressions such as length, fraction places, etc."""
+
+    def visit_QuantumNumeric(self, node: QuantumNumeric) -> QuantumNumeric:
+        return QuantumNumeric(source_ref=node.source_ref)
+
+    def visit_QuantumBitvector(self, node: QuantumBitvector) -> QuantumBitvector:
+        return QuantumBitvector(
+            element_type=self.visit(node.element_type), source_ref=node.source_ref
+        )

classiq/qmod/utilities.py

@@ -1,4 +1,15 @@
+import dataclasses
+import inspect
+import itertools
 import keyword
+import sys
+from enum import Enum as PythonEnum
+from types import FrameType
+from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
+
+from classiq.interface.source_reference import SourceReference
+
+DEFAULT_DECIMAL_PRECISION = 4
 
 
 def mangle_keyword(name: str) -> str:
@@ -7,8 +18,104 @@ def mangle_keyword(name: str) -> str:
     return name
 
 
+@overload
 def unmangle_keyword(name: str) -> str:
-    assert name
+    pass
+
+
+@overload
+def unmangle_keyword(name: None) -> None:
+    pass
+
+
+def unmangle_keyword(name: Optional[str]) -> Optional[str]:
+    if name is None:
+        return None
     if name[-1] == "_" and keyword.iskeyword(name[:-1]):
         name = name[:-1]
     return name
+
+
+def version_portable_get_args(py_type: type) -> tuple:
+    if get_origin(py_type) is None:
+        return tuple()
+    if sys.version_info[0:2] < (3, 10):
+        type_args = get_args(py_type)  # The result of __class_getitem__
+    else:
+        type_args = get_args(py_type)[0]
+    if not isinstance(type_args, tuple):
+        return (type_args,)
+    return tuple(
+        (
+            version_portable_get_args(type_arg)[0]
+            if get_origin(type_arg) == Literal
+            else type_arg
+        )
+        for type_arg in type_args
+    )
+
+
+def get_source_ref(frame: FrameType) -> SourceReference:
+    filename = inspect.getfile(frame)
+    lineno = frame.f_lineno
+    if sys.version_info[0:2] < (3, 11) or frame.f_lasti < 0:
+        source_ref = SourceReference(
+            file_name=filename,
+            start_line=lineno - 1,
+            start_column=-1,
+            end_line=-1,
+            end_column=-1,
+        )
+    else:
+        positions_gen = frame.f_code.co_positions()
+        positions = next(itertools.islice(positions_gen, frame.f_lasti // 2, None))
+        source_ref = SourceReference(
+            file_name=filename,
+            start_line=(positions[0] or 0) - 1,
+            start_column=(positions[2] or 0) - 1,
+            end_line=(positions[1] or 0) - 1,
+            end_column=(positions[3] or 0) - 1,
+        )
+    return source_ref
+
+
+def qmod_val_to_expr_str(val: Any) -> str:
+    if dataclasses.is_dataclass(type(val)):
+        kwargs_str = ", ".join(
+            [
+                f"{field.name}={qmod_val_to_expr_str(vars(val)[field.name])}"
+                for field in dataclasses.fields(val)
+            ]
+        )
+        return f"struct_literal({type(val).__name__}, {kwargs_str})"
+
+    if isinstance(val, list):
+        elements_str = ", ".join([qmod_val_to_expr_str(elem) for elem in val])
+        return f"[{elements_str}]"
+
+    if isinstance(val, PythonEnum):
+        return f"{type(val).__name__}.{val.name}"
+
+    return str(val)
+
+
+def unwrap_forward_ref(x: Any) -> Any:
+    if isinstance(x, ForwardRef):
+        return x.__forward_arg__
+    return x
+
+
+def varname(depth: int) -> Optional[str]:
+    frame = sys._getframe(depth)
+    codes = inspect.getframeinfo(frame).code_context
+    if codes is None or len(codes) != 1:
+        return None
+    code = codes[0]
+    if "=" not in code:
+        return None
+    var_name = code.split("=")[0].strip()
+    if ":" in var_name:
+        var_name = var_name.split(":")[0].strip()
+    if not var_name.isidentifier():
+        return None
+    return var_name

classiq/qmod/write_qmod.py

@@ -0,0 +1,53 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+from classiq.interface.model.model import Model, SerializedModel
+
+from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
+from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+
+_QMOD_SUFFIX = "qmod"
+_SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"
+
+
+def write_qmod(
+    serialized_model: SerializedModel,
+    name: str,
+    directory: Optional[Path] = None,
+    decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+) -> None:
+    """
+    Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
+    The native Qmod file may be uploaded to the Classiq IDE.
+
+    Args:
+        serialized_model: The serialized model to write as a native Qmod file and synthesis options file.
+        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.
+
+    Returns:
+        None
+    """
+
+    model = Model.model_validate_json(serialized_model)
+    pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
+        model
+    )
+
+    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:
+        synthesis_options_path = directory / synthesis_options_path
+
+    synthesis_options_path.write_text(json.dumps(synthesis_options, indent=2))
+
+    native_qmod_path = Path(f"{name}.{_QMOD_SUFFIX}")
+    if directory is not None:
+        native_qmod_path = directory / native_qmod_path
+
+    native_qmod_path.write_text(pretty_printed_model)

classiq/synthesis.py

@@ -1,59 +1,247 @@
-from typing import NewType
+from typing import Any, NewType, Optional
 
 import pydantic
 
+from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.exceptions import ClassiqValueError
 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.common_model_types import ModelInput, SerializedModelInput
-from classiq.interface.model.model import SerializedModel
+from classiq.interface.model.model import Model, SerializedModel
 
+from classiq import QuantumProgram
+from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
 
 SerializedQuantumProgram = NewType("SerializedQuantumProgram", str)
 
+CANT_PARSE_QUANTUM_PROGRAM_MSG = (
+    "Can not parse quantum_program into GeneratedCircuit, \n"
+)
+
+
+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/)
+    """
+    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]
+
+
+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())
+
+
+def quantum_program_from_qasm(qasm: str) -> SerializedQuantumProgram:
+    """
+    generate a quantum program from a QASM file.
+
+    Args:
+        qasm: A QASM2/3 string.
+
+    Returns:
+        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+    """
+    return async_utils.run(quantum_program_from_qasm_async(qasm))
+
 
 async def synthesize_async(
-    serialized_model: SerializedModelInput,
+    serialized_model: SerializedModel,
 ) -> SerializedQuantumProgram:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    model = Model.model_validate_json(serialized_model)
     quantum_program = await ApiWrapper.call_generation_task(model)
-    return SerializedQuantumProgram(quantum_program.json(indent=2))
+    return SerializedQuantumProgram(quantum_program.model_dump_json(indent=2))
+
+
+def synthesize(
+    serialized_model: SerializedModel, auto_show: bool = False
+) -> SerializedQuantumProgram:
+    """
+    Synthesize a model with the Classiq engine to receive a quantum program.
+    [More details](https://docs.classiq.io/latest/reference-manual/synthesis/)
 
+    Args:
+        serialized_model: A model object serialized as a string.
+        auto_show: boolean. whether to call `show` on the output
 
-synthesize = syncify_function(synthesize_async)
+    Returns:
+        SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
+    """
+    result = async_utils.run(synthesize_async(serialized_model))
+    if auto_show:
+        show(result)
+    return result
 
 
 def set_preferences(
-    serialized_model: SerializedModelInput, preferences: Preferences
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel,
+    preferences: Optional[Preferences] = None,
+    **kwargs: Any
+) -> SerializedModel:
+    """
+    Overrides the preferences of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: The model in serialized form.
+        preferences: The new preferences to be set for the model. Can be passed as keyword arguments.
+
+    Returns:
+        SerializedModel: The updated model with the new preferences applied.
+    """
+    if preferences is None:
+        if kwargs:
+            preferences = Preferences(**kwargs)
+        else:
+            raise ClassiqValueError(
+                "Missing preferences. Either pass `Preferences` object or pass keywords"
+            )
+
+    model = Model.model_validate_json(serialized_model)
     model.preferences = preferences
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
+
+
+def update_preferences(
+    serialized_model: SerializedModel, **kwargs: Any
+) -> SerializedModel:
+    """
+    Updates the preferences of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: The model in serialized form.
+        kwargs: key-value combination of preferences fields to update
+
+    Returns:
+        SerializedModel: The updated model with the new preferences applied.
+    """
+    model = Model.model_validate_json(serialized_model)
+
+    for key, value in kwargs.items():
+        setattr(model.preferences, key, value)
+    return model.get_model()
 
 
 def set_constraints(
-    serialized_model: SerializedModelInput, constraints: Constraints
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel,
+    constraints: Optional[Constraints] = None,
+    **kwargs: Any
+) -> SerializedModel:
+    """
+    Overrides the constraints of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: The model in serialized form.
+        constraints: The new constraints to be set for the model. Can be passed as keyword arguments.
+
+    Returns:
+        SerializedModel: The updated model with the new constraints applied.
+    """
+    if constraints is None:
+        if kwargs:
+            constraints = Constraints(**kwargs)
+        else:
+            raise ClassiqValueError(
+                "Missing constraints. Either pass `Constraints` object or pass keywords"
+            )
+
+    model = Model.model_validate_json(serialized_model)
     model.constraints = constraints
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
+
+
+def update_constraints(
+    serialized_model: SerializedModel, **kwargs: Any
+) -> SerializedModel:
+    """
+    Updates the constraints of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: The model in serialized form.
+        kwargs: key-value combination of constraints fields to update
+
+    Returns:
+        SerializedModel: The updated model with the new constraints applied.
+    """
+    model = Model.model_validate_json(serialized_model)
+
+    for key, value in kwargs.items():
+        setattr(model.constraints, key, value)
+    return model.get_model()
 
 
 def set_execution_preferences(
-    serialized_model: SerializedModelInput, execution_preferences: ExecutionPreferences
-) -> SerializedModelInput:
-    model: ModelInput = pydantic.parse_raw_as(ModelInput, serialized_model)  # type: ignore[arg-type]
+    serialized_model: SerializedModel,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+    **kwargs: Any
+) -> SerializedModel:
+    """
+    Overrides the execution preferences of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: A serialization of the defined model.
+        execution_preferences: The new execution preferences to be set for the model. Can be passed as keyword arguments.
+    Returns:
+        SerializedModel: The model with the attached execution preferences.
+
+    For more examples please see: [set_execution_preferences](https://docs.classiq.io/latest/reference-manual/executor/?h=set_execution_preferences#usage)
+    """
+    if execution_preferences is None:
+        if kwargs:
+            execution_preferences = ExecutionPreferences(**kwargs)
+        else:
+            raise ClassiqValueError(
+                "Missing execution_preferences. Either pass `ExecutionPreferences` object or pass keywords"
+            )
+
+    model = Model.model_validate_json(serialized_model)
     model.execution_preferences = execution_preferences
-    return model.get_model()  # type: ignore[return-value]
+    return model.get_model()
+
+
+def update_execution_preferences(
+    serialized_model: SerializedModel, **kwargs: Any
+) -> SerializedModel:
+    """
+    Updates the execution_preferences of a (serialized) model and returns the updated model.
+
+    Args:
+        serialized_model: The model in serialized form.
+        kwargs: key-value combination of execution_preferences fields to update
+
+    Returns:
+        SerializedModel: The updated model with the new execution_preferences applied.
+    """
+    model = Model.model_validate_json(serialized_model)
+
+    for key, value in kwargs.items():
+        setattr(model.execution_preferences, key, value)
+
+    return model.get_model()
 
 
 __all__ = [
     "SerializedModel",
     "SerializedQuantumProgram",
-    "synthesize",
-    "set_preferences",
     "set_constraints",
     "set_execution_preferences",
+    "set_preferences",
+    "synthesize",
+    "update_constraints",
+    "update_execution_preferences",
+    "update_preferences",
 ]

{classiq-0.37.1.dist-info → classiq-0.65.3.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.37.1
+Version: 0.65.3
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies
 Author-email: support@classiq.io
-Requires-Python: >=3.8,<3.12
+Requires-Python: >=3.9,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -16,10 +16,10 @@ Classifier: License :: Other/Proprietary License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
@@ -31,21 +31,29 @@ Provides-Extra: analyzer-sdk
 Provides-Extra: qml
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.5,<6.6)
+Requires-Dist: black (>=24.0,<25.0)
 Requires-Dist: httpx (>=0.23.0,<1)
 Requires-Dist: ipywidgets (>=7.7.1,<8.0.0) ; extra == "analyzer-sdk"
+Requires-Dist: jupyterlab (>=4.2.5,<5.0.0) ; extra == "analyzer-sdk"
 Requires-Dist: keyring (>=23.5.0,<24.0.0)
 Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
+Requires-Dist: notebook (>=7.2.2,<8.0.0) ; extra == "analyzer-sdk"
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
-Requires-Dist: numpy (>=1.20.1,<2.0.0)
-Requires-Dist: packaging (>=21.3,<22.0)
-Requires-Dist: pandas (>=1.4.0,<2.0.0)
+Requires-Dist: numpy (>=1.20.1,<2.0.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=1.26.0,<2.0.0) ; python_version >= "3.12"
+Requires-Dist: packaging (>=23.2,<24.0)
+Requires-Dist: pandas (>=1.4.0,<3.0.0)
 Requires-Dist: plotly (>=5.7.0,<6.0.0)
-Requires-Dist: pydantic (>=1.9.1,<2.0.0)
-Requires-Dist: sympy (>=1.9.0,<1.11.0)
+Requires-Dist: pydantic (>=2.9.0,<2.10.0)
+Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
+Requires-Dist: scipy (>=1.10.0,<2.0.0) ; python_version < "3.12"
+Requires-Dist: scipy (>=1.11.0,<2.0.0) ; python_version >= "3.12"
+Requires-Dist: sympy (>=1.13.0,<2.0.0)
 Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch (>=2.0,<3.0) ; extra == "qml"
 Requires-Dist: torchvision (>=0.15,<1.0) ; extra == "qml"
+Requires-Dist: tqdm (>=4.67.1,<5.0.0)
 Project-URL: Documentation, https://docs.classiq.io/
 Description-Content-Type: text/markdown