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

classiq/qmod/semantics/validation/types_validation.py

@@ -1,11 +1,16 @@
 from typing import Sequence, Union
 
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.model.quantum_type import QuantumBitvector
+
 from classiq import EnumDeclaration, StructDeclaration
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 
 def check_duplicate_types(
-    types: Sequence[Union[EnumDeclaration, StructDeclaration]]
+    types: Sequence[Union[EnumDeclaration, StructDeclaration, QStructDeclaration]]
 ) -> None:
     known_types = {
         type_.name for type_ in EnumDeclaration.BUILTIN_ENUM_DECLARATIONS.values()
@@ -19,3 +24,105 @@ def check_duplicate_types(
                 ErrorManager().add_error(f"Type {type_.name!r} already exists")
         else:
             known_types.add(type_.name)
+
+
+def check_qstruct_flexibility(qstruct: QStructDeclaration) -> None:
+    _check_qstruct_no_array_without_size_and_element_size(qstruct)
+    _check_qstruct_at_most_one_type_without_size(qstruct)
+
+
+def _check_qstruct_no_array_without_size_and_element_size(
+    qstruct: QStructDeclaration,
+) -> None:
+    offending_array_fields = [
+        field_name
+        for field_name, field_type in qstruct.fields.items()
+        if isinstance(field_type, QuantumBitvector)
+        and not field_type.has_length
+        and not field_type.element_type.has_size_in_bits
+    ]
+    if len(offending_array_fields) > 0:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name} contains arrays whose neither length "
+                f"nor element size are constants. Offending fields: "
+                f"{', '.join(offending_array_fields)}"
+            )
+
+
+def _check_qstruct_at_most_one_type_without_size(qstruct: QStructDeclaration) -> None:
+    fields_without_size = [
+        field_name
+        for field_name, field_type in qstruct.fields.items()
+        if not field_type.has_size_in_bits
+    ]
+    if len(fields_without_size) > 1:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name} has more than one field whose size is "
+                f"not constant. Offending fields: {', '.join(fields_without_size)}"
+            )
+
+
+def check_qstruct_fields_are_defined(qstruct: QStructDeclaration) -> bool:
+    all_defined = True
+    for field_type in qstruct.fields.values():
+        if (
+            isinstance(field_type, TypeName)
+            and field_type.name not in QMODULE.qstruct_decls
+        ):
+            with ErrorManager().node_context(field_type):
+                ErrorManager().add_error(
+                    f"Quantum struct {field_type.name!r} is not defined."
+                )
+            all_defined = False
+    return all_defined
+
+
+def check_qstruct_has_fields(qstruct: QStructDeclaration) -> None:
+    if len(qstruct.fields) == 0:
+        with ErrorManager().node_context(qstruct):
+            ErrorManager().add_error(
+                f"Quantum struct {qstruct.name!r} must have at least one field."
+            )
+
+
+def check_cstruct_has_fields(cstruct: StructDeclaration) -> None:
+    if len(cstruct.variables) == 0:
+        with ErrorManager().node_context(cstruct):
+            ErrorManager().add_error(
+                f"Classical struct {cstruct.name!r} must have at least one field."
+            )
+
+
+def check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> bool:
+    non_recursive = True
+    for main_field_name, main_field in qstruct.fields.items():
+        if (
+            not isinstance(main_field, TypeName)
+            or main_field.name not in QMODULE.qstruct_decls
+        ):
+            continue
+        main_field_qstruct = QMODULE.qstruct_decls[main_field.name]
+        seen_qstructs = {qstruct.name}
+        stack = [main_field_qstruct]
+        while stack:
+            qstruct = stack.pop()
+            if qstruct.name in seen_qstructs:
+                with ErrorManager().node_context(qstruct):
+                    ErrorManager().add_error(
+                        f"Declaration of field {main_field_name!r} in quantum struct "
+                        f"{qstruct.name!r} creates a recursive definition."
+                    )
+                non_recursive = False
+                break
+            seen_qstructs.add(qstruct.name)
+            stack.extend(
+                [
+                    QMODULE.qstruct_decls[field.name]
+                    for field in qstruct.fields.values()
+                    if isinstance(field, TypeName)
+                    and field.name in QMODULE.qstruct_decls
+                ]
+            )
+    return non_recursive

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/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.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

@@ -5,9 +5,9 @@ import keyword
 import sys
 from enum import Enum as PythonEnum
 from types import FrameType
-from typing import Any, get_args, get_origin
+from typing import Any, Literal, Optional, get_args, get_origin, overload
 
-from classiq.interface.ast_node import SourceReference
+from classiq.interface.source_reference import SourceReference
 
 DEFAULT_DECIMAL_PRECISION = 4
 
@@ -18,8 +18,19 @@ 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
@@ -29,9 +40,19 @@ 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__
+        type_args = get_args(py_type)  # The result of __class_getitem__
     else:
-        return get_args(py_type)[0]
+        type_args = get_args(py_type)[0]
+    if not isinstance(type_args, tuple):
+        return type_args
+    return tuple(
+        (
+            version_portable_get_args(type_arg)
+            if get_origin(type_arg) == Literal
+            else type_arg
+        )
+        for type_arg in type_args
+    )
 
 
 def get_source_ref(frame: FrameType) -> SourceReference:

classiq/{interface/ide/show.py → 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.43.3.dist-info → classiq-0.45.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.43.3
+Version: 0.45.0
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary
@@ -39,12 +39,12 @@ Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
 Requires-Dist: networkx (>=2.5.1,<3.0.0)
 Requires-Dist: numexpr (>=2.7.3,<3.0.0)
 Requires-Dist: numpy (>=1.20.1,<2.0.0)
-Requires-Dist: packaging (>=22.0,<23.0)
+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: scipy (>=1.10.1,<2.0.0)
-Requires-Dist: sympy (>=1.9.0,<1.11.0)
+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"