classiq 0.75.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/interface/executor/user_budget.py

@@ -0,0 +1,56 @@
+import datetime
+from collections import defaultdict
+from typing import Optional
+
+import pydantic
+from pydantic import ConfigDict, Field
+
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class UserBudget(VersionedModel):
+    provider: str
+    currency_code: str
+    organization: Optional[str] = Field(default=None)
+    available_budget: float
+    used_budget: float
+    last_allocation_date: datetime.datetime
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class UserBudgets(VersionedModel):
+    budgets: list[UserBudget] = pydantic.Field(default=[])
+
+    def print_budgets(self) -> None:
+        def format_header() -> str:
+            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
+
+        def format_row(
+            provider: str, available: float, used: float, currency: str
+        ) -> str:
+            return f"| {provider:<20} | {available:<18.0f} | {used:<18.0f} | {currency:<8} |"
+
+        table_data: dict = defaultdict(
+            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
+        )
+
+        for budget in self.budgets:
+            provider = budget.provider
+            table_data[provider]["available"] += budget.available_budget
+            table_data[provider]["used"] += budget.used_budget
+            table_data[provider]["currency"] = budget.currency_code
+
+        line = "=" * 77
+        print(line)  # noqa: T201
+        print(format_header())  # noqa: T201
+        print(line)  # noqa: T201
+
+        for provider, values in table_data.items():
+            print(  # noqa: T201
+                format_row(
+                    provider, values["available"], values["used"], values["currency"]
+                )
+            )
+
+        print(line)  # noqa: T201

classiq/interface/generator/application_apis/finance_declarations.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -55,11 +56,13 @@ def _generate_finance_function(
                     )
                 ),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
             PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
         ],
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -15,6 +15,7 @@ SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+    "mod_inverse",
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -23,6 +24,8 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseNot",
     "BitwiseOr",
     "LogicalXor",
+    "RShift",
+    "LShift",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -1,135 +1,41 @@
+import inspect
 from typing import Any
 
+import sympy
 
-class AnyClassicalValue:
-    def __init__(self, expr: str) -> None:
-        self._expr = expr
+_SYMPY_MEMBERS = [name for name, _ in inspect.getmembers(sympy.Symbol)] + ["precedence"]
 
-    def __str__(self) -> str:
-        return self._expr
 
-    def __repr__(self) -> str:
-        return str(self)
+def subscript_to_str(index: Any) -> str:
+    if not isinstance(index, slice):
+        return str(index)
+    expr = ""
+    if index.start is not None:
+        expr += str(index.start)
+    expr += ":"
+    if index.stop is not None:
+        expr += str(index.stop)
+    if index.step is not None:
+        expr += f":{index.step}"
+    return expr
 
-    def __getitem__(self, item: Any) -> "AnyClassicalValue":
-        if isinstance(item, slice):
-            subscript = ""
-            if item.start is not None:
-                subscript += str(item.start)
-            subscript += ":"
-            if item.stop is not None:
-                subscript += str(item.stop)
-            if item.step is not None:
-                subscript += f":{item.stop}"
-            item = subscript
-        return AnyClassicalValue(f"{self}[{item}]")
-
-    @staticmethod
-    def _binary_op(lhs: Any, rhs: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{lhs} {op} {rhs}")
-
-    @staticmethod
-    def _unary_op(arg: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{op}({arg})")
-
-    def __add__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "+")
-
-    def __sub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "-")
-
-    def __mul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "*")
-
-    def __truediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "/")
-
-    def __floordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "//")
-
-    def __mod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "%")
-
-    def __pow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "**")
-
-    def __lshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<<")
-
-    def __rshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">>")
-
-    def __and__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "&")
-
-    def __xor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "^")
-
-    def __or__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "|")
-
-    def __radd__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "+")
-
-    def __rsub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "-")
 
-    def __rmul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "*")
+class AnyClassicalValue(sympy.Symbol):
 
-    def __rtruediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "/")
+    is_commutative = None
+    is_infinite = None
+    is_finite = None
+    is_extended_real = None
 
-    def __rfloordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "//")
-
-    def __rmod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "%")
-
-    def __rpow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "**")
-
-    def __rlshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "<<")
-
-    def __rrshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, ">>")
-
-    def __rand__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "&")
-
-    def __rxor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "^")
-
-    def __ror__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "|")
-
-    def __lt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<")
-
-    def __le__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<=")
-
-    def __eq__(self, other: Any) -> "AnyClassicalValue":  # type:ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "==")
-
-    def __ne__(self, other: Any) -> "AnyClassicalValue":  # type: ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "!=")
-
-    def __gt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">")
-
-    def __ge__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">=")
-
-    def __neg__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "-")
-
-    def __pos__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "+")
+    def __getitem__(self, item: Any) -> "AnyClassicalValue":
+        if isinstance(item, slice):
+            return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")
+        return AnyClassicalValue(f"do_subscript({self}, {item})")
 
-    def __abs__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "abs")
+    def __getattribute__(self, attr: str) -> Any:
+        if attr.startswith("_") or attr in _SYMPY_MEMBERS:
+            return super().__getattribute__(attr)
+        return AnyClassicalValue(f"get_field({self}, '{attr}')")
 
-    def __invert__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "~")
+    def __len__(self) -> "AnyClassicalValue":
+        return self.len

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -1,11 +1,16 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
+import sympy
 from sympy import Integer
+from typing_extensions import TypeGuard
 
 from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -22,9 +27,20 @@ if TYPE_CHECKING:
     )
 
 
+def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
+    if isinstance(val, AnyClassicalValue):
+        return False
+    if isinstance(val, sympy.Basic):
+        return val.is_Number
+    return isinstance(val, int)
+
+
 class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def __init__(
-        self, handle: HandleBinding, element_type: "ConcreteClassicalType", length: int
+        self,
+        handle: HandleBinding,
+        element_type: "ConcreteClassicalType",
+        length: "ExpressionValue",
     ) -> None:
         super().__init__(handle)
         self._element_type = element_type
@@ -39,39 +55,47 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
         return "Array"
 
     @property
-    def length(self) -> int:
+    def length(self) -> "ExpressionValue":
         return self._length
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
+    def __getitem__(
+        self, key: Union[slice, int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
     def _get_slice(self, slice_: slice) -> ClassicalProxy:
-        start = int(slice_.start)
-        stop = int(slice_.stop)
-        if start >= stop:
-            raise ClassiqIndexError("Array slice has non-positive length")
-        if start < 0 or stop > self._length:
-            raise ClassiqIndexError("Array slice is out of bounds")
+        start_ = slice_.start
+        stop_ = slice_.stop
+        if _is_int(start_) and _is_int(stop_):
+            start = int(start_)
+            stop = int(stop_)
+            if start >= stop:
+                raise ClassiqIndexError("Array slice has non-positive length")
+            if start < 0 or (isinstance(self._length, int) and stop > self._length):
+                raise ClassiqIndexError("Array slice is out of bounds")
         return ClassicalArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
-                start=Expression(expr=str(start)),
-                end=Expression(expr=str(stop)),
+                start=Expression(expr=str(start_)),
+                end=Expression(expr=str(stop_)),
             ),
             self._element_type,
-            stop - start,
+            stop_ - start_,
         )
 
-    def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
-        index = int(index_)
-        if index < 0:
-            raise ClassiqIndexError(
-                "Array index is out of bounds (negative indices are not supported)"
-            )
-        if index >= self._length:
-            raise ClassiqIndexError("Array index is out of bounds")
+    def _get_subscript(
+        self, index_: Union[int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
+        if _is_int(index_):
+            index = int(index_)
+            if index < 0:
+                raise ClassiqIndexError(
+                    "Array index is out of bounds (negative indices are not supported)"
+                )
+            if isinstance(self._length, int) and index >= self._length:
+                raise ClassiqIndexError("Array index is out of bounds")
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
                 base_handle=self._handle, index=Expression(expr=str(index_))

classiq/interface/generator/expressions/proxies/classical/qmod_struct_instance.py

@@ -25,6 +25,13 @@ class QmodStructInstance:
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __getattr__(self, item: str) -> Any:
+        if item == "_fields":
+            return super().__getattribute__(item)
+        if item in self._fields:
+            return self._fields[item]
+        return super().__getattribute__(item)
+
     def __str__(self) -> str:
         return repr(self)
 

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -13,6 +13,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
+    ClassicalList,
     ClassicalType,
 )
 from classiq.interface.generator.functions.type_name import Struct
@@ -20,15 +21,15 @@ from classiq.interface.generator.functions.type_name import Struct
 
 def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
     if isinstance(proxy, ClassicalScalarProxy):
-        classical_type = proxy._classical_type
-    elif isinstance(proxy, ClassicalArrayProxy):
-        classical_type = ClassicalArray(
-            element_type=proxy._element_type, size=proxy.length
-        )
-    elif isinstance(proxy, ClassicalStructProxy):
+        return proxy._classical_type
+    if isinstance(proxy, ClassicalArrayProxy):
+        if not isinstance(proxy.length, int):
+            return ClassicalList(element_type=proxy._element_type)
+        return ClassicalArray(element_type=proxy._element_type, size=proxy.length)
+    if isinstance(proxy, ClassicalStructProxy):
         classical_type = Struct(name=proxy._decl.name)
-    else:
-        raise ClassiqInternalExpansionError(
-            f"Unrecognized classical proxy {type(proxy).__name__}"
-        )
-    return classical_type
+        classical_type.set_classical_struct_decl(proxy._decl)
+        return classical_type
+    raise ClassiqInternalExpansionError(
+        f"Unrecognized classical proxy {type(proxy).__name__}"
+    )

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,7 +1,8 @@
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, Optional
 
 from sympy import Symbol
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
@@ -12,11 +13,17 @@ from classiq.interface.model.handle_binding import HandleBinding
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
     def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
-        return super().__new__(cls, str(handle), **assumptions)
+        return super().__new__(cls, handle.qmod_expr, **assumptions)
 
     def __init__(self, handle: HandleBinding, size: int) -> None:
         super().__init__(handle, size)
 
+    def __copy__(self) -> Self:
+        return self
+
+    def __deepcopy__(self, memo: Optional[dict]) -> Self:
+        return self
+
 
 class QmodQBitProxy(QmodQScalarProxy):
     def __init__(self, handle: HandleBinding) -> None:

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -15,7 +15,10 @@ class QmodSizedProxy:
         return self._size
 
     def __str__(self) -> str:
-        return str(self.handle)
+        return self.handle.qmod_expr
+
+    def __repr__(self) -> str:
+        return str(self)
 
     @property
     def type_name(self) -> str:

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -33,6 +33,7 @@ MATHEMATICAL_FUNCTIONS: list[str] = [
     "Max",
     "Min",
     "mod_inverse",
+    "Mod",
 ]
 SPECIAL_FUNCTIONS: list[str] = [
     "erf",

classiq/interface/generator/functions/classical_type.py

@@ -6,6 +6,9 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -94,7 +97,9 @@ class ClassicalList(ClassicalType):
         return values_with_discriminator(values, "kind", "list")
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        raise NotImplementedError
+        return ClassicalArrayProxy(
+            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
+        )
 
     @property
     def expressions(self) -> list[Expression]:

classiq/interface/generator/functions/type_name.py

@@ -9,6 +9,9 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
     ClassicalStructProxy,
 )
@@ -109,8 +112,10 @@ class TypeName(ClassicalType, QuantumType):
         self._classical_struct_decl = decl
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        if self._classical_struct_decl is None:
-            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        if self.is_enum:
+            return ClassicalScalarProxy(handle, self)
+        if TYPE_CHECKING:
+            assert self._classical_struct_decl is not None
         return ClassicalStructProxy(handle, self._classical_struct_decl)
 
     @property

classiq/interface/generator/functions/type_qualifier.py

@@ -1,7 +1,22 @@
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
 class TypeQualifier(StrEnum):
     Const = "const"
     QFree = "qfree"
     Quantum = "quantum"
+    Inferred = "inferred"
+
+    @staticmethod
+    def and_(first: "TypeQualifier", second: "TypeQualifier") -> "TypeQualifier":
+        if second is TypeQualifier.Inferred:
+            raise ClassiqInternalExpansionError
+        if first is TypeQualifier.Quantum or second is TypeQualifier.Quantum:
+            return TypeQualifier.Quantum
+        elif first is TypeQualifier.QFree or second is TypeQualifier.QFree:
+            return TypeQualifier.QFree
+        else:
+            if first is not TypeQualifier.Const and second is not TypeQualifier.Const:
+                raise ClassiqInternalExpansionError("Unexpected type qualifiers")
+            return TypeQualifier.Const

classiq/interface/generator/model/preferences/preferences.py

@@ -102,6 +102,13 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         debug_mode (bool): If `True`, debug information is added to the
             synthesized result, potentially slowing down the synthesis. Useful for
             executing interactive algorithms. Defaults to `True`.
+        optimization_level (OptimizationLevel) : The optimization level used during synthesis (0-3);
+        determines the trade-off between synthesis speed and the quality of the results. Defaults to 3.
+             OptimizationLevel Options:
+                - NONE = 0
+                - LIGHT = 1
+                - MEDIUM = 2
+                - HIGH = 3
         output_format (List[QuantumFormat]): Lists the output format(s)
             for the quantum circuit. Defaults to `[QuantumFormat.QASM]`.
             `QuantumFormat` Options:

classiq/interface/generator/quantum_program.py

@@ -1,11 +1,9 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 import pydantic
-from pydantic import model_validator
-from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
 from classiq.interface.compression_utils import decompress
@@ -39,8 +37,6 @@ from classiq.interface.ide.visual_model import CircuitMetrics
 RegisterName: TypeAlias = str
 InitialConditions: TypeAlias = dict[RegisterName, int]
 
-OMIT_DEBUG_INFO_FLAG = "omit_debug_info"
-
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
@@ -77,18 +73,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
-    @model_validator(mode="before")
-    @classmethod
-    def remove_debug_info(
-        cls, data: dict[str, Any], info: ValidationInfo
-    ) -> dict[str, Any]:
-        if (
-            isinstance(data, dict)
-            and info.context is not None
-            and info.context.get(OMIT_DEBUG_INFO_FLAG, False)
-        ):
-            data.pop("debug_info", None)
-        return data
+    def __str__(self) -> str:
+        return self.model_dump_json(indent=2)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
@@ -177,7 +163,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             file.write(self.model_dump_json(indent=4))
 
     @classmethod
-    def from_qprog(cls, qprog: str) -> "QuantumProgram":
+    def from_qprog(cls, qprog: "QuantumProgram") -> "QuantumProgram":
         """
         Creates a `QuantumProgram` instance from a raw quantum program string.
 
@@ -187,7 +173,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         Returns:
             QuantumProgram: The `QuantumProgram` instance.
         """
-        return cls.model_validate_json(qprog)
+        return qprog
 
     @property
     def _can_use_transpiled_code(self) -> bool:

classiq/interface/helpers/backward_compatibility.py

@@ -0,0 +1,9 @@
+import sys
+from typing import Any
+
+if sys.version_info[0:2] >= (3, 10):
+    zip_strict = zip
+else:
+
+    def zip_strict(*iterables: Any, strict: bool = False) -> zip:
+        return zip(*iterables)

classiq/interface/helpers/datastructures.py

@@ -17,6 +17,12 @@ class LenList(list):
     def len(self) -> int:
         return len(self)
 
+    def __getitem__(self, item: Any) -> Any:
+        res = super().__getitem__(item)
+        if isinstance(item, slice):
+            res = type(self)(res)
+        return res
+
 
 def get_sdk_compatible_python_object(obj: Any) -> Any:
     if isinstance(obj, list):

classiq/interface/model/port_declaration.py

@@ -16,8 +16,7 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    # TODO remove default after BWC-breaking version
-    type_qualifier: TypeQualifier = pydantic.Field(default=TypeQualifier.Quantum)
+    type_qualifier: TypeQualifier
     kind: Literal["PortDeclaration"]
 
     @pydantic.model_validator(mode="before")