classiq 0.67.0__py3-none-any.whl → 0.69.0__py3-none-any.whl

classiq/qmod/cparam.py

@@ -1,4 +1,5 @@
 import sys
+from abc import ABC, abstractmethod
 from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
@@ -9,6 +10,8 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
 if TYPE_CHECKING:
@@ -21,18 +24,34 @@ else:
 
 class CParam(SymbolicSuperclass):
     def __init__(self, expr: str) -> None:
-        super().__init__(expr, False)
+        super().__init__(expr, is_quantum=False)
+
+
+class CParamAbstract(ABC, CParam):
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "CParamAbstract":
+        raise ClassiqValueError(
+            f"{cls.__name__} is a Qmod type hint for a classical parameter and it cannot be instantiated. "
+            f"Use regular Pythonic values as arguments instead. "
+            f"Example:\n\n"
+            f"def foo(val: {cls.__name__}) -> None: ...\n\n"
+            f"foo({_EXAMPLE_VALUES[cls.__name__]})  # Correct\n"
+        )
 
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
 
-class CInt(CParam):
+
+class CInt(CParamAbstract):
     pass
 
 
-class CReal(CParam):
+class CReal(CParamAbstract):
     pass
 
 
-class CBool(CParam):
+class CBool(CParamAbstract):
     pass
 
 
@@ -47,7 +66,7 @@ class ArrayBase(Generic[_P]):
             return _GenericAlias(cls, args)
 
 
-class CArray(CParam, ArrayBase[_P]):
+class CArray(CParamAbstract, ArrayBase[_P]):
     if TYPE_CHECKING:
 
         @property
@@ -62,3 +81,11 @@ Array = CArray
 class CParamScalar(CParam, SymbolicExpr):
     def __hash__(self) -> int:
         return hash(str(self))
+
+
+_EXAMPLE_VALUES: dict[str, Any] = {
+    CInt.__name__: 1,
+    CReal.__name__: 1.0,
+    CBool.__name__: True,
+    CArray.__name__: [1, 2],
+}

classiq/qmod/python_classical_type.py

@@ -30,16 +30,22 @@ CARRAY_ERROR_MESSAGE = (
 
 class PythonClassicalType:
     def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
-        if py_type is int or py_type is CInt:
+        if py_type is int:
+            return Integer().set_generative()
+        elif py_type is CInt:
             return Integer()
-        elif py_type in (float, complex) or py_type is CReal:
+        elif py_type in (float, complex):
+            return Real().set_generative()
+        elif py_type is CReal:
             return Real()
-        elif py_type is bool or py_type is CBool:
+        elif py_type is bool:
+            return Bool().set_generative()
+        elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
             element_type = self.convert(get_args(py_type)[0])
             if element_type is not None:
-                return ClassicalList(element_type=element_type)
+                return ClassicalList(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:

classiq/qmod/quantum_callable.py

@@ -21,7 +21,7 @@ from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.cparam import CInt
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import get_source_ref, suppress_return_value
 
 if TYPE_CHECKING:
     from classiq.qmod.quantum_expandable import QTerminalCallable
@@ -48,6 +48,7 @@ class QCallable(Generic[P], ABC):
     CURRENT_EXPANDABLE: ClassVar[Optional[QExpandableInterface]] = None
     FRAME_DEPTH = 1
 
+    @suppress_return_value
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         assert QCallable.CURRENT_EXPANDABLE is not None
         source_ref = get_source_ref(sys._getframe(self.FRAME_DEPTH))

classiq/qmod/quantum_expandable.py

@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC
+from collections.abc import Generator, Iterable
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
 from types import TracebackType
@@ -67,7 +68,10 @@ from classiq.qmod.qmod_variable import (
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.type_attribute_remover import decl_without_type_attributes
-from classiq.qmod.utilities import mangle_keyword, qmod_val_to_expr_str
+from classiq.qmod.utilities import (
+    mangle_keyword,
+    qmod_val_to_expr_str,
+)
 
 ArgType = Union[CParam, QVar, QCallable]
 
@@ -371,11 +375,14 @@ def prepare_arg(
 def _validate_classical_arg(
     arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
 ) -> None:
-    is_native_or_compatible_type = not isinstance(
-        arg, (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
-    ) and not is_dataclass(
-        arg
-    )  # type: ignore[unreachable]
+    is_native_or_compatible_type = (
+        not isinstance(
+            arg,
+            (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum),
+        )
+        and not _is_legal_iterable(arg)
+        and not is_dataclass(arg)  # type: ignore[unreachable]
+    )
     try:
         is_pydantic_classical_type = isinstance(
             arg, pydantic.BaseModel
@@ -481,3 +488,20 @@ def _create_quantum_function_call(
     return QuantumFunctionCall(
         function=function_ident, positional_args=prepared_args, source_ref=source_ref_
     )
+
+
+_FORBIDDEN_ITERABLES = (set, dict, str, Generator)
+
+
+def _is_legal_iterable(arg: Any) -> bool:
+    if not isinstance(arg, Iterable) or isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    return all(_is_legal_iterable_element(e) for e in arg)
+
+
+def _is_legal_iterable_element(arg: Any) -> bool:
+    if isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    if isinstance(arg, Iterable):
+        return all(_is_legal_iterable_element(e) for e in arg)
+    return True

classiq/qmod/quantum_function.py

@@ -24,10 +24,11 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 from classiq.qmod.classical_function import CFunc
+from classiq.qmod.cparam import CParamAbstract
 from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray, CParam
+from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
@@ -308,7 +309,7 @@ def _validate_no_gen_params(annotations: dict[str, Any]) -> None:
         for name, annotation in annotations.items()
         if not (
             name == "return"
-            or (isclass(annotation) and issubclass(annotation, CParam))
+            or (isclass(annotation) and issubclass(annotation, CParamAbstract))
             or (isclass(annotation) and is_dataclass(annotation))
             or (isclass(annotation) and isinstance(annotation, EnumMeta))
             or get_origin(annotation) is CArray

classiq/qmod/semantics/error_manager.py

@@ -46,7 +46,7 @@ class ErrorManager:
         error: str,
         *,
         source_ref: Optional[SourceReference] = None,
-        function: Optional[str] = None
+        function: Optional[str] = None,
     ) -> None:
         if not self._ignore_errors:
             self._errors.append(

classiq/qmod/semantics/validation/types_validation.py

@@ -16,7 +16,7 @@ TYPE_EXISTS_ERROR_MESSAGE = "Type {!r} already exists"
 
 
 def check_duplicate_types(
-    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]
+    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]],
 ) -> None:
     known_types = {type_.name for type_ in BUILTIN_ENUM_DECLARATIONS.values()}
     known_types |= {type_.name for type_ in BUILTIN_STRUCT_DECLARATIONS.values()}

classiq/qmod/symbolic.py

@@ -1,4 +1,5 @@
 import sys
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -296,7 +297,7 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
 
 
 def subscript(
-    amplitudes: Union[list[float], list[CReal], list[CParamScalar], CArray[CReal]],
+    amplitudes: Union[Sequence[Union[float, CReal, CParamScalar]], CArray[CReal]],
     index: QNum,
 ) -> CParamScalar:
     return CParamScalar(expr=f"{amplitudes}[{index}]")

classiq/qmod/utilities.py

@@ -3,15 +3,32 @@ import inspect
 import itertools
 import keyword
 import sys
+from collections.abc import Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
-from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ForwardRef,
+    Literal,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+    overload,
+)
+
+from typing_extensions import ParamSpec
 
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.source_reference import SourceReference
 
+if TYPE_CHECKING:
+    from classiq.qmod.qmod_variable import QVar
+
 DEFAULT_DECIMAL_PRECISION = 4
 
 
@@ -101,7 +118,7 @@ def qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({val.struct_declaration.name}, {kwargs_str})"
 
-    if isinstance(val, list):
+    if isinstance(val, Iterable):
         elements_str = ", ".join([qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"
 
@@ -131,3 +148,15 @@ def varname(depth: int) -> Optional[str]:
     if not var_name.isidentifier():
         return None
     return var_name
+
+
+Params = ParamSpec("Params")
+
+
+def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None]:
+    # An empty decorator suppresses mypy's func-returns-value error when assigning the
+    # return value of a None-returning function
+    return func
+
+
+Statements = Union[None, list[Union[None, "QVar"]], tuple[Union[None, "QVar"], ...]]

classiq/qmod/write_qmod.py

@@ -1,10 +1,11 @@
 import json
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
 from classiq.qmod.native.pretty_printer import DSLPrettyPrinter
+from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 _QMOD_SUFFIX = "qmod"
@@ -12,7 +13,7 @@ _SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"
 
 
 def write_qmod(
-    serialized_model: SerializedModel,
+    model: Union[SerializedModel, QFunc, GenerativeQFunc],
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
@@ -22,7 +23,7 @@ def write_qmod(
     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.
+        model: The entry point of the Qmod model - a qfunc named 'main' (or alternatively the output of 'create_model').
         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.
@@ -30,13 +31,15 @@ def write_qmod(
     Returns:
         None
     """
-
-    model = Model.model_validate_json(serialized_model)
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        model_obj = model.create_model()
+    else:
+        model_obj = Model.model_validate_json(model)
     pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
-        model
+        model_obj
     )
 
-    synthesis_options = model.model_dump(
+    synthesis_options = model_obj.model_dump(
         include={"constraints", "preferences"}, exclude_none=True
     )
 

classiq/synthesis.py

@@ -1,17 +1,18 @@
-from typing import Any, NewType, Optional
+from typing import Any, NewType, Optional, Union
 
 import pydantic
 
 from classiq.interface.analyzer.result import QasmCode
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqError, 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.model import Model, SerializedModel
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
 
 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)
 
@@ -69,19 +70,34 @@ async def synthesize_async(
 
 
 def synthesize(
-    serialized_model: SerializedModel, auto_show: bool = False
+    model: Union[SerializedModel, QFunc, GenerativeQFunc],
+    auto_show: bool = False,
+    constraints: Optional[Constraints] = None,
+    preferences: Optional[Preferences] = None,
 ) -> 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
+        model: The entry point of the Qmod model - a qfunc named 'main' (or alternatively the output of 'create_model').
+        auto_show: Whether to 'show' the synthesized model (False by default).
+        constraints: Constraints for the synthesis of the model. See Constraints (Optional).
+        preferences: Preferences for the synthesis of the model. See Preferences (Optional).
 
     Returns:
         SerializedQuantumProgram: Quantum program serialized as a string. (See: QuantumProgram)
     """
+    if isinstance(model, (QFunc, GenerativeQFunc)):
+        func_name = model._py_callable.__name__
+        if func_name != MAIN_FUNCTION_NAME:
+            raise ClassiqError(
+                f"The entry point function must be named 'main', got {func_name!r}"
+            )
+        model_obj = model.create_model(constraints=constraints, preferences=preferences)
+        serialized_model = model_obj.get_model()
+    else:
+        serialized_model = model
     result = async_utils.run(synthesize_async(serialized_model))
     if auto_show:
         show(result)
@@ -91,7 +107,7 @@ def synthesize(
 def set_preferences(
     serialized_model: SerializedModel,
     preferences: Optional[Preferences] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the preferences of a (serialized) model and returns the updated model.
@@ -139,7 +155,7 @@ def update_preferences(
 def set_constraints(
     serialized_model: SerializedModel,
     constraints: Optional[Constraints] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the constraints of a (serialized) model and returns the updated model.
@@ -187,7 +203,7 @@ def update_constraints(
 def set_execution_preferences(
     serialized_model: SerializedModel,
     execution_preferences: Optional[ExecutionPreferences] = None,
-    **kwargs: Any
+    **kwargs: Any,
 ) -> SerializedModel:
     """
     Overrides the execution preferences of a (serialized) model and returns the updated model.

{classiq-0.67.0.dist-info → classiq-0.69.0.dist-info}/METADATA

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