classiq 0.44.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -14,6 +14,7 @@ from typing import (
     overload,
 )
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -40,7 +41,6 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg

classiq/qmod/classical_function.py

@@ -4,7 +4,7 @@ import sys
 from textwrap import dedent
 from typing import Any, Callable, Dict
 
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 
 
 def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:

classiq/qmod/declaration_inferrer.py

@@ -6,6 +6,7 @@ from typing import (
     Any,
     Callable,
     List,
+    Literal,
     Optional,
     Sequence,
     Tuple,
@@ -17,6 +18,7 @@ from typing import (
 
 from typing_extensions import _AnnotatedAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
@@ -45,7 +47,6 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 from classiq import Struct, StructDeclaration
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
@@ -165,12 +166,13 @@ def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
             return None, py_type
         elif isinstance(args[1], str):
             return args[1], args[0]
-    elif (
-        len(args) == 3
-        and isinstance(args[1], PortDeclarationDirection)
-        and isinstance(args[2], str)
-    ):
-        return args[2], Annotated[args[0], args[1]]
+        elif get_origin(args[1]) is Literal:
+            return version_portable_get_args(args[1])[0], args[0]
+    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
+        if isinstance(args[2], str):
+            return args[2], Annotated[args[0], args[1]]
+        elif get_origin(args[2]) is Literal:
+            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
     raise ClassiqValueError(
         f"Operand parameter declaration must be of the form <param-type> or "
         f"Annotated[<param-type>, <param-name>]. Got {py_type}"

classiq/qmod/qmod_constant.py

@@ -2,6 +2,7 @@ import inspect
 from dataclasses import is_dataclass
 from typing import Any, Optional
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
@@ -9,7 +10,6 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
 )
 
-from classiq.exceptions import ClassiqError
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct

classiq/qmod/qmod_parameter.py

@@ -10,20 +10,23 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalList,
     ClassicalType,
+    Integer,
+    Real,
 )
+from classiq.interface.generator.functions.type_name import TypeName
 
 from classiq import Struct, StructDeclaration
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
 _T = TypeVar("_T")
 
-
 if TYPE_CHECKING:
     from classiq.qmod.qmod_variable import QNum
 
@@ -160,3 +163,24 @@ def create_param(
 
 
 Array = CArray
+
+
+def get_qmod_type(ctype: ClassicalType) -> type:
+    if isinstance(ctype, Integer):
+        return CInt
+    elif isinstance(ctype, Real):
+        return CReal
+    elif isinstance(ctype, Bool):
+        return CBool
+    elif isinstance(ctype, ClassicalList):
+        return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
+    elif isinstance(ctype, ClassicalArray):
+        return CArray[get_qmod_type(ctype.element_type), ctype.size]  # type: ignore[misc]
+    elif isinstance(ctype, TypeName):
+        type_ = type(ctype.name, (TypeName,), dict())
+        if isinstance(ctype, Struct):
+            type_.__dataclass_fields__ = []  # type:ignore[attr-defined]
+        return type_
+    raise NotImplementedError(
+        f"{ctype.__class__.__name__!r} has no QMOD SDK equivalent"
+    )

classiq/qmod/qmod_variable.py

@@ -22,6 +22,7 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.qmod_qarray_proxy import (
     ILLEGAL_SLICE_BOUNDS_MSG,
@@ -56,7 +57,6 @@ from classiq.interface.model.quantum_type import (
 )
 from classiq.interface.source_reference import SourceReference
 
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_parameter import ArrayBase, CBool, CInt, CParamScalar
 from classiq.qmod.quantum_callable import QCallable
@@ -169,6 +169,16 @@ class QVar(Symbolic):
     def __str__(self) -> str:
         return self._expr_str
 
+    @property
+    def size(self) -> Union[CParamScalar, int]:
+        if not QVAR_PROPERTIES_ARE_SYMBOLIC:
+            return self._evaluate_size()
+        return CParamScalar(f"get_field({self}, 'size')")
+
+    @abc.abstractmethod
+    def _evaluate_size(self) -> int:
+        raise NotImplementedError
+
 
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
@@ -259,6 +269,9 @@ class QBit(QScalar):
     def get_qmod_type(self) -> QuantumType:
         return QuantumBit()
 
+    def _evaluate_size(self) -> int:
+        return 1
+
 
 _P = ParamSpec("_P")
 
@@ -345,13 +358,10 @@ class QNum(Generic[_P], QScalar):
             fraction_digits=self._fraction_digits,
         )
 
-    @property
-    def size(self) -> Union[CParamScalar, int]:
-        if not QVAR_PROPERTIES_ARE_SYMBOLIC:
-            if TYPE_CHECKING:
-                assert self._size is not None
-            return self._size.to_int_value()
-        return CParamScalar(f"get_field({self}, 'size')")
+    def _evaluate_size(self) -> int:
+        if TYPE_CHECKING:
+            assert self._size is not None
+        return self._size.to_int_value()
 
     @property
     def fraction_digits(self) -> Union[CParamScalar, int]:
@@ -475,6 +485,11 @@ class QArray(ArrayBase[_P], QVar):
                 return CParamScalar(f"{self._length}")
             return CParamScalar(f"get_field({self}, 'len')")
 
+    def _evaluate_size(self) -> int:
+        if TYPE_CHECKING:
+            assert self._length is not None
+        return self._element_type.size_in_bits * self._length.to_int_value()
+
     @classmethod
     def _get_attributes(cls, type_hint: Any) -> Tuple[Type[QVar], Any]:
         type_args = version_portable_get_args(type_hint)
@@ -604,6 +619,9 @@ class QStruct(QVar):
             fields={name: qvar.get_qmod_type() for name, qvar in self._fields.items()},
         )
 
+    def _evaluate_size(self) -> int:
+        return sum(var._evaluate_size() for var in self._fields.values())
+
 
 def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:
     return _create_qvar_for_qtype(port.quantum_type, HandleBinding(name=name))
@@ -642,3 +660,24 @@ def _create_qvar_for_qtype(
         if TYPE_CHECKING:
             assert isinstance(qtype, QuantumBitvector)
         return QArray(origin, qtype.element_type, qtype.length, _expr_str=expr_str)
+
+
+def get_qvar(qtype: QuantumType, origin: HandleBinding) -> "QVar":
+    if isinstance(qtype, QuantumBit):
+        return QBit(origin)
+    elif isinstance(qtype, QuantumBitvector):
+        return QArray(origin, qtype.element_type, qtype.length)
+    elif isinstance(qtype, QuantumNumeric):
+        return QNum(origin, qtype.size, qtype.is_signed, qtype.fraction_digits)
+    elif isinstance(qtype, TypeName):
+        return QStruct(
+            origin,
+            qtype.name,
+            {
+                field_name: get_qvar(
+                    field_type, FieldHandleBinding(base_handle=origin, field=field_name)
+                )
+                for field_name, field_type in qtype.fields.items()
+            },
+        )
+    raise NotImplementedError

classiq/qmod/quantum_expandable.py

@@ -20,6 +20,7 @@ from typing import (
 from sympy import Basic
 from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import PythonClassicalTypes
 from classiq.interface.model.classical_parameter_declaration import (
@@ -45,10 +46,15 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.source_reference import SourceReference
 
-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 CInt, CParam, CParamScalar, create_param
+from classiq.qmod.qmod_parameter import (
+    CInt,
+    CParam,
+    CParamScalar,
+    create_param,
+    get_qmod_type,
+)
 from classiq.qmod.qmod_variable import (
     QVar,
     create_qvar_for_port_decl,
@@ -321,7 +327,7 @@ def _validate_classical_arg(
         raise ClassiqValueError(
             f"Argument {str(arg)!r} to parameter {arg_decl.name!r}{func_name_message} "
             f"has incompatible type; expected "
-            f"{arg_decl.classical_type.qmod_type.__name__}"
+            f"{get_qmod_type(arg_decl.classical_type).__name__}"
         )
 
 

classiq/qmod/quantum_function.py

@@ -5,6 +5,7 @@ from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
+from classiq.interface.exceptions import ClassiqError
 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
@@ -15,7 +16,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 
-from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.model_state_container import QMODULE
@@ -25,6 +25,7 @@ from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.utilities import mangle_keyword, unmangle_keyword
+from classiq.qmod.write_qmod import write_qmod
 
 
 def _lookup_qfunc(name: str) -> Optional[NamedParamsQuantumFunctionDeclaration]:
@@ -38,15 +39,21 @@ def create_model(
     execution_preferences: Optional[ExecutionPreferences] = None,
     preferences: Optional[Preferences] = None,
     classical_execution_function: Optional[CFunc] = None,
+    out_file: Optional[str] = None,
 ) -> SerializedModel:
     if entry_point.func_decl.name != "main":
         raise ClassiqError(
             f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
         )
-    return entry_point.create_model(
+    result = entry_point.create_model(
         constraints, execution_preferences, preferences, classical_execution_function
     ).get_model()
 
+    if out_file is not None:
+        write_qmod(result, out_file)
+
+    return result
+
 
 class QFunc(QExpandable):
     FRAME_DEPTH = 2

classiq/qmod/semantics/annotation.py

@@ -1,5 +1,6 @@
 from typing import Mapping
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -9,8 +10,6 @@ from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
 
-from classiq.exceptions import ClassiqError
-
 
 def annotate_function_call_decl(
     fc: QuantumFunctionCall,

classiq/qmod/semantics/static_semantics_visitor.py

@@ -12,6 +12,7 @@ from typing import (
     Type,
 )
 
+from classiq.interface.exceptions import ClassiqSemanticError
 from classiq.interface.generator.function_params import PortDirection
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
@@ -45,7 +46,6 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq import AnonClassicalParameterDeclaration
-from classiq.exceptions import ClassiqSemanticError
 from classiq.qmod.semantics.annotation import annotate_function_call_decl
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.func_call_validation import (

classiq/qmod/semantics/validation/func_call_validation.py

@@ -1,5 +1,6 @@
 from typing import List, Mapping
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
@@ -13,7 +14,6 @@ from classiq.interface.model.quantum_lambda_function import (
     QuantumOperand,
 )
 
-from classiq.exceptions import ClassiqError
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 

classiq/qmod/symbolic.py

@@ -11,7 +11,8 @@ from typing import (
     overload,
 )
 
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.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 (

classiq/show.py

@@ -3,11 +3,11 @@ import re
 import pydantic
 
 from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.exceptions import ClassiqValueError
 
 from classiq import QuantumProgram
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
-from classiq.exceptions import ClassiqValueError
 from classiq.synthesis import SerializedQuantumProgram
 
 QASM_VERSION_REGEX = re.compile("OPENQASM (\\d*.\\d*);")

{classiq-0.44.0.dist-info → classiq-0.45.0.dist-info}/METADATA

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