classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/qmod/qmod_variable.py

@@ -1,5 +1,7 @@
 import abc
+import sys
 from contextlib import contextmanager
+from typing import _GenericAlias  # type: ignore[attr-defined]
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -14,6 +16,7 @@ from typing import (
     Union,
     get_args,
     get_origin,
+    overload,
 )
 
 from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
@@ -40,11 +43,13 @@ from classiq.interface.model.quantum_type import (
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.qmod_parameter import ArrayBase, QParam, QParamScalar
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.utilities import version_portable_get_args
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
 SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
+UNSUPPORTED_ELEMENT_TYPE = "Only QBit is supported as element type for QArray"
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -183,22 +188,72 @@ class QBit(QScalar):
         return QuantumBit()
 
 
-_T = TypeVar("_T")
+_P = ParamSpec("_P")
 
 
-class QNum(Generic[_T], QScalar):
+class QNum(Generic[_P], QScalar):
     QMOD_TYPE = QuantumNumeric
 
+    @overload
+    def __init__(self, name: str):
+        pass
+
+    @overload
+    def __init__(
+        self,
+        name: str,
+        size: Union[int, QParam[int]],
+        is_signed: Union[bool, QParam[bool]],
+        fraction_digits: Union[int, QParam[int]],
+    ):
+        pass
+
+    def __init__(
+        self,
+        name: str,
+        size: Union[int, QParam[int], None] = None,
+        is_signed: Union[bool, QParam[bool], None] = None,
+        fraction_digits: Union[int, QParam[int], None] = None,
+    ):
+        if (
+            size is None
+            and (is_signed is not None or fraction_digits is not None)
+            or size is not None
+            and (is_signed is None or fraction_digits is None)
+        ):
+            raise ClassiqValueError(
+                "Assign none or all of size, is_signed, and fraction_digits"
+            )
+        self._size = None if size is None else Expression(expr=str(size))
+        self._is_signed = None if is_signed is None else Expression(expr=str(is_signed))
+        self._fraction_digits = (
+            None if fraction_digits is None else Expression(expr=str(fraction_digits))
+        )
+        super().__init__(name)
+
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
-        size_expr: Optional[Expression] = None
-        if get_args(type_hint):
-            size_expr = Expression(expr=get_type_hint_expr(get_args(type_hint)[0]))
-
-        return cls.QMOD_TYPE(size=size_expr)
+        type_args = get_args(type_hint)
+        if len(type_args) == 0:
+            return cls.QMOD_TYPE()
+        type_args = type_args[0]
+        if len(type_args) != 3:
+            raise ClassiqValueError(
+                "QNum receives three type arguments: QNum[size: int | QParam[int], "
+                "is_signed: bool | QParam[bool], fraction_digits: int | QParam[int]]"
+            )
+        return cls.QMOD_TYPE(
+            size=Expression(expr=get_type_hint_expr(type_args[0])),
+            is_signed=Expression(expr=get_type_hint_expr(type_args[1])),
+            fraction_digits=Expression(expr=get_type_hint_expr(type_args[2])),
+        )
 
     def get_qmod_type(self) -> QuantumType:
-        return self.QMOD_TYPE()
+        return self.QMOD_TYPE(
+            size=self._size,
+            is_signed=self._is_signed,
+            fraction_digits=self._fraction_digits,
+        )
 
     @property
     def size(self) -> QParamScalar:
@@ -212,14 +267,27 @@ class QNum(Generic[_T], QScalar):
     def is_signed(self) -> QParamScalar:
         return QParamScalar(f"is_signed({self._name})")
 
+    # Support comma-separated generic args in older Python versions
+    if sys.version_info[0:2] < (3, 10):
 
-_P = ParamSpec("_P")
+        def __class_getitem__(cls, args) -> _GenericAlias:
+            return _GenericAlias(cls, args)
 
 
 class QArray(ArrayBase[_P], QVar):
-    def __init__(self, name: str, slice_: Optional[Tuple[int, int]] = None) -> None:
-        super().__init__(name)
+    def __init__(
+        self,
+        name: str,
+        element_type: _GenericAlias = QBit,
+        length: Optional[Union[int, QParam[int]]] = None,
+        slice_: Optional[Tuple[int, int]] = None,
+    ) -> None:
+        if element_type is not QBit:
+            raise ClassiqValueError(UNSUPPORTED_ELEMENT_TYPE)
+        self._element_type = element_type
+        self._length = length
         self._slice = slice_
+        super().__init__(name)
 
     def get_handle_binding(self) -> HandleBinding:
         if self._slice is None:
@@ -234,20 +302,30 @@ class QArray(ArrayBase[_P], QVar):
         offset = self._slice[0] if self._slice is not None else 0
         if isinstance(key, slice):
             if key.step is not None:
-                raise NotImplementedError(ILLEGAL_SLICING_STEP_MSG)
+                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
             new_slice = (offset + key.start, offset + key.stop)
         else:
             if isinstance(key, QParam) and not isinstance(key, QParamScalar):
                 raise ClassiqValueError("Non-classical parameter for slicing")
             new_slice = (offset + key, offset + key + 1)
-        if self._slice is not None and new_slice[1] > self._slice[1]:
+        if (
+            self._slice is not None
+            and not isinstance(new_slice[1], Symbolic)
+            and not isinstance(self._slice[1], Symbolic)
+            and new_slice[1] > self._slice[1]
+        ) or (
+            self._length is not None
+            and not isinstance(new_slice[1], Symbolic)
+            and not isinstance(self._length, Symbolic)
+            and new_slice[1] > self._length
+        ):
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
         # prevent addition to local handles, since this is used for slicing existing local handles
         with _no_current_expandable():
-            return QArray(self._name, slice_=new_slice)
+            return QArray(self._name, length=self._length, slice_=new_slice)
 
     def __len__(self) -> int:
-        raise ValueError(
+        raise ClassiqValueError(
             "len(<var>) is not supported for quantum variables - use <var>.len() instead"
         )
 
@@ -258,16 +336,22 @@ class QArray(ArrayBase[_P], QVar):
     else:
 
         def len(self) -> QParamScalar:
+            if self._length is not None:
+                return QParamScalar(f"{self._length}")
             return QParamScalar(f"len({self._name})")
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType:
         length_expr: Optional[Expression] = None
-        if len(get_args(type_hint)) == 2:
-            length_expr = Expression(expr=get_type_hint_expr(get_args(type_hint)[1]))
+        if len(version_portable_get_args(type_hint)) == 2:
+            length_expr = Expression(
+                expr=get_type_hint_expr(version_portable_get_args(type_hint)[1])
+            )
         return QuantumBitvector(length=length_expr)
 
     def get_qmod_type(self) -> QuantumType:
+        if self._length is not None:
+            return QuantumBitvector(length=Expression(expr=str(self._length)))
         return QuantumBitvector()
 
 

classiq/qmod/quantum_expandable.py

@@ -1,3 +1,4 @@
+import inspect
 from abc import ABC
 from types import TracebackType
 from typing import (
@@ -25,14 +26,16 @@ from classiq.interface.model.quantum_function_call import (
     ArgValue,
     OperandIdentifier,
     QuantumFunctionCall,
-    QuantumLambdaFunction,
-    QuantumOperand,
 )
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumLambdaFunction,
+    QuantumOperand,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -41,6 +44,7 @@ from classiq.interface.model.variable_declaration_statement import (
 
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
 from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
@@ -96,9 +100,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
         for arg in self.func_decl.get_positional_arg_decls():
             if isinstance(arg, ClassicalParameterDeclaration):
                 rename_dict = self.infer_rename_params()
-                actual_name = (
-                    rename_dict[arg.name] if arg.name in rename_dict else arg.name
-                )
+                actual_name = rename_dict.get(arg.name, arg.name)
                 result.append(
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
@@ -126,17 +128,12 @@ class QLambdaFunction(QExpandable):
         return self._decl
 
     def infer_rename_params(self) -> Dict[str, str]:
-        if not self._py_callable.__annotations__:
-            return {}
+        py_params = inspect.getfullargspec(self._py_callable)
+        decl_params = self.func_decl.param_decls.keys()
         return {
-            decl_name: actual_name
-            for decl_name, actual_name in list(
-                zip(
-                    [arg.name for arg in self.func_decl.get_positional_arg_decls()],
-                    self._py_callable.__annotations__.keys(),
-                )
-            )
-            if decl_name != actual_name
+            decl_param: py_param
+            for decl_param, py_param in zip(decl_params, py_params.args)
+            if decl_param != py_param
         }
 
 
@@ -163,7 +160,7 @@ class QTerminalCallable(QCallable):
         return QTerminalCallable(self._decl, key)
 
     def __len__(self) -> int:
-        raise ValueError(
+        raise ClassiqValueError(
             "len(<func>) is not supported for quantum callables - use <func>.len() instead (Only if it is an operand list)"
         )
 
@@ -205,6 +202,9 @@ def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue: ...
 
 
 def prepare_arg(arg_decl: PositionalArg, val: Any) -> ArgValue:
+    if isinstance(val, QConstant):
+        val.add_to_model()
+        return Expression(expr=str(val.name))
     if isinstance(arg_decl, ClassicalParameterDeclaration):
         return Expression(expr=str(val))
     elif isinstance(arg_decl, PortDeclaration):

classiq/qmod/quantum_function.py

@@ -1,3 +1,4 @@
+import ast
 import functools
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
@@ -13,6 +14,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
+from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
@@ -63,21 +65,23 @@ class QFunc(QExpandable):
     ) -> Model:
         self._qmodule.type_decls = dict()
         self._qmodule.native_defs = dict()
+        self._qmodule.constants = dict()
+        QConstant.set_current_model(self._qmodule)
         self._add_native_func_def()
         model_extra_settings: List[Tuple[str, Any]] = [
             ("constraints", constraints),
             ("execution_preferences", execution_preferences),
             ("preferences", preferences),
         ]
-        classical_execution_function = (
-            CFunc.default_cmain()
-            if classical_execution_function is None
-            else classical_execution_function
-        )
+        if classical_execution_function is not None:
+            self._add_constants_from_classical_code(classical_execution_function)
+            model_extra_settings.append(
+                ("classical_execution_code", classical_execution_function.code)
+            )
         return Model(
+            constants=list(self._qmodule.constants.values()),
             functions=list(self._qmodule.native_defs.values()),
             types=list(self._qmodule.type_decls.values()),
-            classical_execution_code=classical_execution_function.code,
             **{key: value for key, value in model_extra_settings if value},
         )
 
@@ -89,18 +93,43 @@ class QFunc(QExpandable):
             **self.func_decl.__dict__, body=self.body
         )
 
+    def _add_constants_from_classical_code(
+        self, classical_execution_function: CFunc
+    ) -> None:
+        # FIXME: https://classiq.atlassian.net/browse/CAD-18050
+        # We use this visitor to add the constants that were used in the classical
+        # execution code to the model. In the future, if we will have a better notion
+        # of "QModule" and a "QConstant" will be a part of it then we may be able to
+        # remove the handling of the QConstants from this visitor, but I think we will
+        # need similar logic to allow using python variables in the classical execution
+        # code
+        class IdentifierVisitor(ast.NodeVisitor):
+            def visit_Name(self, node: ast.Name) -> None:
+                if (
+                    node.id in classical_execution_function._caller_constants
+                    and isinstance(
+                        classical_execution_function._caller_constants[node.id],
+                        QConstant,
+                    )
+                ):
+                    classical_execution_function._caller_constants[
+                        node.id
+                    ].add_to_model()
+
+        IdentifierVisitor().visit(ast.parse(classical_execution_function.code))
+
 
 class ExternalQFunc(QTerminalCallable):
     def __init__(self, py_callable: Callable) -> None:
         decl = _lookup_qfunc(unmangle_keyword(py_callable.__name__))
         if decl is None:
-            raise ValueError(f"Definition of {py_callable.__name__!r} not found")
+            raise ClassiqError(f"Definition of {py_callable.__name__!r} not found")
 
         py_callable.__annotations__.pop("return", None)
         if py_callable.__annotations__.keys() != {
             mangle_keyword(arg.name) for arg in decl.get_positional_arg_decls()
         }:
-            raise ValueError(
+            raise ClassiqError(
                 f"Parameter type hints for {py_callable.__name__!r} do not match imported declaration"
             )
         super().__init__(decl)

classiq/qmod/symbolic.py

@@ -1,7 +1,10 @@
 import sys
-from typing import Tuple
+from typing import Optional, Tuple, Type, get_args, get_origin, overload
 
-from classiq.qmod.qmod_parameter import QParamScalar
+from classiq.exceptions import ClassiqValueError
+from classiq.qmod import model_state_container
+from classiq.qmod.declaration_inferrer import python_type_to_qmod
+from classiq.qmod.qmod_parameter import QParam, QParamScalar, create_param
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -13,9 +16,44 @@ EulerGamma = SymbolicExpr("EulerGamma")
 Catalan = SymbolicExpr("Catalan")
 
 
-def symbolic_function(*args: SymbolicTypes) -> QParamScalar:
+@overload
+def symbolic_function(
+    *args: SymbolicTypes, return_type: None = None
+) -> QParamScalar: ...
+
+
+@overload
+def symbolic_function(*args: SymbolicTypes, return_type: Type[QParam]) -> QParam: ...
+
+
+def symbolic_function(
+    *args: SymbolicTypes, return_type: Optional[Type[QParam]] = None
+) -> QParam:
+    qmodule = (
+        model_state_container.QMODULE
+    )  # FIXME: https://classiq.atlassian.net/browse/CAD-15126
     str_args = [str(x) for x in args]
-    return QParamScalar(f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})")
+    expr = f"{sys._getframe(1).f_code.co_name}({','.join(str_args)})"
+
+    if return_type is None:
+        return QParamScalar(expr)
+
+    if get_origin(return_type) is not QParam:
+        raise ClassiqValueError(
+            f"Unsupported return type for symbolic function: {return_type}"
+        )
+
+    qmod_type = python_type_to_qmod(get_args(return_type)[0], qmodule=qmodule)
+    if qmod_type is None:
+        raise ClassiqValueError(
+            f"Unsupported return type for symbolic function: {return_type}"
+        )
+
+    return create_param(
+        expr,
+        qmod_type,
+        qmodule,
+    )
 
 
 def sin(x: SymbolicTypes) -> QParamScalar:
@@ -238,6 +276,10 @@ def logical_not(x: SymbolicTypes) -> SymbolicExpr:
     return SymbolicExpr._unary_op(x, "not")
 
 
+def mod_inverse(a: SymbolicTypes, m: SymbolicTypes) -> QParamScalar:
+    return symbolic_function(a, m)
+
+
 __all__ = [
     "pi",
     "E",
@@ -300,6 +342,7 @@ __all__ = [
     "logical_and",
     "logical_or",
     "logical_not",
+    "mod_inverse",
 ]
 
 

classiq/qmod/symbolic_expr.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ast
 from typing import Any
 
 
@@ -13,6 +14,14 @@ class Symbolic:
     def __repr__(self) -> str:
         return self._expr
 
+    def __bool__(self) -> bool:
+        try:
+            return bool(ast.literal_eval(self._expr))
+        except ValueError:
+            raise TypeError(
+                f"Symbolic expression {self._expr!r} cannot be converted to bool"
+            ) from None
+
 
 class SymbolicExpr(Symbolic):
     def __init__(self, expr: str) -> None:

classiq/qmod/utilities.py

@@ -1,4 +1,8 @@
 import keyword
+import sys
+from typing import get_args, get_origin
+
+DEFAULT_DECIMAL_PRECISION = 4
 
 
 def mangle_keyword(name: str) -> str:
@@ -12,3 +16,12 @@ def unmangle_keyword(name: str) -> str:
     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):
+        return get_args(py_type)  # The result of __class_getitem__
+    else:
+        return get_args(py_type)[0]

classiq/qmod/write_qmod.py

@@ -0,0 +1,39 @@
+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:
+    model = Model.parse_raw(serialized_model)
+    pretty_printed_model = DSLPrettyPrinter(decimal_precision=decimal_precision).visit(
+        model
+    )
+
+    synthesis_options = model.dict(
+        include={"constraints", "preferences"}, exclude_unset=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/quantum_functions/__init__.py

@@ -1,4 +1,4 @@
-from classiq.quantum_functions.decorators import quantum_function as qfunc
+from classiq.quantum_functions.decorators import quantum_function
 from classiq.quantum_functions.function_library import (
     QASM3_INTRO,
     QASM_INTRO,
@@ -8,7 +8,7 @@ from classiq.quantum_functions.function_library import (
 )
 
 __all__ = [
-    "qfunc",
+    "quantum_function",
     "QASM_INTRO",
     "QASM3_INTRO",
     "FunctionLibrary",

classiq/quantum_functions/annotation_parser.py

@@ -1,4 +1,4 @@
-# type: ignore
+# type: ignore  # noqa: PGH003
 # We can either ignore each line individually, or ignore the entire file and wait until mypy can ignore
 # specific errors per-file.
 import inspect
@@ -77,18 +77,16 @@ class AnnotationParser:
             self.input_names, self.input_values, self.output_values
         ):
             # Is arithmetic QReg
-            if issubclass(input_type.__origin__, QSFixed):
-                if input_type != output_type:
-                    raise ClassiqQFuncError(
-                        f"Arithmetic QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
-                    )
+            if issubclass(input_type.__origin__, QSFixed) and input_type != output_type:
+                raise ClassiqQFuncError(
+                    f"Arithmetic QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
+                )
 
             # Is Auxillary QReg
-            if issubclass(input_type.__origin__, AuxQReg):
-                if input_type != output_type:
-                    raise ClassiqQFuncError(
-                        f"Auxillary QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
-                    )
+            if issubclass(input_type.__origin__, AuxQReg) and input_type != output_type:
+                raise ClassiqQFuncError(
+                    f"Auxillary QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
+                )
 
             # Is Zero QReg
             if input_type.__origin__ is ZeroQReg:

classiq/quantum_functions/function_parser.py

@@ -36,7 +36,7 @@ class FunctionParser:
     def _validate_function_output(output: Any) -> None:
         # Todo: validate QASM
 
-        if type(output) is not str:
+        if not isinstance(output, str):
             raise ClassiqQFuncError(
                 "Invalid output. Please return a string of OpenQASM2.0."
             )

classiq/quantum_functions/quantum_function.py

@@ -1,7 +1,7 @@
 import sys
 from abc import ABC, abstractmethod
 from types import FunctionType
-from typing import Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from classiq.interface.generator.functions import (
     FunctionImplementation,
@@ -213,7 +213,7 @@ class QuantumFunctionFactory(ABC):
         )
         return "_".join(str_list)
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         try:
             return self._apply_method(str(self), *args, **kwargs)
         except AttributeError as e:
@@ -227,7 +227,7 @@ class QuantumFunctionFactory(ABC):
         """
         Abstract method for providing the definition of the user function.
         The QuantumFunction object may be generated either directly, or using existing
-        helper tools such as the @qfunc decorator.
+        helper tools such as the @quantum_function decorator.
         Instance attributes of the QuantumFunctionFactory may be used as parameters for the
         definition.