classiq 0.82.1__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/qmod/python_classical_type.py

@@ -31,7 +31,9 @@ CARRAY_ERROR_MESSAGE = (
 
 
 class PythonClassicalType:
-    def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
+    def convert(
+        self, py_type: type, nested: bool = False
+    ) -> Optional[ConcreteClassicalType]:
         if py_type is int:
             return Integer().set_generative()
         elif py_type is CInt:
@@ -45,16 +47,18 @@ class PythonClassicalType:
         elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
-            element_type = self.convert(get_args(py_type)[0])
+            element_type = self.convert(get_args(py_type)[0], nested=True)
             if element_type is not None:
                 return ClassicalArray(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:
-                return ClassicalArray(element_type=self.convert(array_args[0]))
+                return ClassicalArray(
+                    element_type=self.convert(array_args[0], nested=True)
+                )
             elif len(array_args) == 2:
                 return ClassicalArray(
-                    element_type=self.convert(array_args[0]),
+                    element_type=self.convert(array_args[0], nested=True),
                     length=Expression(expr=get_type_hint_expr(array_args[1])),
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
@@ -62,7 +66,10 @@ class PythonClassicalType:
             return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
-            return Enum(name=py_type.__name__).set_generative()
+            enum_type = Enum(name=py_type.__name__)
+            if not nested:
+                enum_type.set_generative()
+            return enum_type
         elif py_type in (CArray, list):
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None

classiq/qmod/qfunc.py

@@ -107,6 +107,6 @@ def _validate_directives(
     if synthesize_separately:
         error_msg += "External functions can't be marked as synthesized separately. \n"
     if unchecked is not None and len(unchecked) > 0:
-        error_msg += "External functions can't have unchecked qualifiers."
+        error_msg += "External functions can't have unchecked modifiers."
     if error_msg:
         raise ClassiqInternalError(error_msg)

classiq/qmod/qmod_constant.py

@@ -5,10 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
+from classiq.interface.generator.functions.classical_type import ClassicalArray
 
 from classiq.qmod.cparam import CArray, CParamScalar
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -118,7 +115,7 @@ class QConstant(SymbolicExpr):
         if qmod_type is None:
             raise ClassiqError("Invalid QMOD type")
 
-        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+        if not isinstance(qmod_type, ClassicalArray):
             raise ClassiqError("Invalid subscript to non-list constant")
 
         return CParamList(

classiq/qmod/qmod_parameter.py

@@ -4,7 +4,6 @@ from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     Integer,
@@ -42,7 +41,7 @@ class CParamList(CParam):
     def __init__(
         self,
         expr: str,
-        list_type: Union[ClassicalList, ClassicalArray, ClassicalTuple],
+        list_type: Union[ClassicalArray, ClassicalTuple],
         qmodule: ModelStateContainer,
     ) -> None:
         super().__init__(expr)
@@ -149,7 +148,7 @@ def create_param(
         decl = ctype.classical_struct_decl
         ctype = Struct(name=ctype.name)
         ctype.set_classical_struct_decl(decl)
-    if isinstance(ctype, (ClassicalList, ClassicalArray, ClassicalTuple)):
+    if isinstance(ctype, (ClassicalArray, ClassicalTuple)):
         return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return CParamStruct(expr_str, ctype, qmodule=qmodule)
@@ -164,8 +163,6 @@ def get_qmod_type(ctype: ClassicalType) -> type:
         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):
         if ctype.length is None:
             return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]

classiq/qmod/qmod_variable.py

@@ -34,19 +34,20 @@ from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy i
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.helpers.classproperty import classproperty
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -136,7 +137,7 @@ class QVar(Symbolic):
         return self._base_handle
 
     @abc.abstractmethod
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         raise NotImplementedError()
 
     @classmethod
@@ -164,15 +165,23 @@ class QVar(Symbolic):
         return self.get_qmod_type().type_name
 
 
+class QmodExpressionCreator(Protocol):
+    """
+    A callable that creates a Qmod expression from the provided QVars.
+    """
+
+    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
+
+
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
 Input = Annotated[_Q, PortDeclarationDirection.Input]
 Const = Annotated[
-    _Q, TypeQualifier.Const
+    _Q, TypeModifier.Const
 ]  # A constant variable, up to a phase dependent on the computational basis state
-QFree = Annotated[
-    _Q, TypeQualifier.QFree
-]  # A quantum free variable, up to a phase dependent on the computational basis state
+Permutable = Annotated[
+    _Q, TypeModifier.Permutable
+]  # A permutable ("quantum free") variable, up to a phase dependent on the computational basis state
 
 
 class QScalar(QVar, SymbolicExpr):
@@ -273,7 +282,7 @@ class QBit(QScalar):
     ) -> "QBit":
         return QBit(origin, _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumBit()
 
 
@@ -329,7 +338,7 @@ class QNum(Generic[_P], QScalar):
     ) -> "QNum":
         return QNum(origin, *_get_qnum_attributes(type_hint), _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumNumeric(
             size=self._size,
             is_signed=self._is_signed,
@@ -498,8 +507,15 @@ class QStruct(QVar):
             setattr(self, field_name, var)
         super().__init__(name, expr_str=_expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
-        return TypeName(name=self._struct_name)
+    def get_qmod_type(self) -> ConcreteQuantumType:
+        classical_type = Struct(name=self._struct_name)
+        classical_type.set_fields(
+            {
+                field_name: field_var.get_qmod_type()
+                for field_name, field_var in self._fields.items()
+            }
+        )
+        return classical_type
 
     @classmethod
     def to_qvar(
@@ -529,9 +545,23 @@ class QStruct(QVar):
             _expr_str=expr_str,
         )
 
+    @classproperty
+    def num_qubits(cls) -> int:  # noqa: N805
+        """
+        The total number of qubits in this quantum struct.
+        Raises an error if the struct doesn't have a fixed size.
+        """
+        qvar = cls.to_qvar(HandleBinding(name="dummy"), type_hint=cls, expr_str=None)
+        quantum_type = qvar.get_qmod_type()
+        if not quantum_type.has_size_in_bits:
+            raise ClassiqValueError(
+                f"Could not infer the size of struct {qvar._struct_name!r}"
+            )
+        return quantum_type.size_in_bits
+
 
-def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:
-    return _create_qvar_for_qtype(port.quantum_type, HandleBinding(name=name))
+def create_qvar_from_quantum_type(quantum_type: ConcreteQuantumType, name: str) -> QVar:
+    return _create_qvar_for_qtype(quantum_type, HandleBinding(name=name))
 
 
 def _create_qvar_for_qtype(
@@ -592,21 +622,21 @@ def get_qvar(qtype: QuantumType, origin: HandleBinding) -> "QVar":
 
 def get_port_from_type_hint(
     py_type: Any,
-) -> tuple[QuantumType, PortDeclarationDirection, TypeQualifier]:
+) -> tuple[QuantumType, PortDeclarationDirection, TypeModifier]:
     direction = PortDeclarationDirection.Inout  # default
-    qualifier = TypeQualifier.Quantum  # default
+    modifier = TypeModifier.Mutable  # default
 
     if isinstance(py_type, _AnnotatedAlias):
         quantum_type = _to_quantum_type(py_type.__origin__)
         for metadata in py_type.__metadata__:
             if isinstance(metadata, PortDeclarationDirection):
                 direction = metadata
-            elif isinstance(metadata, TypeQualifier):
-                qualifier = metadata
+            elif isinstance(metadata, TypeModifier):
+                modifier = metadata
     else:
         quantum_type = _to_quantum_type(py_type)
 
-    return quantum_type, direction, qualifier
+    return quantum_type, direction, modifier
 
 
 def _to_quantum_type(py_type: Any) -> QuantumType:
@@ -689,17 +719,27 @@ def _get_quantum_bit_vector(type_hint: type[QArray]) -> QuantumBitvector:
     return QuantumBitvector(element_type=element_type, length=length_expr)
 
 
-def _get_quantum_struct(type_hint: type[QStruct]) -> TypeName:
-    _register_qstruct(type_hint, qmodule=QMODULE)
-    return TypeName(name=type_hint.__name__)
+def _get_quantum_struct(type_hint: type[QStruct]) -> Struct:
+    decl = _register_qstruct(type_hint, qmodule=QMODULE)
+    classical_type = Struct(name=type_hint.__name__)
+    if decl is not None:
+        classical_type.set_fields(
+            {
+                field_name: field_type.model_copy(deep=True)
+                for field_name, field_type in decl.fields.items()
+            }
+        )
+    return classical_type
 
 
 def _register_qstruct(
     type_hint: type[QStruct], *, qmodule: ModelStateContainer
-) -> None:
+) -> Optional[QStructDeclaration]:
     struct_name = type_hint.__name__
-    if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
-        return
+    if type_hint is QStruct:
+        return None
+    if struct_name in qmodule.qstruct_decls:
+        return qmodule.qstruct_decls[struct_name]
 
     # temp assignment for recursive qstruct definitions
     qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
@@ -714,6 +754,7 @@ def _register_qstruct(
     qmodule.qstruct_decls[struct_name] = struct_decl
     QStructAnnotator().visit(struct_decl)
     validate_qstruct(struct_decl)
+    return struct_decl
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:

classiq/qmod/quantum_expandable.py

@@ -68,7 +68,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.qmod_variable import (
     QVar,
-    create_qvar_for_port_decl,
+    create_qvar_from_quantum_type,
 )
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -163,7 +163,9 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
             elif isinstance(arg, AnonPortDeclaration):
-                result.append(create_qvar_for_port_decl(arg, actual_name))
+                result.append(
+                    create_qvar_from_quantum_type(arg.quantum_type, actual_name)
+                )
             else:
                 assert isinstance(arg, AnonQuantumOperandDeclaration)
                 result.append(QTerminalCallable(arg, idx))

classiq/qmod/quantum_function.py

@@ -101,7 +101,12 @@ class QFunc(BaseQFunc):
     ) -> None:
         _validate_no_gen_params(py_callable.__annotations__)
         super().__init__(py_callable, compilation_metadata)
-        self.compilation_metadata: Optional[CompilationMetadata] = None
+        if compilation_metadata is not None and compilation_metadata.unchecked:
+            self.compilation_metadata: Optional[CompilationMetadata] = (
+                CompilationMetadata(unchecked=compilation_metadata.unchecked)
+            )
+        else:
+            self.compilation_metadata = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
@@ -261,7 +266,7 @@ class GenerativeQFunc(BaseQFunc):
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         if get_global_declarative_switch():
-            return QFunc(self._py_callable)(*args, **kwargs)
+            return QFunc(self._py_callable, self.compilation_metadata)(*args, **kwargs)
         if self.func_decl.name not in self._qmodule.generative_functions:
             self._qmodule.generative_functions[self.func_decl.name] = self
             if self._func_decl is None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -45,7 +45,7 @@ class QStructAnnotator(ModelVisitor):
             return
         self._visited.add(type_name)
         new_fields = {
-            field_name: field_type.model_copy()
+            field_name: field_type.model_copy(deep=True)
             for field_name, field_type in decl.variables.items()
         }
         self.visit(new_fields)

classiq/qmod/semantics/validation/main_validation.py

@@ -1,8 +1,5 @@
 from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
+from classiq.interface.generator.functions.classical_type import ClassicalArray
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -31,11 +28,6 @@ def _validate_main_param(param: PositionalArg) -> None:
 def _validate_main_classical_param_type(
     param: ConcreteClassicalType, param_name: str
 ) -> None:
-    if isinstance(param, ClassicalList):
-        raise ClassiqExpansionError(
-            f"Classical array parameter {param_name!r} of function 'main' must "
-            f"specify array length",
-        )
     if isinstance(param, ClassicalArray):
         if param.length is None:
             raise ClassiqExpansionError(

classiq/qmod/semantics/validation/type_hints.py

@@ -6,7 +6,7 @@ from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 
 
 def validate_annotation(type_hint: Any) -> None:
@@ -17,12 +17,12 @@ def validate_annotation(type_hint: Any) -> None:
         for direction in type_hint.__metadata__
         if isinstance(direction, PortDeclarationDirection)
     ]
-    qualifiers: list[TypeQualifier] = [
-        qualifier
-        for qualifier in type_hint.__metadata__
-        if isinstance(qualifier, TypeQualifier)
+    modifiers: list[TypeModifier] = [
+        modifier
+        for modifier in type_hint.__metadata__
+        if isinstance(modifier, TypeModifier)
     ]
-    if len(directions) <= 1 and len(qualifiers) <= 1:
+    if len(directions) <= 1 and len(modifiers) <= 1:
         return
     error_message = ""
     if len(directions) > 1:
@@ -30,9 +30,9 @@ def validate_annotation(type_hint: Any) -> None:
             f"Multiple directions are not allowed in a single type hint: "
             f"[{', '.join(direction.name for direction in reversed(directions))}]\n"
         )
-    if len(qualifiers) > 1:
+    if len(modifiers) > 1:
         error_message += (
-            f"Multiple qualifiers are not allowed in a single type hint: "
-            f"[{', '.join(qualifier.name for qualifier in reversed(qualifiers))}]\n"
+            f"Multiple modifiers are not allowed in a single type hint: "
+            f"[{', '.join(modifier.name for modifier in reversed(modifiers))}]\n"
         )
     raise ClassiqValueError(error_message)

classiq/qmod/utilities.py

@@ -31,8 +31,6 @@ from classiq.interface.source_reference import SourceReference
 if TYPE_CHECKING:
     from classiq.qmod.qmod_variable import QVar
 
-DEFAULT_DECIMAL_PRECISION = 4
-
 
 def mangle_keyword(name: str) -> str:
     if keyword.iskeyword(name):

classiq/qmod/write_qmod.py

@@ -2,12 +2,12 @@ import json
 from pathlib import Path
 from typing import Optional, Union
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.model.model import Model, SerializedModel
 
 from classiq.qmod.global_declarative_switch import set_global_declarative_switch
 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"
 _SYNTHESIS_OPTIONS_SUFFIX = "synthesis_options.json"

classiq/synthesis.py

@@ -13,8 +13,6 @@ from classiq._internals.api_wrapper import ApiWrapper
 from classiq.qmod.create_model_function import add_entry_point
 from classiq.qmod.quantum_function import BaseQFunc
 
-SerializedQuantumProgram = QuantumProgram
-
 
 def show(quantum_program: QuantumProgram, display_url: bool = True) -> None:
     """

{classiq-0.82.1.dist-info → classiq-0.84.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.82.1
+Version: 0.84.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -27,6 +27,7 @@ Classifier: Topic :: Software Development :: Compilers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: analyzer-sdk
+Provides-Extra: chemistry
 Provides-Extra: qml
 Requires-Dist: ConfigArgParse (>=1.5.3,<2.0.0)
 Requires-Dist: Pyomo (>=6.5,<6.6)
@@ -41,6 +42,8 @@ Requires-Dist: notebook ; extra == "analyzer-sdk"
 Requires-Dist: numexpr (>=2.7.3,<3.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: openfermion ; extra == "chemistry"
+Requires-Dist: openfermionpyscf ; extra == "chemistry"
 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)