mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops/composite/base.py

@@ -24,6 +24,7 @@ import numpy as np
 import mindspore as ms
 from mindspore import context
 from mindspore.common.parameter import Parameter, ParameterTuple
+from mindspore.common.tensor import Tensor
 from mindspore.parallel._utils import _grads_divided_by_device_num_if_recomputation
 from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFuncGraph_, Tail_, \
     TupleAdd_, UnpackCall_, ZipOperation_, ListAppend_, TupleGetItemTensor_, ListInsert_, \
@@ -35,7 +36,6 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
 from mindspore.common import dtype as mstype
 from mindspore.common.api import jit, _pynative_executor, _wrap_func
 from mindspore.common.api import _add_flags, _core
-from mindspore.ops.primitive import Primitive
 from mindspore.ops import signature as sig
 
 __all__ = [TupleAdd_, ListAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_,
@@ -358,16 +358,14 @@ class GradOperation(GradOperation_):
         #   In PYNATIVE_MODE calling Grad from functions decorated with 'jit', use the out layer after_grad do
         #   grad in GRAPH_MODE.
         if context.get_context("mode") == context.GRAPH_MODE:
-            dynamic_shape_inputs = None
             if isinstance(fn, ms.nn.Cell):
-                dynamic_shape_inputs = fn.get_inputs()
                 fn.grad_ops_label = True
             if self.get_by_list:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args, **kwargs):
                     return grad_(fn, weights)(*args, **kwargs)
             else:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args, **kwargs):
                     return grad_(fn)(*args, **kwargs)
         elif self.pynative_:
@@ -578,11 +576,7 @@ class _Grad(GradOperation_):
             outputs = fn(*args, **kwargs)
             if not isinstance(outputs, tuple) or len(outputs) < 2:
                 raise ValueError("When has_aux is True, origin fn requires more than one outputs.")
-            res = (outputs[0],)
-            stop_gradient = Primitive("StopGradient")
-            for item in outputs[1:]:
-                res += (stop_gradient(item),)
-            return res
+            return outputs
 
         grad_ = _Grad(self.get_all, self.get_by_list, self.sens_param, self.get_by_position, self.has_aux,
                       self.get_value, self.return_ids, self.merge_forward)
@@ -592,20 +586,17 @@ class _Grad(GradOperation_):
         #   In PYNATIVE_MODE calling Grad from functions decorated with 'jit', use the out layer after_grad do
         #   grad in GRAPH_MODE.
         if context.get_context("mode") == context.GRAPH_MODE:
-            dynamic_shape_inputs = None
-            if isinstance(fn, ms.nn.Cell):
-                dynamic_shape_inputs = fn.get_inputs()
             if self.get_by_position:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args):
                     return grad_(fn, weights, grad_position)(*args)
             else:
                 if self.get_by_list:
-                    @jit(input_signature=dynamic_shape_inputs)
+                    @jit
                     def after_grad(*args):
                         return grad_(fn, weights)(*args)
                 else:
-                    @jit(input_signature=dynamic_shape_inputs)
+                    @jit
                     def after_grad(*args):
                         return grad_(fn)(*args)
         elif self.pynative_:
@@ -615,9 +606,12 @@ class _Grad(GradOperation_):
             @_wrap_func
             def after_grad(*args, **kwargs):
                 run_args, res = self._pynative_forward_run(fn, grad_, weights, *args, **kwargs)
-                out = _pynative_executor.grad(fn, grad_, weights, grad_position, *run_args)
+                if self.has_aux:
+                    out = _pynative_executor.grad_aux(fn, grad_, weights, grad_position, *run_args)
+                else:
+                    out = _pynative_executor.grad(fn, grad_, weights, grad_position, *run_args)
                 out = _grads_divided_by_device_num_if_recomputation(out)
-                if self.return_ids and out:
+                if self.return_ids and (isinstance(out, Tensor) or out) and out is not None:
                     out = _combine_with_ids(grad_position, weights, out)
                 if self.get_value:
                     return res, out
@@ -820,14 +814,15 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
             self.register_fn(type_names, fn)
             self.entries.append((types, fn))
             return fn
-
         return deco
 
-    def register_default(self):
+    def _register_default(self, convert_to_interpret=True):
         def deco(fn):
-            self.default_func = fn
+            if not convert_to_interpret:
+                self.register_default_fn(fn)
+            else:
+                self.default_func = fn
             return fn
-
         return deco
 
     # pylint: disable=missing-docstring
@@ -928,9 +923,9 @@ class Map(Map_):
     Apply the operations to every element of the sequence.
 
     Args:
-        ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
+        ops (Union[MultitypeFuncGraph, None], optional): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default: ``None`` .
-        reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
+        reverse (bool, optional): The optimizer needs to be inverted in some scenarios to improve parallel performance,
             general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
             Only supported in graph mode. Default is ``False`` .
 

mindspore/ops/composite/math_ops.py

@@ -85,8 +85,9 @@ def matmul(x1, x2, dtype=None):
 def mm(input, mat2):
     r"""
     Returns the matrix product of two arrays.
-    If `input` is a :math:`(n \times m)` Tensor, `mat2` is a
-    :math:`(m \times p)` Tensor, `out` will be a :math:`(n \times p)` Tensor.
+
+    If `input` is a :math:`(n \times m)` tensor, `mat2` is a
+    :math:`(m \times p)` tensor, `out` will be a :math:`(n \times p)` tensor.
 
     Note:
         - This function cannot support broadcasting.
@@ -95,28 +96,17 @@ def mm(input, mat2):
 
     Args:
         input (Tensor): The first matrix of matrix multiplication.
-            The last dimension of `input` must be the same size as the first dimension of `mat2`.
         mat2 (Tensor): The second matrix of matrix multiplication.
-            The last dimension of `input` must be the same size as the first dimension of `mat2`.
 
     Returns:
-        Tensor or scalar, the matrix product of the inputs.
-
-    Raises:
-        ValueError: If the last dimension of `input` is not the same size as the
-            second-to-last dimension of `mat2`.
-        ValueError: If `input` or `mat2` is not a Tensor.
+        Tensor or scalar
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> import numpy as np
-        >>> x1 = ms.Tensor(np.random.rand(2, 3), ms.float32)
-        >>> x2 = ms.Tensor(np.random.rand(3, 4), ms.float32)
-        >>> out = ops.mm(x1, x2)
+        >>> import mindspore
+        >>> out = mindspore.ops.mm(mindspore.ops.ones((2, 3)), mindspore.ops.ones((3, 4)))
         >>> print(out.shape)
         (2, 4)
     """

mindspore/ops/composite/multitype_ops/__init__.py

@@ -25,7 +25,7 @@ from mindspore.ops.composite.multitype_ops.mod_impl import mod
 from mindspore.ops.composite.multitype_ops.getitem_impl import getitem
 from mindspore.ops.composite.multitype_ops.setitem_impl import setitem
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like
+from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like, _ones_like_for_grad
 from mindspore.ops.composite.multitype_ops.equal_impl import equal
 from mindspore.ops.composite.multitype_ops.not_equal_impl import not_equal
 from mindspore.ops.composite.multitype_ops.less_impl import less
@@ -44,6 +44,7 @@ from mindspore.ops.composite.multitype_ops.right_shift_impl import right_shift
 from mindspore.ops.composite.multitype_ops.uadd_impl import uadd
 from mindspore.ops.composite.multitype_ops.in_impl import in_
 from mindspore.ops.composite.multitype_ops.not_in_impl import not_in_
+from mindspore.ops.composite.multitype_ops.invert_impl import invert
 __all__ = [
     'add',
     'sub',
@@ -73,5 +74,7 @@ __all__ = [
     'left_shift',
     'right_shift',
     'in_',
-    'not_in_'
+    'not_in_',
+    'invert',
+    '_ones_like_for_grad'
 ]

mindspore/ops/composite/multitype_ops/_compile_utils.py

@@ -18,7 +18,6 @@ from __future__ import absolute_import
 from enum import IntEnum
 import numpy as np
 
-from mindspore._c_expression import Tensor as Tensor_
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops import functional as F
 from mindspore.ops import operations as P
@@ -36,7 +35,7 @@ from mindspore import ops
 from mindspore.ops.primitive import _primexpr
 from mindspore import _checkparam as validator
 from mindspore.common._stub_tensor import _convert_stub
-from mindspore.ops.auto_generate.gen_ops_prim import select_ext_op, slice_ext_op, inplace_copy_op, \
+from mindspore.ops.auto_generate.gen_ops_prim import select_ext_view_op, slice_ext_op, inplace_copy_op, \
     index_op, inplace_index_put_op
 
 slice_get_item = SliceGetItem()
@@ -52,8 +51,8 @@ select_view = SelectView()
 copy_with_slice = CopyWithSlice()
 
 tensor_1d = Tensor([0], dtype=mstype.int64)
-empty_tensor_1d = Tensor_(shape=(0,), dtype=mstype.int64)
-empty_tensor_9d = Tensor_(shape=(0,)*9, dtype=mstype.int64)
+empty_tensor_1d = Tensor(shape=(0,), dtype=mstype.int64)
+empty_tensor_9d = Tensor(shape=(0,)*9, dtype=mstype.int64)
 
 
 
@@ -267,7 +266,7 @@ def _do_select(self: Tensor, dim: int, index: int, dim_index: int, self_shape: l
     if index >= dim_size or index < -dim_size:
         raise IndexError(f"Index {index} is out of bounds for dimension {dim_index} with size {dim_size}")
     index = index + dim_size if index < 0 else index
-    return select_ext_op(self, dim, index)
+    return select_ext_view_op(self, dim, index)
 
 
 def _do_slice(self: Tensor, dim: int, index: slice, self_shape: list):

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -27,7 +27,6 @@ from mindspore.ops.operations import _inner_ops
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore import log as logger
 from mindspore import context
-from mindspore._c_expression import Tensor as Tensor_
 
 ALL_TENSOR = 0
 NO_TENSOR = 1
@@ -201,7 +200,7 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
 
     if isinstance(a, (list, tuple)):
         if not a:
-            return Tensor_(a, dtype)
+            return Tensor(a, dtype)
         # Convert all tuple/nested tuples to lists
         a = _deep_list(a, dim_size)
         # Convert all tensor sub-elements to numpy arrays

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -600,7 +600,8 @@ def _dict_add_dict(x, y):
 hyper_add = base.HyperMap(_add_backward)
 
 
-@add.register_default()
+# pylint: disable=protected-access
+@add._register_default()
 def default_add(x, y):
     """Default function for add."""
     return x + y

mindspore/ops/composite/multitype_ops/bitwise_and_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_and_tensor(x, y):
     return F.bitwise_and(x, y)
 
 
-@bitwise_and.register_default()
+# pylint: disable=protected-access
+@bitwise_and._register_default()
 def default_bitwsie_add(x, y):
     """Default function for bitwise_and."""
     return x & y

mindspore/ops/composite/multitype_ops/bitwise_or_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_or_tensor(x, y):
     return F.bitwise_or(x, y)
 
 
-@bitwise_or.register_default()
+# pylint: disable=protected-access
+@bitwise_or._register_default()
 def default_bitwsie_or(x, y):
     """Default function for bitwise_or."""
     return x | y

mindspore/ops/composite/multitype_ops/bitwise_xor_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_xor_tensor(x, y):
     return F.bitwise_xor(x, y)
 
 
-@bitwise_xor.register_default()
+# pylint: disable=protected-access
+@bitwise_xor._register_default()
 def default_bitwsie_xor(x, y):
     """Default function for bitwise_xor."""
     return x ^ y

mindspore/ops/composite/multitype_ops/div_impl.py

@@ -21,6 +21,7 @@ from mindspore.ops.composite.multitype_ops._constexpr_utils import log_warning,
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.common import COOTensor
+from mindspore.ops.auto_generate import div_op
 
 
 div = base.MultitypeFuncGraph("div", True)
@@ -84,7 +85,7 @@ def _div_tensor(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Number", "Tensor")
@@ -99,7 +100,7 @@ def _scalar_div_tensor(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Tensor", "Number")
@@ -114,7 +115,7 @@ def _tensor_div_scalar(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Tuple", "Tensor")
@@ -181,7 +182,8 @@ def _tensor_div_list(x, y):
     return F.tensor_div(x, y)
 
 
-@div.register_default()
+# pylint: disable=protected-access
+@div._register_default()
 def default_div(x, y):
     """Default function for div."""
     if y != 0:

mindspore/ops/composite/multitype_ops/equal_impl.py

@@ -306,7 +306,7 @@ def _number_equal_string(x, y):
 
     Args:
        x (Number): The first input which is a number.
-       y (String): The second input which is a string.
+       y (str): The second input which is a string.
 
     Returns:
        bool, return false.
@@ -320,7 +320,7 @@ def _string_equal_number(x, y):
     Determine if number equal string.
 
     Args:
-       x (String): The first input which is a string.
+       x (str): The first input which is a string.
        y (Number): The second input which is a number.
 
     Returns:
@@ -329,7 +329,8 @@ def _string_equal_number(x, y):
     return False
 
 
-@equal.register_default()
+# pylint: disable=protected-access
+@equal._register_default()
 def default_equal(x, y):
     """Default function for equal."""
     return x == y

mindspore/ops/composite/multitype_ops/floordiv_impl.py

@@ -80,7 +80,8 @@ def _tensor_floordiv_list(x, y):
     return F.tensor_floordiv(x, y)
 
 
-@floordiv.register_default()
+# pylint: disable=protected-access
+@floordiv._register_default()
 def default_floordiv(x, y):
     """Default function for floordiv."""
     if y == 0:

mindspore/ops/composite/multitype_ops/getitem_impl.py

@@ -265,7 +265,7 @@ def _string_getitem_by_number(data, number_index):
     Getting item of string by number index.
 
     Inputs:
-        data (String): A string.
+        data (str): A string.
         number_index (Number): Index in scalar.
 
     Outputs:
@@ -394,7 +394,8 @@ def _map_tensor_getitem(map_tensor, key_tensor):
     return _map_tensor_ops.MapTensorGet(True)(map_tensor, key_tensor)
 
 
-@getitem.register_default()
+# pylint: disable=protected-access
+@getitem._register_default()
 def default_getitem(x, y):
     """Default function for getitem."""
     return x[y]

mindspore/ops/composite/multitype_ops/greater_equal_impl.py

@@ -47,8 +47,8 @@ def _greater_equal_string(x, y):
     Determine whether x is greater than or equal to y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x >= y return true, x < y return false.
@@ -103,7 +103,8 @@ def _greater_equal_list(x, y):
     return list_greater_equal()(x, y)
 
 
-@greater_equal.register_default()
+# pylint: disable=protected-access
+@greater_equal._register_default()
 def default_greater_equal(x, y):
     """Default function for greater equal."""
     return x >= y

mindspore/ops/composite/multitype_ops/greater_impl.py

@@ -48,8 +48,8 @@ def _greater_string(x, y):
     Determine whether x is greater than y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x > y return true, x <= y return false.
@@ -104,7 +104,8 @@ def _greater_than_list(x, y):
     return list_greater_than()(x, y)
 
 
-@greater.register_default()
+# pylint: disable=protected-access
+@greater._register_default()
 def default_greater(x, y):
     """Default function for greater."""
     return x > y

mindspore/ops/composite/multitype_ops/in_impl.py

@@ -190,7 +190,8 @@ def _mstype_in_tuple(x, y):
     return const_utils.check_in_sequence(x, y)
 
 
-@in_.register_default()
+# pylint: disable=protected-access
+@in_._register_default()
 def default_in(x, y):
     """Default function for in."""
     return x in y

mindspore/ops/composite/multitype_ops/invert_impl.py

@@ -0,0 +1,50 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Implementation for internal polymorphism `invert` operations."""
+from mindspore.ops.composite import base
+from mindspore.ops import functional as F
+
+
+invert = base.MultitypeFuncGraph('invert', True)
+
+@invert.register("Number")
+def _invert_scalar(x):
+    """
+    return the inverted value of x.
+
+    Args:
+        x (Number): x
+    Returns:
+        Number. Equal to -x-1, has the same type of x.
+    """
+    if isinstance(x, bool):
+        if x:
+            return -2
+        return -1
+    if not isinstance(x, int):
+        raise TypeError(f"bad operand type for unary ~: '{type(x)}")
+    return -x-1
+
+@invert.register("Tensor")
+def _invert_tensor(x):
+    """
+    return the inverted tensor of x.
+    Arg:
+        x (Tensor): x
+    Returns:
+        Tensor.
+    """
+    return F.logical_not(x)

mindspore/ops/composite/multitype_ops/left_shift_impl.py

@@ -31,7 +31,8 @@ def _left_shift_scalar(x, y):
     return inner.bit_left_shift(x, y)
 
 
-@left_shift.register_default()
+# pylint: disable=protected-access
+@left_shift._register_default()
 def default_left_shift(x, y):
     """Default function for left shift."""
     return x << y

mindspore/ops/composite/multitype_ops/less_equal_impl.py

@@ -49,8 +49,8 @@ def _less_equal_string(x, y):
     Determine whether x is less than or equal to y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x <= y return true, x > y return false.
@@ -105,7 +105,8 @@ def _less_equal_list(x, y):
     return _seq.list_le()(x, y)
 
 
-@less_equal.register_default()
+# pylint: disable=protected-access
+@less_equal._register_default()
 def default_less_equal(x, y):
     """Default function for less equal."""
     return x <= y

mindspore/ops/composite/multitype_ops/less_impl.py

@@ -50,8 +50,8 @@ def _less_string(x, y):
     Determine whether x is less than y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x < y return true, x >= y return false.
@@ -106,7 +106,8 @@ def _less_list(x, y):
     return _seq.list_lt()(x, y)
 
 
-@less.register_default()
+# pylint: disable=protected-access
+@less._register_default()
 def default_less(x, y):
     """Default function for less."""
     return x < y

mindspore/ops/composite/multitype_ops/logic_not_impl.py

@@ -43,7 +43,7 @@ def _logical_not_string(x):
     Return logical not operation result of x.
 
     Args:
-       x(String): String.
+       x(str): String.
 
     Returns:
        bool, Return logical not operation result of x.
@@ -107,7 +107,8 @@ def _logical_not_list(x):
     return x.__len__() == 0
 
 
-@logical_not.register_default()
+# pylint: disable=protected-access
+@logical_not._register_default()
 def default_logical_not(x):
     """Default function for logical not."""
     return not x

mindspore/ops/composite/multitype_ops/logical_and_impl.py

@@ -54,7 +54,8 @@ def _logical_and_tensor(x, y):
     return F.logical_and(x, y)
 
 
-@logical_and.register_default()
+# pylint: disable=protected-access
+@logical_and._register_default()
 def default_logical_and(x, y):
     """Default function for logical and."""
     return x and y

mindspore/ops/composite/multitype_ops/logical_or_impl.py

@@ -55,7 +55,8 @@ def _logical_or_tensor(x, y):
     return F.logical_or(x, y)
 
 
-@logical_or.register_default()
+# pylint: disable=protected-access
+@logical_or._register_default()
 def default_logical_or(x, y):
     """Default function for logical or."""
     return x or y

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -80,7 +80,8 @@ def _tensor_mod_list(x, y):
     return F.tensor_mod(x, y)
 
 
-@mod.register_default()
+# pylint: disable=protected-access
+@mod._register_default()
 def default_mod(x, y):
     """Default function for mod."""
     return x % y

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -71,7 +71,7 @@ def _tensor_mul_scalar(x, y):
     Outputs:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_mul(x, y)
+    return F.tensor_muls(x, y)
 
 
 @mul.register("Number", "String")
@@ -288,7 +288,8 @@ def _tensor_mul_cootensor(x, y):
     return COOTensor(y.indices, y.values * other_values, y.shape)
 
 
-@mul.register_default()
+# pylint: disable=protected-access
+@mul._register_default()
 def default_mul(x, y):
     """Default function for mul."""
     return x * y

mindspore/ops/composite/multitype_ops/negative_impl.py

@@ -73,7 +73,8 @@ def _negative_cootensor(x):
     return COOTensor(x.indices, F.neg(x.values), x.shape)
 
 
-@negative.register_default()
+# pylint: disable=protected-access
+@negative._register_default()
 def default_negative(x):
     """Default function for negative."""
     return -x

mindspore/ops/composite/multitype_ops/not_equal_impl.py

@@ -284,7 +284,8 @@ def _none_not_equal_list(x, y):
     return True
 
 
-@not_equal.register_default()
+# pylint: disable=protected-access
+@not_equal._register_default()
 def default_not_equal(x, y):
     """Default function for not equal."""
     return x != y

mindspore/ops/composite/multitype_ops/not_in_impl.py

@@ -190,7 +190,8 @@ def _mstype_not_in_tuple(x, y):
     return not const_utils.check_in_sequence(x, y)
 
 
-@not_in_.register_default()
+# pylint: disable=protected-access
+@not_in_._register_default()
 def default_not_in(x, y):
     """Default function for not in."""
     return x not in y