classiq 0.58.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -113,14 +113,19 @@ class ApiWrapper:
         return _parse_job_response(result, generator_result.QuantumProgram)
 
     @classmethod
-    async def call_execute_generated_circuit(
+    async def call_convert_quantum_program(
         cls, circuit: generator_result.QuantumProgram
-    ) -> execution_request.ExecutionJobDetails:
-        execution_input = await cls._call_task_pydantic(
+    ) -> dict:
+        return await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
         )
+
+    @classmethod
+    async def call_execute_execution_input(
+        cls, execution_input: dict
+    ) -> execution_request.ExecutionJobDetails:
         headers = {
             _ACCEPT_HEADER: "v1",
             _CONTENT_TYPE_HEADER: execution_input["version"],

classiq/_internals/jobs.py

@@ -45,9 +45,9 @@ def _general_job_description_parser(
 
 
 class JobPoller:
-    INITIAL_INTERVAL_SEC = 1
-    INTERVAL_FACTOR = 2
-    FINAL_INTERVAL_SEC = INITIAL_INTERVAL_SEC * INTERVAL_FACTOR**5  # 32 secs
+    INITIAL_INTERVAL_SEC = 0.1
+    INTERVAL_FACTOR = 1.5
+    FINAL_INTERVAL_SEC = 25
     DEV_INTERVAL = 0.05
 
     def __init__(
@@ -107,8 +107,6 @@ class JobPoller:
             while True:
                 yield self.DEV_INTERVAL
         else:
-            for _ in range(10):
-                yield self.INITIAL_INTERVAL_SEC
             interval = self.INITIAL_INTERVAL_SEC
             while True:
                 yield interval

classiq/execution/execution_session.py

@@ -1,4 +1,5 @@
 import json
+from functools import cached_property
 from typing import Any, Callable, Optional, Union, cast
 
 import numpy as np
@@ -15,12 +16,13 @@ from classiq.interface.executor.result import (
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import QuantumProgram
 
+from classiq._internals import async_utils
+from classiq._internals.api_wrapper import ApiWrapper
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
     _pauli_dict_to_pauli_terms,
     _pauli_terms_to_qmod,
 )
 from classiq.execution.jobs import ExecutionJob
-from classiq.executor import execute
 from classiq.qmod.builtins import PauliTerm
 from classiq.qmod.builtins.classical_execution_primitives import (
     CARRAY_SEPARATOR,
@@ -158,14 +160,28 @@ class ExecutionSession:
     ):
         self.program: QuantumProgram = _deserialize_program(quantum_program)
         self.update_execution_preferences(execution_preferences)
+        # When the primitives are called, we always override the
+        # classical_execution_code, and we don't want the conversion route to fail
+        # because cmain is expected in some cases
+        self.program.model.classical_execution_code = "dummy"
 
-    @property
-    def qprog(self) -> SerializedQuantumProgram:
-        """
-        Returns:
-            SerializedQuantumProgram: The serialized quantum program (str). See `QuantumProgram`.
-        """
-        return SerializedQuantumProgram(self.program.model_dump_json(indent=2))
+    @cached_property
+    def _execution_input(self) -> dict:
+        return async_utils.run(ApiWrapper.call_convert_quantum_program(self.program))
+
+    def _execute(
+        self, classical_execution_code: str, primitives_input: PrimitivesInput
+    ) -> ExecutionJob:
+        execution_input = self._execution_input.copy()
+        execution_input["classical_execution_code"] = classical_execution_code
+        # The use of `model_dump_json` is necessary for complex numbers serialization
+        execution_input["primitives_input"] = json.loads(
+            primitives_input.model_dump_json()
+        )
+        result = async_utils.run(
+            ApiWrapper.call_execute_execution_input(execution_input)
+        )
+        return ExecutionJob(details=result)
 
     def update_execution_preferences(
         self, execution_preferences: Optional[ExecutionPreferences]
@@ -210,13 +226,13 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             sample=[parse_params(parameters)] if parameters is not None else [{}]
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def batch_sample(self, parameters: list[ExecutionParams]) -> list[ExecutionDetails]:
         """
@@ -244,13 +260,13 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             sample=[parse_params(params) for params in parameters]
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def estimate(
         self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
@@ -284,12 +300,12 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.ESTIMATE,
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
                 parameters=(
@@ -297,7 +313,7 @@ class ExecutionSession:
                 ),
             )
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def batch_estimate(
         self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
@@ -331,18 +347,18 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
-        self.program.model.classical_execution_code = generate_code_snippet(
+        classical_execution_code = generate_code_snippet(
             SupportedPrimitives.BATCH_ESTIMATE,
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
-        self.program.execution_primitives_input = PrimitivesInput(
+        execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
                 parameters=[parse_params(params) for params in parameters],
             )
         )
-        return execute(SerializedQuantumProgram(self.qprog))
+        return self._execute(classical_execution_code, execution_primitives_input)
 
     def estimate_cost(
         self,

classiq/executor.py

@@ -32,7 +32,8 @@ def _parse_serialized_qprog(
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     circuit = _parse_serialized_qprog(quantum_program)
-    result = await ApiWrapper.call_execute_generated_circuit(circuit)
+    execution_input = await ApiWrapper.call_convert_quantum_program(circuit)
+    result = await ApiWrapper.call_execute_execution_input(execution_input)
     return ExecutionJob(details=result)
 
 

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.58.0'
+SEMVER_VERSION = '0.59.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/generator/arith/arithmetic_operations.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.arith.machine_precision import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
+IMPLICIT_OUTPUTS: Final[str] = "implicit_outputs"
 DEFAULT_GARBAGE_OUT_NAME: Final[str] = "extra_qubits"
 MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
     "Modulo with fraction places not supported"

classiq/interface/generator/register_role.py

@@ -29,3 +29,11 @@ class RegisterRole(StrEnum):
             RegisterRole.AUXILIARY,
             RegisterRole.EXPLICIT_ZERO_INPUT,
         }
+
+    @staticmethod
+    def clean_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.ZERO_OUTPUT, RegisterRole.AUXILIARY}
+
+    @staticmethod
+    def dirty_output_roles() -> set["RegisterRole"]:
+        return {RegisterRole.OUTPUT, RegisterRole.GARBAGE_OUTPUT}

classiq/interface/model/handle_binding.py

@@ -19,6 +19,10 @@ class HandleBinding(ASTNode):
     def __str__(self) -> str:
         return self.name
 
+    @property
+    def qmod_expr(self) -> str:
+        return self.name
+
     def is_bindable(self) -> bool:
         return True
 
@@ -57,6 +61,9 @@ class HandleBinding(ASTNode):
             return replacement
         return self
 
+    def __contains__(self, other_handle: "HandleBinding") -> bool:
+        return self.collapse() in other_handle.collapse().prefixes()
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -66,8 +73,8 @@ class NestedHandleBinding(HandleBinding):
     def _set_name(cls, values: Any) -> dict[str, Any]:
         if isinstance(values, dict):
             orig = values
-            while "base_handle" in values:
-                values = values["base_handle"]
+            while "base_handle" in dict(values):
+                values = dict(values)["base_handle"]
             orig["name"] = dict(values).get("name")
             return orig
         if isinstance(values, NestedHandleBinding):
@@ -106,6 +113,10 @@ class SubscriptHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.index}]"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.index}]"
+
     @property
     def identifier(self) -> str:
         return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.index}"
@@ -157,6 +168,10 @@ class SlicedHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}[{self.start}:{self.end}]"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.start}:{self.end}]"
+
     @property
     def identifier(self) -> str:
         return (
@@ -165,7 +180,7 @@ class SlicedHandleBinding(NestedHandleBinding):
 
     def collapse(self) -> HandleBinding:
         if isinstance(self.base_handle, SlicedHandleBinding):
-            return SubscriptHandleBinding(
+            return SlicedHandleBinding(
                 base_handle=self.base_handle.base_handle,
                 start=self._get_collapsed_start(),
                 end=self._get_collapsed_stop(),
@@ -224,6 +239,10 @@ class FieldHandleBinding(NestedHandleBinding):
     def __str__(self) -> str:
         return f"{self.base_handle}.{self.field}"
 
+    @property
+    def qmod_expr(self) -> str:
+        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+
     @property
     def identifier(self) -> str:
         return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.field}"

classiq/model_expansions/capturing/captured_vars.py

@@ -0,0 +1,316 @@
+import dataclasses
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_type import QuantumType
+
+from classiq.model_expansions.capturing.mangling_utils import (
+    demangle_handle,
+    mangle_captured_var_name,
+)
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.closure import FunctionClosure
+
+
+class PortDirection(StrEnum):
+    Input = "input"
+    Inout = "inout"
+    Output = "output"
+    Outin = "outin"
+
+    def negate(self) -> "PortDirection":
+        if self == PortDirection.Input:
+            return PortDirection.Output
+        if self == PortDirection.Output:
+            return PortDirection.Input
+        return self
+
+    @staticmethod
+    def load(direction: PortDeclarationDirection) -> "PortDirection":
+        if direction == PortDeclarationDirection.Input:
+            return PortDirection.Input
+        if direction == PortDeclarationDirection.Output:
+            return PortDirection.Output
+        if direction == PortDeclarationDirection.Inout:
+            return PortDirection.Inout
+        raise ClassiqInternalExpansionError
+
+    def dump(self) -> PortDeclarationDirection:
+        if self == PortDirection.Input:
+            return PortDeclarationDirection.Input
+        if self == PortDirection.Output:
+            return PortDeclarationDirection.Output
+        if self == PortDirection.Inout:
+            return PortDeclarationDirection.Inout
+        raise ClassiqInternalExpansionError
+
+
+@dataclass(frozen=True)
+class _CapturedHandle:
+    handle: HandleBinding
+    quantum_type: QuantumType
+    defining_function: "FunctionClosure"
+    direction: PortDirection
+    is_propagated: bool
+
+    @property
+    def mangled_name(self) -> str:
+        return mangle_captured_var_name(self.handle.identifier, self.defining_function)
+
+    @property
+    def port(self) -> PortDeclaration:
+        return PortDeclaration(
+            name=self.mangled_name,
+            quantum_type=self.quantum_type,
+            direction=self.direction.dump(),
+        )
+
+    def is_same_var(self, other: "_CapturedHandle") -> bool:
+        return self.handle.name == other.handle.name and _same_closure(
+            self.defining_function, other.defining_function
+        )
+
+    def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
+        return dataclasses.replace(self, direction=new_direction)
+
+    def set_propagated(self) -> "_CapturedHandle":
+        return dataclasses.replace(self, is_propagated=True)
+
+    def update_propagation(
+        self, other_captured_handle: "_CapturedHandle"
+    ) -> "_CapturedHandle":
+        if self.is_propagated and not other_captured_handle.is_propagated:
+            return dataclasses.replace(self, is_propagated=False)
+        return self
+
+
+@dataclass
+class CapturedVars:
+    _captured_handles: list[_CapturedHandle] = field(default_factory=list)
+
+    def capture_handle(
+        self,
+        handle: HandleBinding,
+        quantum_type: QuantumType,
+        defining_function: "FunctionClosure",
+        direction: PortDeclarationDirection,
+    ) -> None:
+        self._capture_handle(
+            _CapturedHandle(
+                handle=handle,
+                quantum_type=quantum_type,
+                defining_function=defining_function,
+                direction=PortDirection.load(direction),
+                is_propagated=False,
+            )
+        )
+
+    def _capture_handle(self, captured_handle: _CapturedHandle) -> None:
+        if (
+            isinstance(captured_handle.handle, NestedHandleBinding)
+            and captured_handle.direction != PortDirection.Inout
+        ):
+            raise ClassiqInternalExpansionError("Captured nested handles must be inout")
+
+        new_captured_handles = []
+        for existing_captured_handle in self._captured_handles:
+            if not existing_captured_handle.is_same_var(captured_handle):
+                new_captured_handles.append(existing_captured_handle)
+                continue
+            captured_handle = captured_handle.update_propagation(
+                existing_captured_handle
+            )
+            if existing_captured_handle.handle == captured_handle.handle:
+                captured_handle = self._conjugate_direction(
+                    existing_captured_handle, captured_handle
+                )
+            elif captured_handle.handle in existing_captured_handle.handle:
+                if existing_captured_handle.direction in (
+                    PortDirection.Input,
+                    PortDirection.Outin,
+                ):
+                    raise ClassiqInternalExpansionError(
+                        "Captured handle is already freed"
+                    )
+                captured_handle = existing_captured_handle
+            elif existing_captured_handle.handle in captured_handle.handle:
+                if captured_handle.direction in (
+                    PortDirection.Output,
+                    PortDirection.Outin,
+                ):
+                    raise ClassiqInternalExpansionError(
+                        "Captured handle is already allocated"
+                    )
+            else:
+                new_captured_handles.append(existing_captured_handle)
+        new_captured_handles.append(captured_handle)
+        self._captured_handles = new_captured_handles
+
+    def _conjugate_direction(
+        self,
+        existing_captured_handle: _CapturedHandle,
+        captured_handle: _CapturedHandle,
+    ) -> _CapturedHandle:
+        if existing_captured_handle.direction == PortDirection.Input:
+            if captured_handle.direction == PortDirection.Output:
+                return captured_handle.change_direction(PortDirection.Inout)
+            if captured_handle.direction == PortDirection.Outin:
+                return captured_handle.change_direction(PortDirection.Input)
+            raise ClassiqInternalExpansionError("Captured handle is already freed")
+        if existing_captured_handle.direction == PortDirection.Output:
+            if captured_handle.direction == PortDirection.Input:
+                return captured_handle.change_direction(PortDirection.Outin)
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqInternalExpansionError(
+                    "Captured handle is already allocated"
+                )
+            return captured_handle.change_direction(PortDirection.Output)
+        if existing_captured_handle.direction == PortDirection.Inout:
+            if captured_handle.direction in (
+                PortDirection.Output,
+                PortDirection.Outin,
+            ):
+                raise ClassiqInternalExpansionError(
+                    "Captured handle is already allocated"
+                )
+        elif captured_handle.direction in (
+            PortDirection.Input,
+            PortDirection.Inout,
+        ):
+            raise ClassiqInternalExpansionError("Captured handle is already freed")
+        return captured_handle
+
+    def update(self, other_captured_vars: "CapturedVars") -> None:
+        for captured_handle in other_captured_vars._captured_handles:
+            self._capture_handle(captured_handle)
+
+    def negate(self) -> "CapturedVars":
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle.change_direction(captured_handle.direction.negate())
+                for captured_handle in self._captured_handles
+            ]
+        )
+
+    def filter(self, current_function: "FunctionClosure") -> "CapturedVars":
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle
+                for captured_handle in self._captured_handles
+                if not _same_closure(
+                    captured_handle.defining_function, current_function
+                )
+            ]
+        )
+
+    def set_propagated(self) -> "CapturedVars":
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle.set_propagated()
+                for captured_handle in self._captured_handles
+            ]
+        )
+
+    def get_captured_ports(self) -> list[PortDeclaration]:
+        return [captured_handle.port for captured_handle in self._captured_handles]
+
+    def get_captured_args(
+        self, current_function: "FunctionClosure"
+    ) -> list[HandleBinding]:
+        return [
+            (
+                captured_handle.handle
+                if _same_closure(current_function, captured_handle.defining_function)
+                else HandleBinding(name=captured_handle.mangled_name)
+            )
+            for captured_handle in self._captured_handles
+        ]
+
+    def get_captured_mapping(self) -> SymbolParts:
+        return {
+            QuantumSymbol(
+                handle=captured_handle.handle,
+                quantum_type=captured_handle.quantum_type,
+            ): [
+                SymbolPart(
+                    source_handle=captured_handle.handle,
+                    target_var_name=captured_handle.mangled_name,
+                    target_var_type=captured_handle.quantum_type,
+                )
+            ]
+            for captured_handle in self._captured_handles
+            if not captured_handle.is_propagated
+        }
+
+    @contextmanager
+    def freeze(self) -> Iterator[None]:
+        previous = self._captured_handles
+        yield
+        self._captured_handles = previous
+
+
+def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
+    return closure_1.depth == closure_2.depth
+
+
+def validate_args_are_not_propagated(
+    args: Sequence[ArgValue], captured_vars: Sequence[HandleBinding]
+) -> None:
+    if not captured_vars:
+        return
+    captured_handles = {demangle_handle(handle) for handle in captured_vars}
+    arg_handles = {
+        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
+    }
+    if any(
+        arg_handle.overlaps(captured_handle)
+        for arg_handle in arg_handles
+        for captured_handle in captured_handles
+    ):
+        captured_handles_str = {str(handle) for handle in captured_handles}
+        arg_handles_str = {str(handle) for handle in arg_handles}
+        vars_msg = f"Explicitly passed variables: {arg_handles_str}, captured variables: {captured_handles_str}"
+        raise ClassiqExpansionError(
+            f"Cannot capture variables that are explicitly passed as arguments. "
+            f"{vars_msg}"
+        )
+
+
+def validate_captured_directions(captured_vars: CapturedVars) -> None:
+    captured_inputs = [
+        captured_handle.handle.name
+        for captured_handle in captured_vars._captured_handles
+        if captured_handle.direction == PortDirection.Input
+    ]
+    captured_outputs = [
+        captured_handle.handle.name
+        for captured_handle in captured_vars._captured_handles
+        if captured_handle.direction == PortDirection.Output
+    ]
+    if len(captured_inputs) > 0:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {captured_inputs!r} cannot be used as inputs"
+        )
+    if len(captured_outputs) > 0:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {captured_outputs!r} cannot be used as outputs"
+        )

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,17 +1,25 @@
 import re
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.closure import FunctionClosure
+
 IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
 CAPTURE_PATTERN = re.compile(
-    rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__"
+    rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__\d*"
 )
 ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
 
-def mangle_captured_var_name(var_name: str, defining_function: str) -> str:
-    return f"{var_name}{CAPTURE_SUFFIX}{defining_function}__"
+def mangle_captured_var_name(
+    var_name: str, defining_function: "FunctionClosure"
+) -> str:
+    return (
+        f"{var_name}{CAPTURE_SUFFIX}{defining_function.name}__{defining_function.depth}"
+    )
 
 
 def demangle_name(name: str) -> str:
@@ -25,15 +33,16 @@ def demangle_handle(handle: HandleBinding) -> HandleBinding:
         return handle
     if ARRAY_CAST_SUFFIX in name:
         return HandleBinding(name=name.split(ARRAY_CAST_SUFFIX)[0])
-    name = re.sub(r"_\d+$", "", name)
+    name = re.sub(r"([^_])_\d+$", r"\1", name)
     name_parts = name.split(HANDLE_ID_SEPARATOR)
-    new_name = name_parts[0]
+    new_name_parts = [name_parts[0]]
     for part in name_parts[1:]:
         if re.fullmatch(r"\d+", part):
-            new_name += f"[{part}]"
+            new_name_parts.append(f"[{part}]")
         elif re.fullmatch(r"\d+_\d+", part):
             part_left, part_right = part.split("_")
-            new_name += f"[{part_left}:{part_right}]"
+            new_name_parts.append(f"[{part_left}:{part_right}]")
         else:
-            new_name += f".{part}"
-    return handle.rename(new_name)
+            new_name_parts.append(f".{part}")
+    new_name_parts = list(map(demangle_name, new_name_parts))
+    return handle.rename("".join(new_name_parts))