Remove parametric calibration workaround

src/braket/circuits/circuit.py

@@ -1251,7 +1251,7 @@ def _validate_gate_calibrations_uniqueness(
         frames: dict[str, Frame],
         waveforms: dict[str, Waveform],
     ) -> None:
-        for _key, calibration in gate_definitions.items():
+        for calibration in gate_definitions.values():
             for frame in calibration._frames.values():
                 _validate_uniqueness(frames, frame)
                 frames[frame.id] = frame
@@ -1264,7 +1264,7 @@ def _generate_frame_wf_defcal_declarations(
     ) -> str | None:
         """Generates the header where frames, waveforms and defcals are declared.
 
-        It also adds any FreeParameter of the calibrations to the circuit parameter set.
+        It also adds any FreeParameter that is not a gate argument to the circuit parameter set.
 
         Args:
             gate_definitions (dict[tuple[Gate, QubitSet], PulseSequence] | None): The
@@ -1289,21 +1289,12 @@ def _generate_frame_wf_defcal_declarations(
 
             for key, calibration in gate_definitions.items():
                 gate, qubits = key
-
-                # Ignoring parametric gates
-                # Corresponding defcals with fixed arguments have been added
-                # in _get_frames_waveforms_from_instrs
-                if isinstance(gate, Parameterizable) and any(
-                    not isinstance(parameter, (float, int, complex))
-                    for parameter in gate.parameters
-                ):
-                    continue
-
                 gate_name = gate._qasm_name
                 arguments = gate.parameters if isinstance(gate, Parameterizable) else []
 
                 for param in calibration.parameters:
-                    self._parameters.add(param)
+                    if param not in arguments:
+                        self._parameters.add(param)
                 arguments = [
                     param._to_oqpy_expression() if isinstance(param, FreeParameter) else param
                     for param in arguments
@@ -1334,80 +1325,8 @@ def _get_frames_waveforms_from_instrs(
                 for waveform in instruction.operator.pulse_sequence._waveforms.values():
                     _validate_uniqueness(waveforms, waveform)
                     waveforms[waveform.id] = waveform
-            # this will change with full parametric calibration support
-            elif isinstance(instruction.operator, Parameterizable):
-                fixed_argument_calibrations = self._add_fixed_argument_calibrations(
-                    gate_definitions, instruction
-                )
-                gate_definitions.update(fixed_argument_calibrations)
         return frames, waveforms
 
-    def _add_fixed_argument_calibrations(
-        self,
-        gate_definitions: dict[tuple[Gate, QubitSet], PulseSequence],
-        instruction: Instruction,
-    ) -> dict[tuple[Gate, QubitSet], PulseSequence]:
-        """Adds calibrations with arguments set to the instruction parameter values
-
-        Given the collection of parameters in instruction.operator, this function looks for matching
-        parametric calibrations that have free parameters. If such a calibration is found and the
-        number N of its free parameters equals the number of instruction parameters, we can bind
-        the arguments of the calibration and add it to the calibration dictionary.
-
-        If N is smaller, it is probably impossible to assign the instruction parameter values to the
-        corresponding calibration parameters so we raise an error.
-        If N=0, we ignore it as it will not be removed by _generate_frame_wf_defcal_declarations.
-
-        Args:
-            gate_definitions (dict[tuple[Gate, QubitSet], PulseSequence]): a dictionary of
-                calibrations
-            instruction (Instruction): a Circuit instruction
-
-        Returns:
-            dict[tuple[Gate, QubitSet], PulseSequence]: additional calibrations
-
-        Raises:
-            NotImplementedError: in two cases: (i) if the instruction contains unbound parameters
-                and the calibration dictionary contains a parametric calibration applicable to this
-                instructions; (ii) if the calibration is defined with a partial number of unbound
-                parameters.
-        """
-        additional_calibrations = {}
-        for key, calibration in gate_definitions.items():
-            gate = key[0]
-            target = key[1]
-            if target != instruction.target:
-                continue
-            if isinstance(gate, type(instruction.operator)) and len(
-                instruction.operator.parameters
-            ) == len(gate.parameters):
-                free_parameter_number = sum(
-                    [isinstance(p, FreeParameterExpression) for p in gate.parameters]
-                )
-                if free_parameter_number == 0:
-                    continue
-                elif free_parameter_number < len(gate.parameters):
-                    raise NotImplementedError(
-                        "Calibrations with a partial number of fixed parameters are not supported."
-                    )
-                elif any(
-                    isinstance(p, FreeParameterExpression) for p in instruction.operator.parameters
-                ):
-                    raise NotImplementedError(
-                        "Parametric calibrations cannot be attached with parametric circuits."
-                    )
-                bound_key = (
-                    type(instruction.operator)(*instruction.operator.parameters),
-                    instruction.target,
-                )
-                additional_calibrations[bound_key] = calibration(
-                    **{
-                        p.name if isinstance(p, FreeParameterExpression) else p: v
-                        for p, v in zip(gate.parameters, instruction.operator.parameters)
-                    }
-                )
-        return additional_calibrations
-
     def to_unitary(self) -> np.ndarray:
         """Returns the unitary matrix representation of the entire circuit.