Repository: aeon-toolkit/aeon
Pull request #1459 (2024-04-22 20:33:41)

[MNT] Adds an Issue/PR Assigning Bot
As per the discussion with @MatthewMiddlehurst, 

#### What does this implement/fix? Explain your changes.
It implements an Issue/PR assigning bot to eliminate the chances of people working on the same Issue.

<!--
A clear and concise description of what you have implemented.
-->

#### Any other comments?
This would look something like : 
![image](https://github.com/aeon-toolkit/aeon/assets/67187480/b4d83922-9f51-4420-af45-07bbdd8718d6)


<!--
Please be aware that we are a loose team of volunteers so patience is
necessary; assistance handling other issues is very welcome. We value all
user contributions, no matter how minor they are. If we are slow to
review, either the pull request needs some benchmarking, tinkering,
convincing, etc. or more likely the reviewers are simply busy. In either
case, we ask for your understanding during the review process.
-->



<!--
Thanks for contributing!
-->


aeon-actions-bot[bot]: 
## Thank you for contributing to `aeon`

I have added the following labels to this PR based on the title: **[ $\\color{#EC843A}{\\textsf{maintenance}}$ ]**.


The [Checks](https://github.com/aeon-toolkit/aeon/pull/1459/checks) tab will show the status of our automated tests. You can click on individual test runs in the tab or "Details" in the panel below to see more information if there is a failure.

If our `pre-commit` code quality check fails, any trivial fixes will automatically be pushed to your PR unless it is a draft.

Don't hesitate to ask questions on the `aeon` [Slack](
https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA) channel if you have any.
    
AnonymousCodes911: @chrisholder, do you think we could add more interactivity to this?
MatthewMiddlehurst: Could you run through the code and what each bit is doing? Not very reader friendly currently for anyone who may not know much about bash 🙂.
AnonymousCodes911: @MatthewMiddlehurst, added the comments to make it more readable!
MatthewMiddlehurst: Three issues I have with this really at the moment.

1. It is rather rigid, requiring a specific phrase and formatting
2. The code does not really match the style of other actions, it would be better as a bash script (or preferably a python file using pygithub).
3. There is nothing to indicate that this is available, I don't expect new users (who are most likely to not have write access) to know this is available. Probably best place is the contributor guide.
AnonymousCodes911: Hi @MatthewMiddlehurst !, so answer your questions: 
> 1. It is rather rigid, requiring a specific phrase and formatting

 We can make it more generic to include flexibility in the phrases. 
by making it accept phrases like : 
```python
"Aeon-Assign bot", "assign this to", "please assign"
```
>2. The code does not really match the style of other actions, it would be better as a bash script (or preferably a python file using pygithub).

I'll opt for using PyGithub


> 3. There is nothing to indicate that this is available, I don't expect new users (who are most likely to not have write access) to know this is available. Probably best place is the contributor guide.

We can add it to the contributor's guide or describe a simple bot, that would comment on the Issues/PRs stating how we can trigger this bot.

Do you think this approach is fine?





AnonymousCodes911: @MatthewMiddlehurst please review.
MatthewMiddlehurst: We are mostly volunteers and there is a lot of other work we do, so try to be a bit patient and we will get around to it 🙂 
AnonymousCodes911: I understand, I apologize if it felt rushed, I just meant it is up for review at your convenience.
AnonymousCodes911: > Would it be possible to only run this if the message starts with @aeon-actions-bot? If so the comment text only needs to contain "assign" for it to run, probably.

Even now, if the text only contains " assign " it would still Assign the PR, I just added the other phrases as contingencies to keep the bot flexible.
AnonymousCodes911: > I would look at the other workflows i.e. the PR comment one to see the token generator. That will allow the bot to assign.

@MatthewMiddlehurst, 
I think when the task is as trivial as just assigning the PR, we can directly use the personal access token (PAT) stored in the repository, and we would not need the app token(did you mean [this?](https://github.com/aeon-toolkit/aeon/blob/625a1448ecebca89d0312c68dbf3fdd5a96de8e8/.github/workflows/pr_opened.yml#L31))
MatthewMiddlehurst: Using the app token will make the bot assign rather than github actions. Its cosmetic I guess.

I mean since you are explicitly asking the bot, you can just remove the list and run it on any string which contains "assign" (which would cover "assigning", "assign this to", etc). You could avoid parsing users (any word starting with @) as well, but probably not required.

Patch:
diff --git a/.github/scripts/self_assign.py b/.github/scripts/self_assign.py
new file mode 100644
index 00000000..bc24ec70
--- /dev/null
+++ b/.github/scripts/self_assign.py
@@ -0,0 +1,33 @@
+"""
+Script for the Self-Assign Bot.
+
+It checks if a comment on an issue or PR includes the trigger
+phrase(as defined) and a mentioned user.
+If it does, it assigns the issue/PR to the mentioned user.
+"""
+
+import os
+import re
+
+from github import Github
+
+# Initialize a Github instance:
+g = Github(os.getenv("GITHUB_TOKEN"))
+
+# Get the repo from environment variables
+repo = g.get_repo(os.getenv("GITHUB_REPOSITORY"))
+
+# Get the issue from the payload
+issue_number = int(os.getenv("ISSUE_NUMBER"))
+issue = repo.get_issue(number=issue_number)
+
+# Get the comment from the payload
+comment_body = os.getenv("COMMENT_BODY")
+
+# Check if the comment contains the word "assign"
+if "assign" in comment_body.lower():
+    # Extract the username mentioned in the comment
+    mentioned_users = re.findall(r"@([a-zA-Z0-9](?:-?[a-zA-Z0-9]){0,38})", comment_body)
+    for mentioned_user in mentioned_users:
+        # Assign the Issue/PR to the user
+        issue.add_to_assignees(mentioned_user)
diff --git a/.github/workflows/self_assign_bot.yml b/.github/workflows/self_assign_bot.yml
new file mode 100644
index 00000000..34a8f4dd
--- /dev/null
+++ b/.github/workflows/self_assign_bot.yml
@@ -0,0 +1,31 @@
+name: Self-Assign Bot
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  self-assign:
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.10
+
+      - name: Install PyGithub
+        run: |
+          python -m pip install --upgrade pip
+          pip install PyGithub
+      - name: Set env
+        run: |
+          echo "ISSUE_NUMBER=$(jq --raw-output .issue.number "$GITHUB_EVENT_PATH")" >> $GITHUB_ENV
+          echo "COMMENT_BODY=$(jq --raw-output .comment.body "$GITHUB_EVENT_PATH")" >> $GITHUB_ENV
+
+      - name: Run script
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: python .github/scripts/self_assign.py
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3f90e4bc..03be5d6a 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -29,7 +29,7 @@ repos:
         args: [ "--create", "--python-folders", "aeon" ]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.2
+    rev: v0.4.3
     hooks:
       - id: ruff
         args: [ "--fix"]
diff --git a/aeon/base/_base_series.py b/aeon/base/_base_series.py
index 9a3f94e7..fb01ad28 100644
--- a/aeon/base/_base_series.py
+++ b/aeon/base/_base_series.py
@@ -16,7 +16,6 @@ from aeon.utils.validation._dependencies import _check_estimator_deps
 # allowed input and internal data types for Series
 VALID_INNER_TYPES = [
     "np.ndarray",
-    "pd.Series",
     "pd.DataFrame",
 ]
 VALID_INPUT_TYPES = [pd.DataFrame, pd.Series, np.ndarray]
@@ -38,7 +37,7 @@ class BaseSeriesEstimator(BaseEstimator):
             np.ndarray, shape ``(m,)``, ``(m, 1)`` or ``(1, m)`` depending on axis.
             This is converted to a 2D np.ndarray internally.
             pd.DataFrame, shape ``(m, 1)`` or ``(1, m)`` depending on axis.
-            pd.Series, shape ``(m,)``.
+            pd.Series, shape ``(m,)`` is converted to a pd.DataFrame.
         Multivariate series:
             np.ndarray array, shape ``(m, d)`` or ``(d, m)`` depending on axis.
             pd.DataFrame ``(m, d)`` or ``(d, m)`` depending on axis.
@@ -199,30 +198,12 @@ class BaseSeriesEstimator(BaseEstimator):
         if input not in inner_names:
             if inner_names[0] == "ndarray":
                 X = X.to_numpy()
-            elif inner_names[0] == "Series":
-                if self.get_tag("capability:multivariate"):
-                    raise ValueError(
-                        "Cannot convert to pd.Series for multivariate capable "
-                        "estimators"
-                    )
-                if X.ndim > 1:
-                    n_channels = X.shape[0] if axis == 1 else X.shape[1]
-                    if n_channels > 1:
-                        raise ValueError(
-                            "Cannot convert to pd.Series for multivariate data. Found "
-                            f"{n_channels} channels"
-                        )
-
-                X = X.squeeze()
-                X = pd.Series(X)
             elif inner_names[0] == "DataFrame":
                 # converting a 1d array will create a 2d array in axis 0 format
                 transpose = False
                 if X.ndim == 1 and axis == 1:
                     transpose = True
-
                 X = pd.DataFrame(X)
-
                 if transpose:
                     X = X.T
             else:
@@ -271,38 +252,3 @@ class BaseSeriesEstimator(BaseEstimator):
             self.metadata_ = meta
 
         return self._convert_X(X, axis)
-
-    def _postprocess_series(self, Xt, axis):
-        """Postprocess data Xt to revert to original shape.
-
-        Parameters
-        ----------
-        Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
-            A valid aeon time series data structure. See
-            aeon.base._base_series.VALID_INPUT_TYPES for aeon supported types.
-            Intended for algorithms which have another series as output.
-        axis: int or None
-            The time point axis of the input series if it is 2D. If ``axis==0``, it is
-            assumed each column is a time series and each row is a time point. i.e. the
-            shape of the data is ``(n_timepoints, n_channels)``. ``axis==1`` indicates
-            the time series are in rows, i.e. the shape of the data is
-            ``(n_channels, n_timepoints)``.
-            If None, the default class axis is used.
-
-        Returns
-        -------
-        Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
-            New time series input reshaped to match the original input.
-        """
-        if axis is None:
-            axis = self.axis
-
-        # If a univariate only transformer, return a univariate series
-        if not self.get_tag("capability:multivariate"):
-            Xt = Xt.squeeze()
-
-        # return with input axis
-        if Xt.ndim == 1 or axis == self.axis:
-            return Xt
-        else:
-            return Xt.T
diff --git a/aeon/distances/__init__.py b/aeon/distances/__init__.py
index e8915766..059e892b 100644
--- a/aeon/distances/__init__.py
+++ b/aeon/distances/__init__.py
@@ -65,6 +65,8 @@ __all__ = [
     "shape_dtw_pairwise_distance",
     "sbd_distance",
     "sbd_pairwise_distance",
+    "mpdist",
+    "mpdist_pairwise_distance",
 ]
 
 
@@ -119,6 +121,7 @@ from aeon.distances._lcss import (
 )
 from aeon.distances._manhattan import manhattan_distance, manhattan_pairwise_distance
 from aeon.distances._minkowski import minkowski_distance, minkowski_pairwise_distance
+from aeon.distances._mpdist import mpdist, mpdist_pairwise_distance
 from aeon.distances._msm import (
     msm_alignment_path,
     msm_cost_matrix,
diff --git a/aeon/distances/_distance.py b/aeon/distances/_distance.py
index 7df35595..6e43d806 100644
--- a/aeon/distances/_distance.py
+++ b/aeon/distances/_distance.py
@@ -44,6 +44,7 @@ from aeon.distances._lcss import (
 )
 from aeon.distances._manhattan import manhattan_distance, manhattan_pairwise_distance
 from aeon.distances._minkowski import minkowski_distance, minkowski_pairwise_distance
+from aeon.distances._mpdist import mpdist
 from aeon.distances._msm import (
     msm_alignment_path,
     msm_cost_matrix,
@@ -77,7 +78,6 @@ from aeon.distances._wdtw import (
     wdtw_distance,
     wdtw_pairwise_distance,
 )
-from aeon.distances.mpdist import mpdist
 
 
 class DistanceKwargs(TypedDict, total=False):
diff --git a/aeon/distances/_mpdist.py b/aeon/distances/_mpdist.py
new file mode 100644
index 00000000..96fe91a7
--- /dev/null
+++ b/aeon/distances/_mpdist.py
@@ -0,0 +1,359 @@
+"""Matrix Profile Distances."""
+
+from typing import List, Optional, Union
+
+import numpy as np
+from numba import njit
+from numba.typed import List as NumbaList
+
+from aeon.distances._utils import reshape_pairwise_to_multiple
+
+
+def mpdist(x: np.ndarray, y: np.ndarray, m: int = 0) -> float:
+    r"""Matrix Profile Distance.
+
+    MPdist is a recently introduced distance measure which considers
+    two time series to be similar if they share many similar subsequences,
+    2regardless of the order of matching subsequences. MPdist combines the
+    results of an AB-join and a BA-join, then identifies the kth smallest
+    value as the reported distance. It's important to note that MPdist is
+    a measure, not a metric. As a result, it doesn't adhere to the triangular
+    inequality.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        First time series, univariate, shape ``(n_timepoints,)``
+    y : np.ndarray
+        Second time series, univariate, shape ``(n_timepoints,)``
+    m : int (default = 0)
+        Length of the subsequence
+
+    Returns
+    -------
+    float
+        Matrix Profile distance between x and y
+
+    Raises
+    ------
+    ValueError
+        If x and y are not 1D arrays
+
+    References
+    ----------
+    .. [1] S. Gharghabi, S. Imani, A. Bagnall, A. Darvishzadeh and E. Keogh,
+    "Matrix Profile XII: MPdist: A Novel Time Series Distance Measure to Allow
+    Data Mining in More Challenging Scenarios," 2018 IEEE International Conference
+    on Data Mining (ICDM), Singapore, 2018.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from aeon.distances import mpdist
+    >>> x = np.array([5, 9, 16, 23, 19, 13, 7])
+    >>> y = np.array([3, 7, 13, 19, 23, 31, 36, 40, 48, 55, 63])
+    >>> m = 4
+    >>> mpdist(x, y, m)
+    0.05663764013361034
+    """
+    x = np.squeeze(x)
+    y = np.squeeze(y)
+
+    if x.ndim == 1 and y.ndim == 1:
+        return _mpdist(x, y, m)
+
+    raise ValueError("x and y must be a 1D array of shape (n_timepoints,)")
+
+
+def _mpdist(x: np.ndarray, y: np.ndarray, m: int) -> float:
+    threshold = 0.05
+    len_x = len(x)
+    len_y = len(y)
+
+    first_dot_prod_ab = _sliding_dot_products(y[0:m], x, m, len_x)
+    dot_prod_ab = _sliding_dot_products(x[0:m], y, m, len_y)
+    mp_ab, ip_ab = _stomp_ab(
+        x, y, m, first_dot_prod_ab, dot_prod_ab
+    )  # AB Matrix profile
+
+    first_dot_prod_ba = _sliding_dot_products(x[0:m], y, m, len_y)
+    dot_prod_ba = _sliding_dot_products(y[0:m], x, m, len_x)
+    mp_ba, ip_ba = _stomp_ab(
+        y, x, m, first_dot_prod_ba, dot_prod_ba
+    )  # BA Matrix profile
+
+    join_mp = np.concatenate([mp_ab, mp_ba])
+
+    k = int(np.ceil(threshold * (len(x) + len(y))))
+
+    sorted_mp = np.sort(join_mp)
+
+    if len(sorted_mp) > k:
+        dist = sorted_mp[k]
+    else:
+        dist = sorted_mp[len(sorted_mp) - 1]
+
+    return dist
+
+
+def _sliding_dot_products(q, t, len_q, len_t):
+    """
+    Compute the sliding dot products between a query and a time series.
+
+    Parameters
+    ----------
+        q: numpy.array
+            Query.
+        t: numpy.array
+            Time series.
+        len_q: int
+            Length of the query.
+        len_t: int
+            Length of the time series.
+
+    Output
+    ------
+        dot_prod: numpy.array
+             Sliding dot products between q and t.
+    """
+    # Reversing query and padding both query and time series
+    padded_t = np.pad(t, (0, len_t))
+    reversed_q = np.flipud(q)
+    padded_reversed_q = np.pad(reversed_q, (0, 2 * len_t - len_q))
+
+    # Applying FFT to both query and time series
+    fft_t = np.fft.fft(padded_t)
+    fft_q = np.fft.fft(padded_reversed_q)
+
+    # Applying inverse FFT to obtain the convolution of the time series by
+    # the query
+    element_wise_mult = np.multiply(fft_t, fft_q)
+    inverse_fft = np.fft.ifft(element_wise_mult)
+
+    # Returns only the valid dot products from inverse_fft
+    dot_prod = inverse_fft[len_q - 1 : len_t].real
+
+    return dot_prod
+
+
+@njit(cache=True, fastmath=True)
+def _calculate_distance_profile(
+    dot_prod, q_mean, q_std, t_mean, t_std, q_len, n_t_subs
+):
+    """
+    Calculate the distance profile for the given query.
+
+    Parameters
+    ----------
+        dot_prod: numpy.array
+            Sliding dot products between the time series and the query.
+        q_mean: float
+            Mean of the elements of the query.
+        q_std: float
+            Standard deviation of elements of the query.
+        t_mean: numpy.array
+            Array with the mean of the elements from each subsequence of
+            length(query) from the time series.
+        t_std: numpy.array
+            Array with the standard deviation of the elements from each
+            subsequence of length(query) from the time series.
+        q_len: int
+            Length of the query.
+        n_t_subs: int
+            Number of subsequences in the time series.
+
+    Output
+    ------
+        d: numpy.array
+            Distance profile of query q.
+    """
+    d = np.empty(n_t_subs)
+    for i in range(n_t_subs):
+        temp = (dot_prod[i] - q_len * q_mean * t_mean[i]) / (q_len * q_std * t_std[i])
+        d[i] = 2 * q_len * (1 - temp)
+
+    d = np.absolute(d)
+    d = np.sqrt(d)
+
+    return d
+
+
+@njit(cache=True, fastmath=True)
+def _stomp_ab(
+    x: np.ndarray,
+    y: np.ndarray,
+    m: int,
+    first_dot_prod: np.ndarray,
+    dot_prod: np.ndarray,
+):
+    """
+    STOMP implementation for AB similarity join.
+
+    Parameters
+    ----------
+        x: numpy.array
+            First time series.
+        y: numpy.array
+            Second time series.
+        m: int
+            Length of the subsequences.
+        first_dot_prod: np.ndarray
+            The distance profile for the first y subsequence.
+        dot_prod: np.ndarray
+            the distance profile for the first x subsequence.
+
+    Output
+    ------
+        mp: numpy.array
+            Array with the distance between every subsequence from x
+            to the nearest subsequence with same length from y.
+        ip: numpy.array
+            Array with the index of the nearest neighbor of x in y.
+    """
+    len_x = len(x)
+    len_y = len(y)
+    if m == 0:
+        if len_x > len_y:
+            m = int(len_x / 4)
+        else:
+            m = int(len_y / 4)
+
+    # Number of subsequences
+    subs_x = len_x - m + 1
+    subs_y = len_y - m + 1
+
+    # Compute the mean and standard deviation
+    x_mean = []
+    x_std = []
+    y_mean = []
+    y_std = []
+
+    for i in range(subs_x):
+        x_mean.append(np.mean(x[i : i + m]))
+        x_std.append(np.std(x[i : i + m]))
+
+    for i in range(subs_y):
+        y_mean.append(np.mean(y[i : i + m]))
+        y_std.append(np.std(y[i : i + m]))
+
+    # Initialization
+    mp = np.full(subs_x, np.inf)  # matrix profile
+    ip = np.zeros(subs_x)  # index profile
+
+    dp = _calculate_distance_profile(
+        dot_prod, x_mean[0], x_std[0], y_mean, y_std, m, subs_y
+    )
+
+    # Update the matrix profile
+    mp[0] = np.amin(dp)
+    ip[0] = np.argmin(dp)
+
+    for i in range(1, subs_x):
+        for j in range(subs_y - 1, 0, -1):
+            dot_prod[j] = (
+                dot_prod[j - 1] - y[j - 1] * x[i - 1] + y[j - 1 + m] * x[i - 1 + m]
+            )
+        # Compute the next dot products using previous ones
+        dot_prod[0] = first_dot_prod[i]
+        dp = _calculate_distance_profile(
+            dot_prod, x_mean[i], x_std[i], y_mean, y_std, m, subs_y
+        )
+        mp[i] = np.amin(dp)
+        ip[i] = np.argmin(dp)
+
+    return mp, ip
+
+
+def mpdist_pairwise_distance(
+    X: Union[np.ndarray, List[np.ndarray]],
+    y: Optional[Union[np.ndarray, List[np.ndarray]]] = None,
+    m: int = 0,
+) -> np.ndarray:
+    """Compute the mpdist pairwise distance between a set of time series.
+
+    Parameters
+    ----------
+    X : np.ndarray
+        A collection of time series instances  of shape ``(n_cases, n_timepoints)``.
+    y : np.ndarray or None, default=None
+        A single series or a collection of time series of shape ``(m_timepoints,)`` or
+        ``(m_cases, m_timepoints)``.
+        If None, then the mpdist pairwise distance between the instances of X is
+        calculated.
+    m : int (default = 0)
+        Length of the subsequence
+
+    Returns
+    -------
+    np.ndarray (n_cases, n_cases)
+        mpdist pairwise matrix between the instances of X if only X is given
+        else mpdist pairwise matrix between the instances of X and y.
+
+    Raises
+    ------
+    ValueError
+        If X is not 2D or 3D array when only passing X.
+        If X and y are not 1D, 2D arrays when passing both X and y.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from aeon.distances import mpdist_pairwise_distance
+    >>> # Distance between each time series in a collection of time series
+    >>> X = np.array([[16, 23, 19, 13],[48, 55, 63, 67]])
+    >>> mpdist_pairwise_distance(X, m = 3)
+    array([[0.        , 1.56786235],
+           [1.56786235, 0.        ]])
+
+    >>> # Distance between two collections of time series
+    >>> X = np.array([[[1, 2, 3]],[[4, 5, 6]], [[7, 8, 9]]])
+    >>> y = np.array([[[21, 13, 9]],[[19, 14, 5]], [[17, 11, 6]]])
+    >>> mpdist_pairwise_distance(X, y, m = 2)
+    array([[2.82842712, 2.82842712, 2.82842712],
+           [2.82842712, 2.82842712, 2.82842712],
+           [2.82842712, 2.82842712, 2.82842712]])
+
+    >>> X = np.array([[[1, 2, 3]],[[4, 5, 6]], [[7, 8, 9]]])
+    >>> y_univariate = np.array([[22, 18, 12]])
+    >>> mpdist_pairwise_distance(X, y_univariate, m = 2)
+    array([[2.82842712],
+           [2.82842712],
+           [2.82842712]])
+    """
+    if m == 0:
+        m = int(X.shape[1] / 4)
+
+    if y is None:
+        if X.ndim == 3 and X.shape[1] == 1:
+            X = np.squeeze(X)
+        return _mpdist_pairwise_distance_single(X, m)
+
+    X, y = reshape_pairwise_to_multiple(X, y)
+
+    return _mpdist_pairwise_distance(X, y, m)
+
+
+def _mpdist_pairwise_distance_single(x: NumbaList[np.ndarray], m: int) -> np.ndarray:
+    n_cases = len(x)
+    distances = np.zeros((n_cases, n_cases))
+
+    for i in range(n_cases):
+        for j in range(i + 1, n_cases):
+            distances[i, j] = mpdist(x[i], x[j], m)
+            distances[j, i] = distances[i, j]
+
+    return distances
+
+
+def _mpdist_pairwise_distance(
+    x: NumbaList[np.ndarray], y: NumbaList[np.ndarray], m: int
+) -> np.ndarray:
+    n_cases = len(x)
+    m_cases = len(y)
+
+    distances = np.zeros((n_cases, m_cases))
+
+    for i in range(n_cases):
+        for j in range(m_cases):
+            distances[i, j] = mpdist(x[i], y[j], m)
+    return distances
diff --git a/aeon/distances/mpdist.py b/aeon/distances/mpdist.py
deleted file mode 100644
index bbc3851a..00000000
--- a/aeon/distances/mpdist.py
+++ /dev/null
@@ -1,211 +0,0 @@
-"""Matrix Profile Distances."""
-
-import numpy as np
-
-
-def _sliding_dot_products(q, t, q_len, t_len):
-    """
-    Compute the sliding dot products between a query and a time series.
-
-    Parameters
-    ----------
-        q: numpy.array
-            Query.
-        t: numpy.array
-            Time series.
-        q_len: int
-            Length of the query.
-        t_len: int
-            Length of the time series.
-
-    Output
-    ------
-        dot_prod: numpy.array
-                    Sliding dot products between q and t.
-    """
-    # Reversing query and padding both query and time series
-    t_padded = np.pad(t, (0, t_len))
-    q_reversed = np.flipud(q)
-    q_reversed_padded = np.pad(q_reversed, (0, 2 * t_len - q_len))
-
-    # Applying FFT to both query and time series
-    t_fft = np.fft.fft(t_padded)
-    q_fft = np.fft.fft(q_reversed_padded)
-
-    # Applying inverse FFT to obtain the convolution of the time series by
-    # the query
-    element_wise_mult = np.multiply(t_fft, q_fft)
-    inverse_fft = np.fft.ifft(element_wise_mult)
-
-    # Returns only the valid dot products from inverse_fft
-    dot_prod = inverse_fft[q_len - 1 : t_len].real
-
-    return dot_prod
-
-
-def _calculate_distance_profile(
-    dot_prod, q_mean, q_std, t_mean, t_std, q_len, n_t_subs
-):
-    """
-    Calculate the distance profile for the given query.
-
-    Parameters
-    ----------
-        dot_prod: numpy.array
-            Sliding dot products between the time series and the query.
-        q_mean: float
-            Mean of the elements of the query.
-        q_std: float
-            Standard deviation of elements of the query.
-        t_mean: numpy.array
-            Array with the mean of the elements from each subsequence of
-            length(query) from the time series.
-        t_std: numpy.array
-            Array with the standard deviation of the elements from each
-            subsequence of length(query) from the time series.
-        q_len: int
-            Length of the query.
-        n_t_subs: int
-            Number of subsequences in the time series.
-
-    Output
-    ------
-        d: numpy.array
-            Distance profile of query q.
-    """
-    d = [
-        2
-        * q_len
-        * (
-            1
-            - ((dot_prod[i] - q_len * q_mean * t_mean[i]) / (q_len * q_std * t_std[i]))
-        )
-        for i in range(0, n_t_subs)
-    ]
-    d = np.absolute(d)
-    d = np.sqrt(d)
-
-    return d
-
-
-def _stomp_ab(ts1, ts2, m):
-    """
-    STOMP implementation for AB similarity join.
-
-    Parameters
-    ----------
-        ts1: numpy.array
-            First time series.
-        ts2: numpy.array
-            Second time series.
-        m: int
-            Length of the subsequences.
-
-    Output
-    ------
-        mp: numpy.array
-            Array with the distance between every subsequence from ts1
-            to the nearest subsequence with same length from ts2.
-        ip: numpy.array
-            Array with the index of the nearest neighbor of ts1 in ts2.
-    """
-    len1 = len(ts1)
-    len2 = len(ts2)
-
-    # Number of subsequences
-    n_ts1_subs = len1 - m + 1
-    n_ts2_subs = len2 - m + 1
-
-    # Compute the mean and standard deviation
-    ts1_mean = [np.mean(ts1[i : i + m]) for i in range(0, n_ts1_subs)]
-    ts1_std = [np.std(ts1[i : i + m]) for i in range(0, n_ts1_subs)]
-
-    ts2_mean = [np.mean(ts2[i : i + m]) for i in range(0, n_ts2_subs)]
-    ts2_std = [np.std(ts2[i : i + m]) for i in range(0, n_ts2_subs)]
-
-    # Compute the dot products between the first ts2 subsequence and every
-    # ts1 subsequence
-    dot_prod = _sliding_dot_products(ts2[0:m], ts1, m, len1)
-    first_dot_prod = np.copy(dot_prod)
-
-    # Initialization
-    mp = np.full(n_ts1_subs, float("inf"))  # matrix profile
-    ip = np.zeros(n_ts1_subs)  # index profile
-
-    # Compute the distance profile for the first ts1 subsequence
-    dot_prod = _sliding_dot_products(ts1[0:m], ts2, m, len2)
-    dp = _calculate_distance_profile(
-        dot_prod, ts1_mean[0], ts1_std[0], ts2_mean, ts2_std, m, n_ts2_subs
-    )
-
-    # Updates the matrix profile
-    mp[0] = np.amin(dp)
-    ip[0] = np.argmin(dp)
-
-    for i in range(1, n_ts1_subs):
-        for j in range(n_ts2_subs - 1, 0, -1):
-            dot_prod[j] = (
-                dot_prod[j - 1]
-                - ts2[j - 1] * ts1[i - 1]
-                + ts2[j - 1 + m] * ts1[i - 1 + m]
-            )  # compute the next dot products
-            # using the previous ones
-        dot_prod[0] = first_dot_prod[i]
-        dp = _calculate_distance_profile(
-            dot_prod, ts1_mean[i], ts1_std[i], ts2_mean, ts2_std, m, n_ts2_subs
-        )
-        mp[i] = np.amin(dp)
-        ip[i] = np.argmin(dp)
-
-    return mp, ip
-
-
-def mpdist(ts1: np.ndarray, ts2: np.ndarray, m: int = 0):
-    """
-    Matrix profile distance.
-
-    Parameters
-    ----------
-        ts1: numpy.array
-            First time series.
-        ts2: numpy.array
-            Second time series.
-        m: int
-            Length of the subsequences.
-
-    Output
-    ------
-        mpdist: float
-            Distance between the two time series.
-    """
-    if ts1.ndim == 2 and ts1.shape[0] > 1:
-        raise ValueError("ts1 must be a 1D array or shape (1,n)")
-    if ts2.ndim == 2 and ts2.shape[0] > 1:
-        raise ValueError("ts2 must be a 1D array or shape (1,n)")
-    ts1 = ts1.squeeze()
-    ts2 = ts2.squeeze()
-
-    len1 = len(ts1)
-    len2 = len(ts2)
-
-    if m == 0:
-        if len1 > len2:
-            m = int(len1 / 4)
-        else:
-            m = int(len2 / 4)
-    threshold = 0.05
-    mp_ab, ip_ab = _stomp_ab(ts1, ts2, m)  # compute the AB matrix profile
-    mp_ba, ip_ba = _stomp_ab(ts2, ts1, m)  # compute the BA matrix profile
-
-    join_mp = np.concatenate([mp_ab, mp_ba])
-
-    k = int(np.ceil(threshold * (len1 + len2)))
-
-    sorted_mp = np.sort(join_mp)  # sort the join matrix profile in ascending order
-
-    if len(sorted_mp) > k:
-        mpdist = sorted_mp[k]
-    else:
-        mpdist = sorted_mp[len(sorted_mp) - 1]
-
-    return mpdist
diff --git a/aeon/transformations/series/base.py b/aeon/transformations/series/base.py
index 209a2984..f38f9595 100644
--- a/aeon/transformations/series/base.py
+++ b/aeon/transformations/series/base.py
@@ -22,7 +22,7 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
     _tags = {
         "input_data_type": "Series",
         "output_data_type": "Series",
-        "X_inner_type": "ndarray",
+        "X_inner_type": "np.ndarray",
         "fit_is_empty": False,
         "requires_y": False,
         "capability:inverse_transform": False,
@@ -33,7 +33,7 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         super().__init__(axis=axis)
 
     @final
-    def fit(self, X, y=None, axis=None):
+    def fit(self, X, y=None, axis=1):
         """Fit transformer to X, optionally using y if supervised.
 
         State change:
@@ -46,9 +46,9 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
             ``pd.DataFrame``.
         y : Target variable, default=None
             Additional data, e.g., labels for transformation
-        axis : int, default = None
-            Axis along which to segment if passed a multivariate X series (2D input).
-            If axis is 0, it is assumed each column is a time series and each row is
+        axis : int, default = 1
+            Axis of time in the input series.
+            If ``axis == 0``, it is assumed each column is a time series and each row is
             a time point. i.e. the shape of the data is ``(n_timepoints,
             n_channels)``.
             ``axis == 1`` indicates the time series are in rows, i.e. the shape of
@@ -59,13 +59,13 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         -------
         self : a fitted instance of the estimator
         """
-        if self.get_tag("requires_y"):
-            if y is None:
-                raise ValueError("Tag requires_y is true, but fit called with y=None")
         # skip the rest if fit_is_empty is True
         if self.get_tag("fit_is_empty"):
             self._is_fitted = True
             return self
+        if self.get_tag("requires_y"):
+            if y is None:
+                raise ValueError("Tag requires_y is true, but fit called with y=None")
         # reset estimator at the start of fit
         self.reset()
         if axis is None:  # If none given, assume it is correct.
@@ -78,7 +78,7 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         return self
 
     @final
-    def transform(self, X, axis=None):
+    def transform(self, X, axis=1):
         """Transform X and return a transformed version.
 
         State required:
@@ -90,9 +90,9 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
             Data to fit transform to, of valid collection type.
         y : Target variable, default=None
             Additional data, e.g., labels for transformation
-        axis : int, default = None
-            Axis along which to segment if passed a multivariate X series (2D input).
-            If axis is 0, it is assumed each column is a time series and each row is
+        axis : int, default = 1
+            Axis of time in the input series.
+            If ``axis == 0``, it is assumed each column is a time series and each row is
             a time point. i.e. the shape of the data is ``(n_timepoints,
             n_channels)``.
             ``axis == 1`` indicates the time series are in rows, i.e. the shape of
@@ -106,9 +106,6 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         """
         # check whether is fitted
         self.check_is_fitted()
-
-        if axis is None:
-            axis = self.axis
         X = self._preprocess_series(
             X, axis=axis, store_metadata=self.get_class_tag("fit_is_empty")
         )
@@ -116,7 +113,7 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         return self._postprocess_series(Xt, axis=axis)
 
     @final
-    def fit_transform(self, X, y=None, axis=None):
+    def fit_transform(self, X, y=None, axis=1):
         """
         Fit to data, then transform it.
 
@@ -131,9 +128,9 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
             Data to fit transform to, of valid collection type.
         y : Target variable, default=None
             Additional data, e.g., labels for transformation
-        axis : int, default = None
-            Axis along which to segment if passed a multivariate X series (2D input).
-            If axis is 0, it is assumed each column is a time series and each row is
+        axis : int, default = 1
+            Axis of time in the input series.
+            If ``axis == 0``, it is assumed each column is a time series and each row is
             a time point. i.e. the shape of the data is ``(n_timepoints,
             n_channels)``.
             ``axis == 1`` indicates the time series are in rows, i.e. the shape of
@@ -153,7 +150,7 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
         return self._postprocess_series(Xt, axis=axis)
 
     @final
-    def inverse_transform(self, X, y=None, axis=None):
+    def inverse_transform(self, X, y=None, axis=1):
         """Inverse transform X and return an inverse transformed version.
 
         State required:
@@ -165,6 +162,14 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
             Data to fit transform to, of valid collection type.
         y : Target variable, default=None
              Additional data, e.g., labels for transformation
+        axis : int, default = 1
+            Axis of time in the input series.
+            If ``axis == 0``, it is assumed each column is a time series and each row is
+            a time point. i.e. the shape of the data is ``(n_timepoints,
+            n_channels)``.
+            ``axis == 1`` indicates the time series are in rows, i.e. the shape of
+            the data is ``(n_channels, n_timepoints)`.``axis is None`` indicates
+            that the axis of X is the same as ``self.axis``.
 
         Returns
         -------
@@ -310,3 +315,66 @@ class BaseSeriesTransformer(BaseSeriesEstimator, BaseTransformer, metaclass=ABCM
             Parameters to create testing instances of the class.
         """
         return {}
+
+    def _postprocess_series(self, Xt, axis):
+        """Postprocess data Xt to revert to original shape.
+
+        Parameters
+        ----------
+        Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
+            A valid aeon time series data structure. See
+            aeon.base._base_series.VALID_INPUT_TYPES for aeon supported types.
+            Intended for algorithms which have another series as output.
+        axis: int
+            The axids of time in the series.
+            If  ``axis==0``, it is
+            assumed each column is a time series and each row is a time point. i.e. the
+            shape of the data is ``(n_timepoints, n_channels)``. ``axis==1`` indicates
+            the time series are in rows, i.e. the shape of the data is
+            ``(n_channels, n_timepoints)``.
+            If None, the default class axis is used.
+
+        Returns
+        -------
+        Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
+            New time series input reshaped to match the original input.
+        """
+        if axis is None:
+            axis = self.axis
+
+        # If a univariate only transformer, return a univariate series
+        if not self.get_tag("capability:multivariate"):
+            Xt = Xt.squeeze()
+
+        # return with input axis
+        if Xt.ndim == 1 or axis == self.axis:
+            return Xt
+        else:
+            return Xt.T
+
+
+def _postprocess_series(self, Xt, axis):
+    """Postprocess data Xt to revert to original shape.
+
+    Parameters
+    ----------
+    Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
+        A valid aeon time series data structure. See
+        aeon.base._base_series.VALID_INPUT_TYPES for aeon supported types.
+        Intended for algorithms which have another series as output.
+    axis: int or None
+        The time point axis of the input series if it is 2D. If ``axis==0``, it is
+        assumed each column is a time series and each row is a time point. i.e. the
+        shape of the data is ``(n_timepoints, n_channels)``. ``axis==1`` indicates
+        the time series are in rows, i.e. the shape of the data is
+        ``(n_channels, n_timepoints)``.
+        If None, the default class axis is used.
+
+    Returns
+    -------
+    Xt: one of aeon.base._base_series.VALID_INPUT_TYPES
+        New time series input reshaped to match the original input.
+    """
+    # If a univariate only transformer, return a univariate series
+    if not self.get_tag("capability:multivariate"):
+        Xt = Xt.squeeze()
diff --git a/build_tools/run_examples.sh b/build_tools/run_examples.sh
index d03c4fc2..3eeac963 100755
--- a/build_tools/run_examples.sh
+++ b/build_tools/run_examples.sh
@@ -12,6 +12,16 @@ if [ "$1" = true ]; then
     "examples/benchmarking/reference_results.ipynb"
     "examples/benchmarking/bakeoff_results.ipynb"
     "examples/benchmarking/regression.ipynb"
+    "examples/clustering/partitional_clustering.ipynb"
+    "examples/classification/hybrid.ipynb"
+    "examples/classification/deep_learning.ipynb"
+    "examples/classification/dictionary_based.ipynb"
+    "examples/classification/distance_based.ipynb"
+    "examples/classification/feature_based.ipynb"
+    "examples/classification/interval_based.ipynb"
+    "examples/classification/shapelet_based.ipynb"
+    "examples/classification/convolution_based.ipynb"
+
   )
 fi
 
diff --git a/docs/contributing.md b/docs/contributing.md
index 13ddc649..cf7338c0 100644
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -20,10 +20,18 @@ for creating a fork of `aeon`.
 3. Pick an `enhancement`, `documentation` or `maintenance` issue from the [issue list](https://github.com/aeon-toolkit/aeon/issues)
 to complete i.e. improving an algorithm, docstring or test. The [good first issue](https://github.com/aeon-toolkit/aeon/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
 list may be a good place to start.
-4. Post on the issue which you want to work on, so that others know you are working on
-it. If it is a larger issue with multiple components, indicate which part you are
-working on. A Core Developer may suggest a different issue if the one you chose is
-complex or somebody is already working on it.
+4. Post on the issue which you want to work on, so that others know you are working on it. To assign yourself an **Issue/Pull Request**, please mention '@your_username' and use one of the following trigger phrases:
+    - Aeon-Assign bot
+    - assign
+    - assign this to
+
+    For example:
+    ```python
+    Aeon-Assign bot assign @your-username
+    ```
+    If it is a larger issue with multiple components, indicate which part you are
+    working on. A Core Developer may suggest a different issue if the one you chose is
+    complex or somebody is already working on it.
 5. Create a [pull request (PR)](https://github.com/aeon-toolkit/aeon/compare)
 with your changes from your fork. For help, see the [GitHub documentation](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork)
 or ask in Slack. Follow the PR template and checklist.
diff --git a/examples/base/series_estimator.ipynb b/examples/base/series_estimator.ipynb
index 50702eca..81a2237d 100644
--- a/examples/base/series_estimator.ipynb
+++ b/examples/base/series_estimator.ipynb
@@ -12,10 +12,17 @@
     "\n",
     "To use any algorithms extending the base estimator all you need to understand is the meaning of the `axis` parameter and the capability tags. `BaseSeriesEstimator` handles the preprocessing required before being used in methods such as `fit` and `predict`. These are used in inheriting base classes by applying the protected method `_preprocess_series`. The key steps to note are:\n",
     "1. Input data type should be a `np.ndarray`, a `pd.Series` or a `pd.DataFrame`.\n",
-    "2. Unless the `X_inner_type` of the estimator is `pd.Series`, the `axis` variable of the estimator controls how the input data is interpreted in methods such as `fit`, `predict` and `transform`. If `axis==0` then each column is a time series, and each row is a time point: i.e. the shape of the input data is `(n_timepoints, n_channels)`. If `axis==1` indicates the time series are in rows, i.e. the shape of the data is `(n_channels, n_timepoints)`. It is important to set this correctly or check the default used, otherwise your data may be processed incorrectly.\n",
-    "3. The input data will be transformed into the type required by the estimator as determined by the tag `X_inner_type`. This will also reshape the array to use the correct time point `axis` and expand the input to 2D if it is a 1D `np.ndarray`.\n",
-    "4. If the estimator can only work with univariate time series (`capability:multivariate` set to False) then the input data shape must be 1D or 2D with the selected channel `axis` being size 1.\n",
-    "5. If the estimator can only work with multivariate time series (`capability:univariate` set to False), then the input data must be 2D, with the selected channel `axis` greater than 1. `pd.Series` is not supported in this case.\n",
+    "2. The `axis` describes the direction of time. If `axis==0` then each column is a time\n",
+    "series, and each row is a time point: i.e. the shape of the input data is `\n",
+    "(n_timepoints, n_channels)`. `axis==1` indicates the time series are in rows, i.e.\n",
+    "the shape of the data is `(n_channels, n_timepoints)`. It is important to set this\n",
+    "correctly or check the default used, otherwise your data may be processed incorrectly\n",
+    ". The `axis` of an estimator  controls how the input data is interpreted in methods\n",
+    "such as `fit`, `predict` and `transform`.\n",
+    "3. The input data will be transformed into the type required by the estimator as\n",
+    "determined by the tag `X_inner_type`, which should be a string, either `\"np.ndarray\"`\n",
+    " or `\"pd.DataFrame\"`. 1D input data is converted to 2D in the `BaseEstimator` with\n",
+    " the axis determined by the estimator `axis` parameter.\n",
     "\n",
     "We demonstrate this with calls to private methods. This is purely to aid understanding and should not be used in practice."
    ],
@@ -28,6 +35,9 @@
     "ExecuteTime": {
      "end_time": "2024-04-10T15:04:57.444241Z",
      "start_time": "2024-04-10T15:04:55.744636Z"
+    },
+    "pycharm": {
+     "is_executing": true
     }
    },
    "cell_type": "code",
@@ -42,12 +52,14 @@
     "bs = BaseSeriesEstimator(axis=0)"
    ],
    "outputs": [],
-   "execution_count": 1
+   "execution_count": null
   },
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": "## Univariate examples"
+   "source": [
+    "## Univariate examples"
+   ]
   },
   {
    "metadata": {
@@ -219,67 +231,12 @@
    ],
    "execution_count": 7
   },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-10T15:04:57.497917Z",
-     "start_time": "2024-04-10T15:04:57.490936Z"
-    }
-   },
-   "cell_type": "code",
-   "source": [
-    "bs = bs.set_tags(**{\"X_inner_type\": \"pd.Series\"})\n",
-    "d1 = np.random.random(size=(100))\n",
-    "d2 = bs._preprocess_series(d1, axis=0, store_metadata=True)\n",
-    "print(\n",
-    "    f\"7. Input type = {type(d1)}, input shape = {d1.shape}, \"\n",
-    "    f\"output type = {type(d2)}, output shape = {d2.shape}\"\n",
-    ")\n",
-    "bs = bs.set_tags(**{\"X_inner_type\": \"np.ndarray\"})"
-   ],
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "7. Input type = <class 'numpy.ndarray'>, input shape = (100,), output type = <class 'pandas.core.series.Series'>, output shape = (100,)\n"
-     ]
-    }
-   ],
-   "execution_count": 8
-  },
-  {
-   "cell_type": "code",
-   "source": [
-    "# Passing a multivariate array will raise an error if capability:multivariate is False\n",
-    "d1 = np.random.random(size=(100, 5))\n",
-    "try:\n",
-    "    bs._preprocess_series(d1, axis=0, store_metadata=True)\n",
-    "except ValueError as e:\n",
-    "    print(f\"8. {e}\")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "ExecuteTime": {
-     "end_time": "2024-04-10T15:04:57.504899Z",
-     "start_time": "2024-04-10T15:04:57.498915Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "8. Multivariate data not supported by BaseSeriesEstimator\n"
-     ]
-    }
-   ],
-   "execution_count": 9
-  },
   {
    "metadata": {},
    "cell_type": "markdown",
-   "source": "## Multivariate examples"
+   "source": [
+    "## Multivariate examples"
+   ]
   },
   {
    "metadata": {
@@ -397,36 +354,6 @@
    ],
    "execution_count": 13
   },
-  {
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-10T15:04:57.540803Z",
-     "start_time": "2024-04-10T15:04:57.535816Z"
-    }
-   },
-   "cell_type": "code",
-   "source": [
-    "# As pd.Series is univariate only, it is not allowed as an inner type for multivariate\n",
-    "# This should not be an issue for usage, just for development\n",
-    "bs = bs.set_tags(**{\"X_inner_type\": \"pd.Series\"})\n",
-    "d1 = np.random.random(size=(100, 5))\n",
-    "try:\n",
-    "    d2 = bs._preprocess_series(d1, axis=1, store_metadata=True)\n",
-    "except ValueError as e:\n",
-    "    print(f\"4. {e}\")\n",
-    "bs = bs.set_tags(**{\"X_inner_type\": \"np.ndarray\"})"
-   ],
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4. Cannot convert to pd.Series for multivariate capable estimators\n"
-     ]
-    }
-   ],
-   "execution_count": 14
-  },
   {
    "metadata": {
     "ExecuteTime": {
@@ -456,7 +383,9 @@
   },
   {
    "cell_type": "markdown",
-   "source": "If implementing a new estimator that extends `BaseSeriesEstimator` then just set the `axis` to the shape you want to work with by passing it to the `BaseSeriesEstimator` constructor. If your estimator can handle multivariate series, set the tag and set the `capability:multivariate` tag to `True`.  Set the `X_inner_type` tag if you wish to use a datatype other than `np.ndarray`.",
+   "source": [
+    "If implementing a new estimator that extends `BaseSeriesEstimator` then just set the `axis` to the shape you want to work with by passing it to the `BaseSeriesEstimator` constructor. If your estimator can handle multivariate series, set the tag and set the `capability:multivariate` tag to `True`.  Set the `X_inner_type` tag if you wish to use a datatype other than `np.ndarray`."
+   ],
    "metadata": {
     "collapsed": false
    }
diff --git a/examples/clustering/partitional_clustering.ipynb b/examples/clustering/partitional_clustering.ipynb
index d42dc972..032512cf 100644
--- a/examples/clustering/partitional_clustering.ipynb
+++ b/examples/clustering/partitional_clustering.ipynb
@@ -468,7 +468,7 @@
     {
      "data": {
       "text/plain": "<Figure size 640x480 with 2 Axes>",
-      "image/png": "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"
+      "image/png": "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"
      },
      "metadata": {},
      "output_type": "display_data"
@@ -516,7 +516,7 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "-26092.080757984702"
+      "text/plain": "-26178.727675421676"
      },
      "execution_count": 8,
      "metadata": {},
diff --git a/examples/transformations/sast.ipynb b/examples/transformations/sast.ipynb
index 635fdcff..318effbd 100644
--- a/examples/transformations/sast.ipynb
+++ b/examples/transformations/sast.ipynb
@@ -81,7 +81,7 @@
    },
    "outputs": [],
    "source": [
-    "X_train, y_train = load_classification(\"Chinatown\", split=\"train\")"
+    "X_train, y_train = load_classification(\"UnitTest\", split=\"train\")"
    ]
   },
   {
@@ -188,7 +188,7 @@
    },
    "outputs": [],
    "source": [
-    "X_test, y_test = load_classification(\"Chinatown\", split=\"test\")\n",
+    "X_test, y_test = load_classification(\"UnitTest\", split=\"test\")\n",
     "X_test_transform = sast.transform(X_test)"
    ]
   },
@@ -304,7 +304,7 @@
     }
    ],
    "source": [
-    "X_train, y_train = load_classification(\"Chinatown\", split=\"train\")\n",
+    "X_train, y_train = load_classification(\"UnitTest\", split=\"train\")\n",
     "\n",
     "# it is necessary to pass y_train to the pipeline\n",
     "# y_train is not used for the transform, but it is used by the classifier\n",
@@ -342,7 +342,7 @@
     }
    ],
    "source": [
-    "X_test, y_test = load_classification(\"Chinatown\", split=\"test\")\n",
+    "X_test, y_test = load_classification(\"UnitTest\", split=\"test\")\n",
     "\n",
     "sast_pipeline.score(X_test, y_test)"
    ]
@@ -444,7 +444,7 @@
    "source": [
     "### 4.4 Interpretability\n",
     "\n",
-    "SASTClassifier's interpretability can be achieved by visualizing the most important subsequences used for the transformation. \n",
+    "SASTClassifier's interpretability can be achieved by visualizing the most important subsequences used for the transformation.\n",
     "\n",
     "The importance of features can be computed by different means. In this demo, we considere the absolute values of the weights of the ridge classifier as the feature importances.\n",
     "\n",
@@ -506,10 +506,10 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### 4.4.3 Interpretability summary \n",
+    "#### 4.4.3 Interpretability summary\n",
     "\n",
-    "We can see that the most important subsequences matche the instance from class `1` quite exactly, meaning that these subsequences are characteristic of this class. \n",
-    "On the contrary, they failed to match the instance from class `2`. These subsequences can be called Shapelets for this dataset. \n",
+    "We can see that the most important subsequences matche the instance from class `1` quite exactly, meaning that these subsequences are characteristic of this class.\n",
+    "On the contrary, they failed to match the instance from class `2`. These subsequences can be called Shapelets for this dataset.\n",
     "\n",
     "Feel free to play with different time series from the dataset, or with a different dataset"
    ]


Test patch:
diff --git a/aeon/base/tests/test_base_series.py b/aeon/base/tests/test_base_series.py
index e0ea7a40..9999db47 100644
--- a/aeon/base/tests/test_base_series.py
+++ b/aeon/base/tests/test_base_series.py
@@ -43,11 +43,15 @@ MULTIVARIATE_MISSING["pd.DataFrame"].iloc[
 ] = np.NAN
 
 
-VALID_TYPES = [
+VALID_INPUT_TYPES = [
     "np.ndarray",
     "pd.Series",
     "pd.DataFrame",
 ]
+VALID_INNER_TYPES = [
+    "np.ndarray",
+    "pd.DataFrame",
+]
 
 
 def test_check_X():
@@ -153,7 +157,7 @@ def test_check_X():
         dummy._check_X(collection, axis=0)
 
 
-@pytest.mark.parametrize("input_type", VALID_TYPES)
+@pytest.mark.parametrize("input_type", VALID_INPUT_TYPES)
 def test_convert_X_ndarray_inner(input_type):
     """Test _convert_X on with np.ndarray inner type."""
     dummy = BaseSeriesEstimator(axis=1)
@@ -187,40 +191,7 @@ def test_convert_X_ndarray_inner(input_type):
         assert_equal(X2, X3)
 
 
-@pytest.mark.parametrize("input_type", VALID_TYPES)
-def test_convert_X_series_inner(input_type):
-    """Test _convert_X on with pd.Series inner type."""
-    dummy = BaseSeriesEstimator(axis=1)
-    dummy.set_tags(**{"X_inner_type": "pd.Series"})
-    # test univariate
-    X = UNIVARIATE[input_type]
-
-    X2 = dummy._convert_X(X, axis=1)
-    assert type(X2).__name__ == "Series"
-    assert X2.shape == (20,)
-    assert X.shape[-1] == X2.shape[0]
-
-    X3 = dummy._convert_X(X.T, axis=0)
-    assert type(X3).__name__ == "Series"
-    assert X3.shape == (20,)
-    assert X2.equals(X3)
-
-    # test multivariate, should raise error as pd.Series cannot be multivariate
-    if input_type != "pd.Series":
-        X = MULTIVARIATE[input_type]
-
-        with pytest.raises(ValueError, match="multivariate data. Found 5 channels"):
-            dummy._convert_X(X, axis=1)
-
-        dummy.set_tags(**{"capability:multivariate": True})
-
-        with pytest.raises(ValueError, match="for multivariate capable estimators"):
-            dummy._convert_X(X, axis=1)
-        with pytest.raises(ValueError, match="for multivariate capable estimators"):
-            dummy._convert_X(X.T, axis=0)
-
-
-@pytest.mark.parametrize("input_type", VALID_TYPES)
+@pytest.mark.parametrize("input_type", VALID_INPUT_TYPES)
 def test_convert_X_dataframe_inner(input_type):
     """Test _convert_X on with pd.DataFrame inner type."""
     dummy = BaseSeriesEstimator(axis=1)
@@ -268,8 +239,8 @@ def test_convert_X_invalid():
         dummy._convert_X(UNIVARIATE["np.ndarray"], axis=1)
 
 
-@pytest.mark.parametrize("input_type", VALID_TYPES)
-@pytest.mark.parametrize("inner_type", VALID_TYPES)
+@pytest.mark.parametrize("input_type", VALID_INPUT_TYPES)
+@pytest.mark.parametrize("inner_type", VALID_INNER_TYPES)
 def test_preprocess_series(input_type, inner_type):
     """Test _preprocess_series for different input and inner types."""
     dummy = BaseSeriesEstimator(axis=1)
@@ -320,57 +291,6 @@ def test_preprocess_series(input_type, inner_type):
             dummy._preprocess_series(X, axis=1, store_metadata=True)
 
 
-@pytest.mark.parametrize("returned_type", VALID_TYPES)
-def test_postprocess_series(returned_type):
-    """Test data reformatted correctly by _postprocess_series."""
-    dummy = BaseSeriesEstimator(axis=1)
-    # test univariate
-    Xu = UNIVARIATE[returned_type]
-
-    X2 = dummy._postprocess_series(Xu, axis=1)
-    assert X2.ndim == 1
-    assert X2.shape == (20,)
-
-    X3 = dummy._postprocess_series(Xu.T, axis=0)
-    assert X2.shape == X3.shape
-
-    # test multivariate and 2d, excludes pd.Series input type as it is 1D only
-    if returned_type != "pd.Series":
-        Xu = Xu.reshape((1, -1)) if returned_type == "np.ndarray" else Xu
-        Xm = MULTIVARIATE[returned_type]
-
-        X2 = dummy._postprocess_series(Xu, axis=1)
-        assert X2.ndim == 1
-        assert X2.shape == (20,)
-
-        X3 = dummy._postprocess_series(Xu.T, axis=0)
-        assert X2.shape == X3.shape
-
-        X2 = dummy._postprocess_series(Xm, axis=1)
-        assert X2.ndim == 2
-        assert X2.shape == (5, 20)
-
-        X3 = dummy._postprocess_series(Xm.T, axis=0)
-        assert X2.shape == X3.shape
-
-        # multivariate capable estimator
-        dummy.set_tags(**{"capability:multivariate": True})
-
-        X2 = dummy._postprocess_series(Xu, axis=1)
-        assert X2.ndim == 2
-        assert X2.shape == (1, 20)
-
-        X3 = dummy._postprocess_series(Xu.T, axis=0)
-        assert X2.shape == X3.shape
-
-        X2 = dummy._postprocess_series(Xm, axis=1)
-        assert X2.ndim == 2
-        assert X2.shape == (5, 20)
-
-        X3 = dummy._postprocess_series(Xm.T, axis=0)
-        assert X2.shape == X3.shape
-
-
 def test_axis():
     """Test axis property."""
     dummy = BaseSeriesEstimator(axis=1)
diff --git a/aeon/distances/tests/test_mpdist.py b/aeon/distances/tests/test_mpdist.py
index ac1b1fd1..97352be9 100644
--- a/aeon/distances/tests/test_mpdist.py
+++ b/aeon/distances/tests/test_mpdist.py
@@ -1,8 +1,10 @@
 """Test MPDist function."""
 
+import re
+
 import pytest
 
-from aeon.distances.mpdist import mpdist
+from aeon.distances._mpdist import mpdist
 from aeon.testing.utils.data_gen import make_series
 
 
@@ -10,10 +12,24 @@ def test_mpdist():
     """Minimal test for MPDist prior to redesign."""
     x = make_series(10, return_numpy=True, random_state=1)
     y = make_series(10, 2, return_numpy=True, random_state=2)
-    with pytest.raises(ValueError, match="ts1 must be a 1D array"):
+
+    # Test for ValueError if ts1 is not a 1D array
+    with pytest.raises(
+        ValueError,
+        match=re.escape("x and y must be a 1D array of shape (n_timepoints,)"),
+    ):
         mpdist(y, y)
-    with pytest.raises(ValueError, match="ts2 must be a 1D array"):
+
+    # Test for ValueError if ts2 is not a 1D array
+    with pytest.raises(
+        ValueError,
+        match=re.escape("x and y must be a 1D array of shape (n_timepoints,)"),
+    ):
         mpdist(x, y)
+
     y = make_series(10, 1, return_numpy=True, random_state=2)
+
+    # Test MPDist function with valid inputs
     d = mpdist(x, y)
-    assert d >= 0
+    assert isinstance(d, float)  # Check if the result is a float
+    assert d >= 0  # Check if the distance is non-negative