internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: PennyLaneAI/pennylane

Issue:
Allow QNodes to support `diff_method=None` option
As discussed in #1271 , add the option for `diff_method=None` to QNodes. This would create QNodes that accept NumPy input, return NumPy output, but cannot be differentiated.


Discussion:

Resolving patch:
diff --git a/pennylane/qnode.py b/pennylane/qnode.py
--- a/pennylane/qnode.py
+++ b/pennylane/qnode.py
@@ -106,6 +106,8 @@ class QNode:
             * ``"finite-diff"``: Uses numerical finite-differences for all quantum operation
               arguments.
 
+            * ``None``: QNode cannot be differentiated. Works the same as ``interface=None``.
+
         mutable (bool): If True, the underlying quantum circuit is re-constructed with
             every evaluation. This is the recommended approach, as it allows the underlying
             quantum structure to depend on (potentially trainable) QNode input arguments,
@@ -155,6 +157,13 @@ def __init__(
         **diff_options,
     ):
 
+        if diff_method is None:
+            # TODO: update this behaviour once the new differentiable pipeline is the default
+            # We set "best" to allow internals to work and leverage the interface = None
+            # feature to restrict differentiability
+            diff_method = "best"
+            interface = None
+
         if interface is not None and interface not in self.INTERFACE_MAP:
             raise qml.QuantumFunctionError(
                 f"Unknown interface {interface}. Interface must be "


Test patch:
diff --git a/tests/tape/test_qnode.py b/tests/tape/test_qnode.py
--- a/tests/tape/test_qnode.py
+++ b/tests/tape/test_qnode.py
@@ -330,6 +330,44 @@ def func(x):
             == "<QNode: wires=1, device='default.qubit.autograd', interface='autograd', diff_method='best'>"
         )
 
+    @pytest.mark.parametrize("par", [None, 1, 1.1, np.array(1.2)])
+    def test_diff_method_none(self, par):
+        """Test if diff_method=None works as intended."""
+        dev = qml.device("default.qubit", wires=1)
+
+        def func(x):
+            qml.RX(x, wires=0)
+            return qml.expval(qml.PauliZ(0))
+
+        qn = qml.QNode(func, dev, diff_method=None)
+        assert qn.interface is None
+
+        grad = qml.grad(qn)
+
+        # Raise error in all cases
+        # Case 1: No input
+        # Case 2: int input
+        # Case 3: float input
+        # Case 4: numpy input
+        with pytest.raises(TypeError) as exp:
+            grad() if par is None else grad(par)
+
+    def test_diff_method_none_no_qnode_param(self):
+        """Test if diff_method=None works as intended."""
+        dev = qml.device("default.qubit", wires=1)
+
+        def func():
+            qml.PauliX(wires=0)
+            return qml.expval(qml.PauliZ(0))
+
+        qn = qml.QNode(func, dev, diff_method=None)
+        assert qn.interface is None
+
+        grad = qml.grad(qn)
+
+        # No differentiation required. No error raised.
+        grad()
+
 
 class TestTapeConstruction:
     """Tests for the tape construction"""
Repository: PennyLaneAI/pennylane

Issue:
Casting to complex in Amplitude Embedding
If I do not batch the parameters in `qml.AmplitudeEmbedding`, the parameter is preprocessed to be `np.compex128`:

```
>>> data = np.random.random(8)
>>> op = qml.templates.AmplitudeEmbedding(data, wires=[0, 1, 2], normalize=True)
>>> op.parameters
[tensor([0.45477115+0.j, 0.01693656+0.j, 0.07562024+0.j, 0.54867405+0.j,
         0.36355761+0.j, 0.50257082+0.j, 0.31384676+0.j, 0.05369689+0.j], requires_grad=True)]
```

But if I add a batch dimension, an warning is raised:
```
pennylane/pennylane/templates/embeddings/amplitude.py:208: ComplexWarning: Casting complex values to real discards the imaginary part
```

and the resulting parameters are purely real:

```
>>> batch_size = 5
>>> data = np.random.random((batch_size, 8))
>>> op = qml.templates.AmplitudeEmbedding(data, wires=[0, 1, 2], normalize=True)
>>> op.parameters
[tensor([[0.0016901 , 0.5075714 , 0.54801605, 0.03162948, 0.55714217,
          0.20436995, 0.00293922, 0.29809946],
         [0.3872195 , 0.22144908, 0.23615862, 0.18293768, 0.24939231,
          0.34098754, 0.51028387, 0.52242283],
         [0.3192768 , 0.30626548, 0.14370121, 0.5928348 , 0.12077899,
          0.06004839, 0.05753843, 0.64082493],
         [0.63251121, 0.02695029, 0.31892484, 0.29212886, 0.08482609,
          0.29508076, 0.56160044, 0.04987735],
         [0.01995247, 0.3879382 , 0.04970833, 0.36439654, 0.54700921,
          0.41374685, 0.48902248, 0.06558638]], requires_grad=True)]
```

I came across this problem when trying to clean warnings from the transform tests, so it is not currently breaking anything, but I would consider it unexpected behaviour.


Discussion:

Resolving patch:
diff --git a/pennylane/templates/embeddings/amplitude.py b/pennylane/templates/embeddings/amplitude.py
--- a/pennylane/templates/embeddings/amplitude.py
+++ b/pennylane/templates/embeddings/amplitude.py
@@ -205,6 +205,6 @@ def _preprocess(features, wires, pad_with, normalize):
                         "Use 'normalize=True' to automatically normalize."
                     )
 
-            features_batch[i] = qml.math.cast(feature_set, np.complex128)
+            features_batch[i] = feature_set
 
-        return features_batch if batched else features_batch[0]
+        return qml.math.cast(features_batch if batched else features_batch[0], np.complex128)


Test patch:
Repository: PennyLaneAI/pennylane

Issue:
[BUG] `adjoint(adjoint(op))` returns identity
### Expected behavior

When queuing `adjoint(adjoint(op))` in a tape, op should be added

### Actual behavior

op and adjoint(op) are queued

### Additional information

Here is a simple example, where the original circuit contains an adjoint and is taken to a new circuit that executes the original and its adjoint, Since `adjoint(adjoint())` becomes identity, the original circuit is restored (instead of the identity, as expected:

```python
with qml.tape.QuantumTape() as circuit:
    qml.adjoint(qml.RX(0.5, wires=0))
    qml.expval(qml.PauliZ(0))

base_ops = circuit.expand().copy(copy_operations=True).operations

new_list_of_ops = [op for op in base_ops]
new_list_of_ops += [adjoint(op) for op in base_ops[::-1]]

with QuantumTape() as new_circuit:
    for op in new_list_of_ops:
        apply(op)

    for meas in circuit.measurements:
        apply(meas)

dev = qml.device("default.qubit", wires=range(2))
>>> print(qml.execute([circuit], dev, gradient_fn=None), qml.execute([new_circuit], dev, gradient_fn=None))
[array([0.87758256])] [array([0.87758256])]
```
But the latter should yield 1 since it is supposed to be the identity.

### Source code

_No response_

### Tracebacks

_No response_

### System information

```shell
0.24.0.dev0
```


### Existing GitHub issues

- [X] I have searched existing GitHub issues to make sure the issue does not already exist.


Discussion:

Resolving patch:
diff --git a/pennylane/ops/op_math/adjoint_class.py b/pennylane/ops/op_math/adjoint_class.py
--- a/pennylane/ops/op_math/adjoint_class.py
+++ b/pennylane/ops/op_math/adjoint_class.py
@@ -310,7 +310,7 @@ def has_matrix(self):
         return self.base.has_matrix
 
     def adjoint(self):
-        return self.base
+        return self.base.queue()
 
     @property
     def _queue_category(self):


Test patch:
diff --git a/tests/ops/op_math/test_adjoint_op.py b/tests/ops/op_math/test_adjoint_op.py
--- a/tests/ops/op_math/test_adjoint_op.py
+++ b/tests/ops/op_math/test_adjoint_op.py
@@ -608,6 +608,18 @@ def test_no_base_gate_decomposition(self):
         with pytest.raises(qml.operation.DecompositionUndefinedError):
             Adjoint(base).decomposition()
 
+    def test_adjoint_of_adjoint(self):
+        """Test that the adjoint an adjoint returns the base operator through both decomposition and expand."""
+
+        base = qml.PauliX(0)
+        adj1 = Adjoint(base)
+        adj2 = Adjoint(adj1)
+
+        assert adj2.decomposition()[0] is base
+
+        tape = adj2.expand()
+        assert tape.circuit[0] is base
+
 
 class TestIntegration:
     """Test the integration of the Adjoint class with qnodes and gradients."""
Repository: PennyLaneAI/pennylane

Issue:
[Docstring] Create a dedicated `QubitDevice.sample` docstring
### Expected behavior

The `QubitDevice.sample` docstring describes the method well.

### Actual behavior

The `QubitDevice.sample` docstring is the same as the `Device.sample` docstring. The two methods are different, however, in their work and `QubitDevice` uses arguments like `shot_range`, `bin_size`, `counts`. It would be great to have these be described.

### Additional information

The `QubitDevice.statistics` docstring can be used.

### Source code

_No response_

### Tracebacks

_No response_

### System information

```shell
PennyLane master
```


### Existing GitHub issues

- [X] I have searched existing GitHub issues to make sure the issue does not already exist.


Discussion:

Resolving patch:
diff --git a/pennylane/_qubit_device.py b/pennylane/_qubit_device.py
--- a/pennylane/_qubit_device.py
+++ b/pennylane/_qubit_device.py
@@ -973,6 +973,27 @@ def var(self, observable, shot_range=None, bin_size=None):
         return np.squeeze(np.var(samples, axis=0))
 
     def sample(self, observable, shot_range=None, bin_size=None, counts=False):
+        """Return samples of an observable.
+
+        Args:
+            observable (Observable): the observable to sample
+            shot_range (tuple[int]): 2-tuple of integers specifying the range of samples
+                to use. If not specified, all samples are used.
+            bin_size (int): Divides the shot range into bins of size ``bin_size``, and
+                returns the measurement statistic separately over each bin. If not
+                provided, the entire shot range is treated as a single bin.
+            counts (bool): whether counts (``True``) or raw samples (``False``)
+                should be returned
+
+        Raises:
+            EigvalsUndefinedError: if no information is available about the
+                eigenvalues of the observable
+
+        Returns:
+            Union[array[float], dict, list[dict]]: samples in an array of
+            dimension ``(shots,)`` or counts
+        """
+
         def _samples_to_counts(samples, no_observable_provided):
             """Group the obtained samples into a dictionary.
 


Test patch:
Repository: PennyLaneAI/pennylane

Issue:
[BUG] `qml.equal` ignore in-place inversion
Currently, we have:
```
>>> qml.equal(qml.RX(1.0, wires=0), qml.RX(1.0, wires=0).inv())
True
```

If two operations are inverses of each other, they should not be equal.


Discussion:

Resolving patch:
diff --git a/pennylane/ops/functions/equal.py b/pennylane/ops/functions/equal.py
--- a/pennylane/ops/functions/equal.py
+++ b/pennylane/ops/functions/equal.py
@@ -98,4 +98,4 @@ def equal(
             if qml.math.get_interface(params_1) != qml.math.get_interface(params_2):
                 return False
 
-    return True
+    return getattr(op1, "inverse", False) == getattr(op2, "inverse", False)


Test patch:
diff --git a/tests/ops/functions/test_equal.py b/tests/ops/functions/test_equal.py
--- a/tests/ops/functions/test_equal.py
+++ b/tests/ops/functions/test_equal.py
@@ -847,3 +847,15 @@ def test_equal_with_nested_operators_raises_error(self):
             + " depth larger than 0 is not yet implemented.",
         ):
             qml.equal(qml.adjoint(qml.PauliX(0)), qml.adjoint(qml.PauliX(0)))
+
+    def test_equal_same_inversion(self):
+        """Test operations are equal if they are both inverted."""
+        op1 = qml.RX(1.2, wires=0).inv()
+        op2 = qml.RX(1.2, wires=0).inv()
+        assert qml.equal(op1, op2)
+
+    def test_not_equal_different_inversion(self):
+        """Test operations are not equal if one is inverted and the other is not."""
+        op1 = qml.PauliX(0)
+        op2 = qml.PauliX(0).inv()
+        assert not qml.equal(op1, op2)
Repository: PennyLaneAI/pennylane

Issue:
[BUG] `ControlledQubitUnitary` behaves differently in `0.25` and `0.26`
### Expected behavior

Here is a minimal example with `v0.26`:

```python
U = qml.PauliX.compute_matrix() * (1.0j)

def subcircuit():
    qml.ControlledQubitUnitary(U @ U, control_wires=1, wires=2, control_values='0')

dev = qml.device("default.qubit", wires=3)
@qml.qnode(dev)
def circuit():
    qml.ctrl(subcircuit, control = 0, control_values=(0))()
    return qml.state()
```

```pycon
>>> circuit()
[-1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
```


### Actual behavior

Differing outputs with `0.25` and `0.26` and not sure why 🤔

```pycon
>>> circuit()
# v25: [1.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j]

# v26: [-1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
```

### Additional information

_No response_

### Source code

```shell
U = qml.PauliX.compute_matrix() * (1.0j)

def subcircuit():
    qml.ControlledQubitUnitary(U @ U, control_wires=1, wires=2, control_values='0')

dev = qml.device("default.qubit", wires=3)
@qml.qnode(dev)
def circuit():
    qml.ctrl(subcircuit, control = 0, control_values=(0))()
    return qml.state()
```


### Tracebacks

_No response_

### System information

```shell
Depends on PennyLane version
```


### Existing GitHub issues

- [X] I have searched existing GitHub issues to make sure the issue does not already exist.


Discussion:

Resolving patch:
diff --git a/pennylane/ops/qubit/matrix_ops.py b/pennylane/ops/qubit/matrix_ops.py
--- a/pennylane/ops/qubit/matrix_ops.py
+++ b/pennylane/ops/qubit/matrix_ops.py
@@ -374,8 +374,13 @@ def pow(self, z):
 
     def _controlled(self, wire):
         ctrl_wires = self.control_wires + wire
+        old_control_values = self.hyperparameters["control_values"]
+        values = None if old_control_values is None else f"{old_control_values}1"
         new_op = ControlledQubitUnitary(
-            *self.parameters, control_wires=ctrl_wires, wires=self.hyperparameters["u_wires"]
+            *self.parameters,
+            control_wires=ctrl_wires,
+            wires=self.hyperparameters["u_wires"],
+            control_values=values,
         )
         return new_op.inv() if self.inverse else new_op
 


Test patch:
diff --git a/tests/ops/qubit/test_matrix_ops.py b/tests/ops/qubit/test_matrix_ops.py
--- a/tests/ops/qubit/test_matrix_ops.py
+++ b/tests/ops/qubit/test_matrix_ops.py
@@ -889,9 +889,11 @@ def test_controlled(self, inverse):
 
         U = qml.PauliX(0).compute_matrix()
 
-        original = qml.ControlledQubitUnitary(U, control_wires=(0, 1), wires=4)
+        original = qml.ControlledQubitUnitary(U, control_wires=(0, 1), wires=4, control_values="01")
         original.inverse = inverse
-        expected = qml.ControlledQubitUnitary(U, control_wires=(0, 1, "a"), wires=4)
+        expected = qml.ControlledQubitUnitary(
+            U, control_wires=(0, 1, "a"), wires=4, control_values="011"
+        )
         expected.inverse = inverse
 
         out = original._controlled("a")
Repository: PennyLaneAI/pennylane

Issue:
[BUG] `qml.QNSPSAOptimizer` includes `op.adjoint` instead of `qml.adjoint(op)` in source
### Expected behavior

Circuit that includes `qml.RandomLayers` and uses `qml.QNSPSAOptimizer` executes normally.

### Actual behavior

Execution raises `AdjointUndefinedError`. Other optimizers execute fine.

### Additional information

`qml.QNSPSAOptimizer` includes `op.adjoint` in the source instead of `qml.adjoint(op)`, as spotted by @albi3ro 

Bug discovered by [Lucas Tecot on the PennyLane Discussion Forum](https://discuss.pennylane.ai/t/basisstate-raises-adjoint-undefined-error/2160/8).

### Source code

```shell
import pennylane as qml
from pennylane import numpy as plnp

num_qubits = 2
dev = qml.device("default.qubit", wires=num_qubits)
@qml.qnode(dev)
def cost(params):
    qml.RandomLayers(weights=params, wires=range(num_qubits), seed=42)
    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))

params = plnp.random.normal(0, plnp.pi, (2, 4))
opt = qml.QNSPSAOptimizer(stepsize=5e-2)
for i in range(51):
    params, loss = opt.step_and_cost(cost, params)
    if i % 10 == 0:
        print(f"Step {i}: cost = {loss:.4f}")
```


### Tracebacks

_No response_

### System information

```shell
(Not relevant here.)
```


### Existing GitHub issues

- [X] I have searched existing GitHub issues to make sure the issue does not already exist.


Discussion:

Resolving patch:
diff --git a/pennylane/optimize/qnspsa.py b/pennylane/optimize/qnspsa.py
--- a/pennylane/optimize/qnspsa.py
+++ b/pennylane/optimize/qnspsa.py
@@ -408,7 +408,7 @@ def _get_overlap_tape(self, cost, args1, args2, kwargs):
         op_forward = self._get_operations(cost, args1, kwargs)
         op_inv = self._get_operations(cost, args2, kwargs)
 
-        new_ops = op_forward + [op.adjoint() for op in reversed(op_inv)]
+        new_ops = op_forward + [qml.adjoint(op) for op in reversed(op_inv)]
         return qml.tape.QuantumScript(new_ops, [qml.probs(wires=cost.tape.wires.labels)])
 
     @staticmethod


Test patch:
diff --git a/tests/optimize/test_qnspsa.py b/tests/optimize/test_qnspsa.py
--- a/tests/optimize/test_qnspsa.py
+++ b/tests/optimize/test_qnspsa.py
@@ -418,3 +418,20 @@ def test_blocking(self, finite_diff_step, seed):
         # blocking should stop params from updating from this minimum
         new_params, _ = opt.step_and_cost(qnode, params)
         assert np.allclose(new_params, params)
+
+
+def test_template_no_adjoint():
+    """Test that qnspsa iterates when the operations do not have a custom adjoint."""
+
+    num_qubits = 2
+    dev = qml.device("default.qubit", wires=num_qubits)
+
+    @qml.qnode(dev)
+    def cost(params):
+        qml.RandomLayers(weights=params, wires=range(num_qubits), seed=42)
+        return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+    params = np.random.normal(0, np.pi, (2, 4))
+    opt = qml.QNSPSAOptimizer(stepsize=5e-2)
+    assert opt.step_and_cost(cost, params)  # just checking it runs without error
+    assert not qml.RandomLayers.has_adjoint
Repository: PennyLaneAI/pennylane

Issue:
[BUG] tensorflow autograph with finite diff and M1 Mac kills the kernel
### Expected behavior

I expect to get the gradient. Or at least an error message that tells me what I'm doing wrong.

### Actual behavior

bus error  python untitled.py

Very helpful traceback there.

### Additional information

The kernel gets killed with finite diff or spsa, but works fine with parameter shift.

### Source code

```shell
import pennylane as qml
import numpy as np

import tensorflow as tf

dev = qml.device('default.qubit', wires=1)

@tf.function
@qml.qnode(dev, diff_method="finite-diff")
def circuit(x):
    qml.RX(x, wires=0)
    return qml.expval(qml.PauliZ(0))

x = tf.Variable(0.1, dtype=tf.float64)
with tf.GradientTape() as tape:
    y = circuit(x)
tape.gradient(y, x)
```


### Tracebacks

_No response_

### System information

```shell
M1 Mac
tensorflow 2.14.1

PL master
```


### Existing GitHub issues

- [X] I have searched existing GitHub issues to make sure the issue does not already exist.


Discussion:
It seems to me that `tensorflow/python/eager/imperative_grad.py` uses a  `pywrap_tfe.TFE_Py_TapeGradient`, which access a memory address it isn't supposed to. Guess that the next step is to create a MRE and raise to TensorFlow team? 

If you are fine with that then I would be happy to take the issue, otherwise let's discuss more.

I've managed to track down the problem to this line:

https://github.com/PennyLaneAI/pennylane/blob/8702182672f0a074c5a2f9f67206ae7a9d95e929/pennylane/gradients/finite_difference.py#L149

Why that would be causing a problem, I have no idea.
And it seems to be fixed by switching `np.linalg.solve` with `scipy.linalg.solve`. 😕 

Resolving patch:
diff --git a/pennylane/gradients/finite_difference.py b/pennylane/gradients/finite_difference.py
--- a/pennylane/gradients/finite_difference.py
+++ b/pennylane/gradients/finite_difference.py
@@ -23,6 +23,7 @@
 
 import numpy as np
 from scipy.special import factorial
+from scipy.linalg import solve as linalg_solve
 
 import pennylane as qml
 from pennylane.measurements import ProbabilityMP
@@ -146,7 +147,11 @@ def finite_diff_coeffs(n, approx_order, strategy):
     A = shifts ** np.arange(len(shifts)).reshape(-1, 1)
     b = np.zeros_like(shifts)
     b[n] = factorial(n)
-    coeffs = np.linalg.solve(A, b)
+
+    # Note: using np.linalg.solve instead of scipy.linalg.solve can cause a bus error when this
+    # is inside a tf.py_function inside a tf.function, as occurs with the tensorflow-autograph interface
+    # Bus errors were potentially specific to the M1 Mac. Change with caution.
+    coeffs = linalg_solve(A, b)
 
     coeffs_and_shifts = np.stack([coeffs, shifts])
 


Test patch:
Repository: aimhubio/aim

Issue:
Support scalar tensor values, numpy scalars and  1-D arrays as input for metric tracking
Need to make utilities in `aim/sdk/num_utils.py` to treat as numeric values the following types:
1. `numpy.ndarray` with shape `(1,)`.
2.  subclasses of `numpy.number`.
3. tensor for scalar values (`tensorflow`, `torch`).

Change `Run.track()` method to not allow values which are not numeric values nor `AimObject`.


Discussion:

Resolving patch:
diff --git a/aim/sdk/num_utils.py b/aim/sdk/num_utils.py
--- a/aim/sdk/num_utils.py
+++ b/aim/sdk/num_utils.py
@@ -74,14 +74,19 @@ def is_numpy_number(inst):
     """
     Check whether `inst` is numpy number
     """
+
     return inst_has_typename(inst, ['numpy'])
 
 
+def is_py_number(value):
+    return isinstance(value, (int, float))
+
+
 def is_number(value):
     """
     Checks if the given value is a number
     """
-    if isinstance(value, (int, float)):
+    if is_py_number(value):
         return True
 
     if is_numpy_number(value):
@@ -100,11 +105,14 @@ def convert_to_py_number(value) -> object:
     """
     Converts numpy objects or tensors to python number types
     """
+    if isinstance(value, int):
+        return int(value)
+
     if isinstance(value, float):
         return float(value)
 
-    if isinstance(value, int):
-        return int(value)
+    if is_numpy_array(value):
+        return value.item()
 
     if is_numpy_number(value):
         return value.item()
diff --git a/aim/sdk/run.py b/aim/sdk/run.py
--- a/aim/sdk/run.py
+++ b/aim/sdk/run.py
@@ -10,9 +10,10 @@
 
 from aim.sdk.errors import RepoIntegrityError
 from aim.sdk.sequence import Sequence
+from aim.storage.object import CustomObject
 from aim.sdk.sequence_collection import SingleRunSequenceCollection
 from aim.sdk.utils import generate_run_hash, get_object_typename, check_types_compatibility
-from aim.sdk.num_utils import convert_to_py_number
+from aim.sdk.num_utils import convert_to_py_number, is_number
 from aim.sdk.types import AimObject
 from aim.sdk.configs import AIM_ENABLE_TRACKING_THREAD, AIM_RUN_INDEXING_TIMEOUT
 
@@ -417,11 +418,14 @@ def _track_impl(
     ):
         if context is None:
             context = {}
-        try:
+
+        if is_number(value):
             val = convert_to_py_number(value)
-        except ValueError:
-            # value is not a number
+        elif isinstance(value, (CustomObject, list, tuple)):
             val = value
+        else:
+            raise ValueError(f"Input metric of type {type(value)} is neither python number nor AimObject")
+
         dtype = get_object_typename(value)
 
         ctx = Context(context)


Test patch: