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

classiq/{applications_model_constructors → applications/finance}/finance_model_constructor.py

@@ -18,10 +18,10 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications_model_constructors.libraries.ampltitude_estimation_library import (
+from classiq.applications.libraries.ampltitude_estimation_library import (
     AE_CLASSICAL_LIBRARY,
 )
-from classiq.applications_model_constructors.libraries.qmci_library import QMCI_LIBRARY
+from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
 from classiq.exceptions import ClassiqError
 
 _OUTPUT_VARIABLE_NAME = "result"
@@ -75,16 +75,26 @@ def construct_finance_model(
                 },
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
+                    QuantumFunctionCall(
+                        function="allocate",
+                        positional_args=[
+                            Expression(expr=f"{num_unitary_qubits}"),
+                            HandleBinding(name="unitary_port"),
+                        ],
+                    ),
+                    QuantumFunctionCall(
+                        function="allocate_num",
+                        positional_args=[
+                            Expression(expr=f"{phase_port_size}"),
+                            Expression(expr="False"),
+                            Expression(expr=f"{phase_port_size}"),
+                            HandleBinding(name="phase_port"),
+                        ],
+                    ),
                     QuantumFunctionCall(
                         function="qmci",
-                        params={
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
-                            "num_unitary_qubits": Expression(
-                                expr=f"{num_unitary_qubits}"
-                            ),
-                        },
                         operands={
-                            "sp_op": QuantumLambdaFunction(
+                            "space_transform": QuantumLambdaFunction(
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
@@ -97,16 +107,16 @@ def construct_finance_model(
                                             ),
                                         },
                                         inouts={
-                                            "func_port": HandleBinding(name="reg"),
-                                            "obj_port": HandleBinding(name="ind"),
+                                            "func_port": HandleBinding(name="arg0"),
+                                            "obj_port": HandleBinding(name="arg1"),
                                         },
                                     ),
                                 ],
                             ),
                         },
-                        outputs={
-                            "phase_port": HandleBinding(name="phase_port"),
-                            "unitary_port": HandleBinding(name="unitary_port"),
+                        inouts={
+                            "phase": HandleBinding(name="phase_port"),
+                            "packed_vars": HandleBinding(name="unitary_port"),
                         },
                     ),
                 ],

classiq/applications/grover/__init__.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from .grover_model_constructor import construct_grover_model
+
+__all__ = [
+    "construct_grover_model",
+]
+
+
+def __dir__() -> List[str]:
+    return __all__

classiq/applications/libraries/qmci_library.py

@@ -0,0 +1,35 @@
+from typing import cast
+
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    QArray,
+    QBit,
+    QCallable,
+    QNum,
+    Z,
+    amplitude_estimation,
+    qfunc,
+)
+
+
+@qfunc
+def qmci(
+    space_transform: QCallable[QArray[QBit], QBit],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    amplitude_estimation(
+        lambda reg: Z(reg[reg.len - 1]),
+        lambda reg: space_transform(reg[0 : reg.len - 1], reg[reg.len - 1]),
+        phase,
+        packed_vars,
+    )
+
+
+QMCI_LIBRARY = [
+    cast(
+        NativeFunctionDefinition,
+        qmci.create_model().function_dict["qmci"],
+    ),
+]

classiq/applications/qsvm/__init__.py

@@ -4,5 +4,9 @@ from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
+from .qsvm_model_constructor import construct_qsvm_model
 
-__all__ = ["QSVMFeatureMapEntanglement"]
+__all__ = [
+    "QSVMFeatureMapEntanglement",
+    "construct_qsvm_model",
+]

classiq/execution/all_hardware_devices.py

@@ -0,0 +1,13 @@
+from typing import List
+
+from classiq.interface.hardware import HardwareInformation
+
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
+
+
+def get_all_hardware_devices() -> List[HardwareInformation]:
+    """
+    Returns a list of all hardware devices known to Classiq.
+    """
+    return async_utils.run(ApiWrapper.call_get_all_hardware_devices())

classiq/executor.py

@@ -29,9 +29,10 @@ from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq.execution.jobs import ExecutionJob
-from classiq.model.model import DEFAULT_RESULT_NAME
 from classiq.synthesis import SerializedQuantumProgram
 
+DEFAULT_RESULT_NAME = "result"
+
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
 ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.38.0'
+SEMVER_VERSION = '0.40.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/result.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Literal, Optional, Set, Tuple, Union
 from uuid import UUID
 
 import pydantic
-from pydantic import AnyHttpUrl, Field
+from pydantic import Field
 from typing_extensions import Annotated
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
@@ -41,10 +41,6 @@ class QasmCode(pydantic.BaseModel):
     code: str
 
 
-class PreSignedS3Url(VersionedModel):
-    url: AnyHttpUrl
-
-
 class AnalysisStatus(StrEnum):
     NONE = "none"
     SUCCESS = "success"

classiq/interface/applications/qsvm.py

@@ -103,11 +103,13 @@ class QSVMData(VersionedModel):
         extra = "forbid"
 
     @pydantic.validator("data", pre=True)
-    def set_data(cls, data):
+    def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
         return listify(data)
 
     @pydantic.validator("labels", pre=True)
-    def set_labels(cls, labels):
+    def set_labels(
+        cls, labels: Optional[Union[IterableType, ArrayLike]]
+    ) -> Optional[list]:
         if labels is None:
             return None
         else:

classiq/interface/ast_node.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import pydantic
+
+from classiq.interface.helpers.hashable_pydantic_base_model import (
+    HashablePydanticBaseModel,
+)
+
+
+class SourceReference(pydantic.BaseModel):
+    start_line: int
+    start_column: int
+    end_line: int
+    end_column: int
+    file_name: Optional[str] = pydantic.Field(default=None)
+
+
+class ASTNode(pydantic.BaseModel):
+    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
+
+
+class HashableASTNode(ASTNode, HashablePydanticBaseModel):
+    pass

classiq/interface/backend/backend_preferences.py

@@ -12,8 +12,8 @@ from classiq.interface.backend.quantum_backend_providers import (
     AliceBobBackendNames,
     AmazonBraketBackendNames,
     AzureQuantumBackendNames,
-    ClassiqAerBackendNames,
     ClassiqNvidiaBackendNames,
+    ClassiqSimulatorBackendNames,
     IonqBackendNames,
     OQCBackendNames,
     ProviderTypeVendor,
@@ -56,7 +56,7 @@ class BackendPreferences(BaseModel):
         return False
 
 
-AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=5).total_seconds())
+AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=240).total_seconds())
 
 
 class AliceBobBackendPreferences(BackendPreferences):
@@ -221,13 +221,13 @@ def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
 
 
 def default_backend_preferences(
-    backend_name: str = ClassiqAerBackendNames.AER_SIMULATOR,
+    backend_name: str = ClassiqSimulatorBackendNames.SIMULATOR,
 ) -> BackendPreferences:
     return ClassiqBackendPreferences(backend_name=backend_name)
 
 
 def backend_preferences_field(
-    backend_name: str = ClassiqAerBackendNames.AER_SIMULATOR,
+    backend_name: str = ClassiqSimulatorBackendNames.SIMULATOR,
 ) -> Any:
     return pydantic.Field(
         default_factory=lambda: default_backend_preferences(backend_name),
@@ -252,7 +252,7 @@ __all__ = [
     "AzureCredential",
     "AzureQuantumBackendNames",
     "ClassiqBackendPreferences",
-    "ClassiqAerBackendNames",
+    "ClassiqSimulatorBackendNames",
     "IBMBackendPreferences",
     "IBMBackendProvider",
     "AwsBackendPreferences",

classiq/interface/backend/quantum_backend_providers.py

@@ -31,11 +31,11 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
 
 
-class ClassiqAerBackendNames(StrEnum):
-    AER_SIMULATOR = "aer_simulator"
-    AER_SIMULATOR_STATEVECTOR = "aer_simulator_statevector"
-    AER_SIMULATOR_DENSITY_MATRIX = "aer_simulator_density_matrix"
-    AER_SIMULATOR_MATRIX_PRODUCT_STATE = "aer_simulator_matrix_product_state"
+class ClassiqSimulatorBackendNames(StrEnum):
+    SIMULATOR = "simulator"
+    SIMULATOR_STATEVECTOR = "simulator_statevector"
+    SIMULATOR_DENSITY_MATRIX = "simulator_density_matrix"
+    SIMULATOR_MATRIX_PRODUCT_STATE = "simulator_matrix_product_state"
 
 
 class IonqBackendNames(StrEnum):
@@ -141,7 +141,7 @@ class ClassiqNvidiaBackendNames(StrEnum):
     SIMULATOR = "nvidia_state_vector_simulator"
 
 
-AllClassiqBackendNames = Union[ClassiqAerBackendNames, ClassiqNvidiaBackendNames]
+AllClassiqBackendNames = Union[ClassiqSimulatorBackendNames, ClassiqNvidiaBackendNames]
 
 
 class GoogleNvidiaBackendNames(StrEnum):
@@ -166,7 +166,7 @@ EXACT_SIMULATORS = {
     AmazonBraketBackendNames.AMAZON_BRAKET_SV1,
     AmazonBraketBackendNames.AMAZON_BRAKET_TN1,
     AmazonBraketBackendNames.AMAZON_BRAKET_DM1,
-    *ClassiqAerBackendNames,
+    *ClassiqSimulatorBackendNames,
     *ClassiqNvidiaBackendNames,
 }
 

classiq/interface/combinatorial_optimization/examples/mht.py

@@ -3,6 +3,7 @@ from typing import Dict, Tuple
 
 import networkx as nx
 import pyomo.core as pyo
+import pyomo.core.expr.numeric_expr as pyo_expr
 
 Node = int
 Edge = Tuple[Node, Node]
@@ -22,7 +23,9 @@ def build_mht_pyomo_model(
     if has_constraints:
 
         @model.Constraint(model.Nodes)
-        def out_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        def out_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             out_nodes = [
                 node_id for node_id in model.Nodes if [idx, node_id] in model.Arcs
             ]
@@ -32,7 +35,9 @@ def build_mht_pyomo_model(
                 return pyo.Constraint.Feasible
 
         @model.Constraint(model.Nodes)
-        def in_edges_rule(model: pyo.ConcreteModel, idx: int) -> pyo.ExpressionBase:
+        def in_edges_rule(
+            model: pyo.ConcreteModel, idx: int
+        ) -> pyo_expr.ExpressionBase:
             in_nodes = [
                 node_id for node_id in model.Nodes if [node_id, idx] in model.Arcs
             ]
@@ -41,7 +46,7 @@ def build_mht_pyomo_model(
             else:
                 return pyo.Constraint.Feasible
 
-    def obj_expression(model: pyo.ConcreteModel) -> pyo.ExpressionBase:
+    def obj_expression(model: pyo.ConcreteModel) -> pyo_expr.ExpressionBase:
         return sum(
             round(pubo_energy, _decimals)
             * math.prod(model.x[edge] for edge in pubo_edges)

classiq/interface/executor/execution_preferences.py

@@ -10,8 +10,9 @@ from classiq.interface.backend.backend_preferences import (
     backend_preferences_field,
 )
 from classiq.interface.backend.pydantic_backend import MAX_EXECUTION_TIMEOUT_SECONDS
-from classiq.interface.backend.quantum_backend_providers import ClassiqAerBackendNames
-from classiq.interface.executor.error_mitigation import ErrorMitigationMethod
+from classiq.interface.backend.quantum_backend_providers import (
+    ClassiqSimulatorBackendNames,
+)
 from classiq.interface.executor.optimizer_preferences import (
     OptimizerPreferences,
     OptimizerType,
@@ -51,11 +52,6 @@ class ExecutionPreferences(pydantic.BaseModel):
         default_factory=None,
         description="Settings related to VQE execution.",
     )
-    error_mitigation_method: Optional[ErrorMitigationMethod] = pydantic.Field(
-        default=None,
-        description="Error mitigation method. Currently supports complete and tensored "
-        "measurement calibration.",
-    )
     noise_properties: Optional[NoiseProperties] = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
@@ -64,7 +60,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         description="The random seed used for the execution",
     )
     backend_preferences: BackendPreferencesTypes = backend_preferences_field(
-        backend_name=ClassiqAerBackendNames.AER_SIMULATOR
+        backend_name=ClassiqSimulatorBackendNames.SIMULATOR
     )
     num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
     transpile_to_hardware: TranspilationOption = pydantic.Field(
@@ -151,7 +147,6 @@ def _choose_original_or_optimizer_attribute(
 
 __all__ = [
     "ExecutionPreferences",
-    "ErrorMitigationMethod",
     "NoiseProperties",
     "OptimizerPreferences",
     "OptimizerType",

classiq/interface/executor/execution_request.py

@@ -1,21 +1,18 @@
 from datetime import datetime
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 
 import pydantic
 from pydantic import BaseModel, Field
 from typing_extensions import Annotated
 
-from classiq.interface.backend.backend_preferences import IonqBackendPreferences
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.quantum_code import QuantumCode, QuantumInstructionSet
+from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.generator.quantum_program import QuantumProgram
 from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
-from classiq.exceptions import ClassiqValueError
-
 
 class QuantumProgramExecution(QuantumProgram):
     execution_type: Literal["quantum_program2"] = "quantum_program2"
@@ -42,38 +39,6 @@ class ExecutionRequest(BaseModel, json_encoders=CUSTOM_ENCODERS):
         description="preferences for the execution",
     )
 
-    @pydantic.validator("preferences")
-    def validate_ionq_backend(
-        cls, preferences: ExecutionPreferences, values: Dict[str, Any]
-    ) -> ExecutionPreferences:
-        """
-        This function implement the following check:
-        BE \\ payload | IonQ program | Qasm program | Other
-        --------------|--------------|--------------|------
-        IonQ backend  |       V      |      V       |   X
-        Other backend |       X      |      V       |   V
-        Since:
-        - We can't execute non-programs on the IonQ backends
-        - We can't execute IonQ programs on non-IonQ backends
-        """
-        quantum_program = values.get("execution_payload")
-        is_ionq_backend = isinstance(
-            preferences.backend_preferences, IonqBackendPreferences
-        )
-        if isinstance(quantum_program, QuantumCode):
-            if (
-                quantum_program.syntax == QuantumInstructionSet.IONQ
-                and not is_ionq_backend
-            ):
-                raise ClassiqValueError("Can only execute IonQ code on IonQ backend.")
-        else:
-            # If we handle anything other than a program.
-            if is_ionq_backend:
-                raise ClassiqValueError(
-                    "IonQ backend supports only execution of QuantumPrograms"
-                )
-        return preferences
-
 
 class QuantumProgramExecutionRequest(ExecutionRequest):
     execution_payload: QuantumCodeExecution

classiq/interface/executor/vqe_result.py

@@ -63,7 +63,7 @@ class VQESolverResult(SolverResult, QmodPyObject):
         self.convergence_graph.show()
 
     @property
-    def convergence_graph(self):
+    def convergence_graph(self) -> Image.Image:
         return Image.open(io.BytesIO(base64.b64decode(self.convergence_graph_str)))
 
     @property

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -24,9 +24,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 MOLECULE_PROBLEM_PARAM = {"molecule_problem": Struct(name="MoleculeProblem")}
-MOLECULE_PROBLEM_SIZE = (
-    "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-)
+MOLECULE_PROBLEM_SIZE = "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
 MOLECULE_PROBLEM_PORT = {
     "qbv": PortDeclaration(
         name="qbv",
@@ -40,7 +38,7 @@ MOLECULE_PROBLEM_PORT = {
 FOCK_HAMILTONIAN_PROBLEM_PARAM = {
     "fock_hamiltonian_problem": Struct(name="FockHamiltonianProblem")
 }
-FOCK_HAMILTONIAN_SIZE = "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
+FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
 
 FOCK_HAMILTONIAN_PROBLEM_PORT = {
     "qbv": PortDeclaration(

classiq/interface/generator/application_apis/finance_declarations.py

@@ -31,7 +31,7 @@ class FinanceModelType(Enum):
 
 
 FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
-    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
+    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
     FinanceModelType.LogNormal: "get_field(finance_model, 'num_qubits')",
 }
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
 from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
 
@@ -174,6 +175,7 @@ class ExpressionValidator(ast.NodeVisitor):
         if not (
             isinstance(node.value, ast.Name)
             and node.value.id in self._supported_attr_values
+            or node.attr in CLASSICAL_ATTRIBUTES.keys()
         ):
             raise ClassiqValueError(
                 f"Attribute is not supported for value {node.value}"

classiq/interface/generator/builtin_api_builder.py

@@ -4,15 +4,10 @@ from classiq.interface.generator.functions.classical_function_declaration import
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
 
 
 def populate_builtin_declarations(decls: Iterable[Any]) -> None:
     for decl in decls:
-        if isinstance(decl, QuantumFunctionDeclaration):
-            QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, ClassicalFunctionDeclaration):
             ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, StructDeclaration):

classiq/interface/generator/constant.py

@@ -1,10 +1,9 @@
-import pydantic
-
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
 
 
-class Constant(pydantic.BaseModel):
+class Constant(ASTNode):
     name: str
     const_type: ConcreteClassicalType
     value: Expression

classiq/interface/generator/expressions/expression.py

@@ -4,6 +4,7 @@ from typing import Any, Mapping, Optional, Type
 import pydantic
 from pydantic import PrivateAttr
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
@@ -17,14 +18,11 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 from classiq.interface.generator.function_params import validate_expression_str
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 
 from classiq.exceptions import ClassiqError
 
 
-class Expression(HashablePydanticBaseModel):
+class Expression(HashableASTNode):
     expr: str
     _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
 

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -0,0 +1,82 @@
+from typing import Optional, Tuple, Union
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+from classiq.exceptions import ClassiqValueError
+
+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"
+QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
+
+
+class QmodQArrayProxy(QmodSizedProxy):
+    def __init__(
+        self,
+        name: str,
+        size: int,
+        slice_: Optional[Tuple[int, int]] = None,
+        index_: Optional[int] = None,
+    ) -> None:
+        super().__init__(size)
+        self._name = name
+        self._slice = slice_
+        self._index = index_
+
+    def __getitem__(self, key: Union[slice, int]) -> "QmodQArrayProxy":
+        if self._index is not None:
+            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+
+        new_index: Optional[int] = None
+
+        if isinstance(key, slice):
+            if key.step is not None:
+                raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+            new_slice = self._get_new_slice(key.start, key.stop)
+        else:
+            new_slice = self._get_new_slice(key, key + 1)
+            new_index = new_slice[0]
+
+        if (self._slice is not None and new_slice[1] > self._slice[1]) or new_slice[
+            1
+        ] > self._size:
+            raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
+
+        return QmodQArrayProxy(
+            self._name, self._size, slice_=new_slice, index_=new_index
+        )
+
+    def _get_new_slice(self, start: int, end: int) -> Tuple[int, int]:
+        if self._slice is not None:
+            return self._slice[0] + start, self._slice[0] + end
+        return start, end
+
+    @property
+    def index(self) -> Optional[int]:
+        return self._index
+
+    @property
+    def slice(self) -> Optional[Tuple[int, int]]:
+        return self._slice
+
+    @property
+    def handle(self) -> HandleBinding:
+        if self._index is not None:
+            return SubscriptHandleBinding(
+                name=self._name,
+                index=Expression(expr=str(self._index)),
+            )
+
+        if self._slice is not None:
+            return SlicedHandleBinding(
+                name=self._name,
+                start=Expression(expr=str(self._slice[0])),
+                end=Expression(expr=str(self._slice[1])),
+            )
+
+        return HandleBinding(name=self._name)