From 82b79b178768641268660ff773f5c1c084001f99 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Mar 2024 16:06:33 +0100
Subject: [PATCH 1/2] Bump mamba-org/setup-micromamba from 1.8.0 to 1.8.1
 (#914)

Bumps [mamba-org/setup-micromamba](https://github.com/mamba-org/setup-micromamba) from 1.8.0 to 1.8.1.
- [Release notes](https://github.com/mamba-org/setup-micromamba/releases)
- [Commits](https://github.com/mamba-org/setup-micromamba/compare/v1.8.0...v1.8.1)

---
updated-dependencies:
- dependency-name: mamba-org/setup-micromamba
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/build_pkg.yml       | 2 +-
 .github/workflows/docs.yml            | 2 +-
 .github/workflows/pytest.yml          | 4 ++--
 .github/workflows/pytest_asdf.yml     | 2 +-
 .github/workflows/static_analysis.yml | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build_pkg.yml b/.github/workflows/build_pkg.yml
index 5a3da2e81..2b3730742 100644
--- a/.github/workflows/build_pkg.yml
+++ b/.github/workflows/build_pkg.yml
@@ -41,7 +41,7 @@ jobs:
           fetch-depth: 0 # Fetch all history for all tags and branches
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./devtools/conda.recipe/build_env.yml
           environment-name: build_env
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 9926871f7..32caec587 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -47,7 +47,7 @@ jobs:
           fetch-depth: 0 # Fetch all history for all tags and branches
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./doc/rtd_environment.yml
           environment-name: rtd
diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml
index d6b5bd1d3..1e015e4a5 100644
--- a/.github/workflows/pytest.yml
+++ b/.github/workflows/pytest.yml
@@ -47,7 +47,7 @@ jobs:
           setup_requires: 'include'
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./environment.yml
           environment-name: weldx
@@ -147,7 +147,7 @@ jobs:
           setup_requires: 'include'
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./environment.yml
           environment-name: weldx
diff --git a/.github/workflows/pytest_asdf.yml b/.github/workflows/pytest_asdf.yml
index b022a895e..511558463 100644
--- a/.github/workflows/pytest_asdf.yml
+++ b/.github/workflows/pytest_asdf.yml
@@ -33,7 +33,7 @@ jobs:
           setup_requires: 'include'
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./environment.yml
           environment-name: weldx
diff --git a/.github/workflows/static_analysis.yml b/.github/workflows/static_analysis.yml
index 8da2bbf9d..1d092f4a8 100644
--- a/.github/workflows/static_analysis.yml
+++ b/.github/workflows/static_analysis.yml
@@ -49,7 +49,7 @@ jobs:
           key: ${{ runner.os }}-${{ hashFiles('./environment.yml') }}
 
       - name: Setup Conda Environment
-        uses: mamba-org/setup-micromamba@v1.8.0
+        uses: mamba-org/setup-micromamba@v1.8.1
         with:
           environment-file: ./environment.yml
           environment-name: weldx

From ab583bea6d9b2d7a3d0525d71c57796022f0afda Mon Sep 17 00:00:00 2001
From: "Martin K. Scherer" <marscher@users.noreply.github.com>
Date: Tue, 12 Mar 2024 09:14:42 +0100
Subject: [PATCH 2/2] use pandas.to_timedelta function instead of invoking
 deprecated ctor arg (#918)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* use pandas.to_timedelta function instead of invoking deprecated ctor (unit argument will be gone)

* handle all old units

* pin pandas >=1.5

* Update weldx/tags/time/timedeltaindex.py

Co-authored-by: Çağtay Fabry <cagtay.fabry@bam.de>
---
 CHANGELOG.md                                  |  12 +-
 pyproject.toml                                |   5 +-
 .../weldx.bam.de/weldx/time/time-0.1.0.yaml   |   2 +-
 .../weldx/time/timedeltaindex-0.1.0.yaml      |   2 +-
 weldx/tags/time/timedeltaindex.py             |  10 +
 weldx/tests/asdf_tests/test_asdf_core.py      |   4 +-
 weldx/tests/test_core.py                      |  24 ++-
 weldx/tests/test_time.py                      |  70 ++++---
 weldx/tests/test_utility.py                   |  10 +-
 .../tests/transformations/test_cs_manager.py  |  59 +++---
 weldx/tests/transformations/test_local_cs.py  | 174 ++++++++++--------
 weldx/time.py                                 |   4 +-
 12 files changed, 218 insertions(+), 158 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df56ffb2c..8c219869a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,20 @@
 # Release Notes
 
+## 0.6.8 (unreleased)
+
+### Changes
+
+- use pandas.to_timedelta function to pass units to the TimeDeltaIndex object \[{pull}`918`\].
+
+### Dependencies
+
+- unpin nbval testing dependency.
+
 ## 0.6.7 (2023.08.24)
 
 ### Added
 
-- added `weldx.exceptions` module with `WeldxException` \[{pull}`871`\] .
+- added `weldx.exceptions` module with `WeldxException` \[{pull}`871`\].
 
 ### Fixes
 
diff --git a/pyproject.toml b/pyproject.toml
index e65f52b13..d06cc4ff9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -37,7 +37,7 @@ requires-python = ">=3.9"
 dependencies = [
     "numpy >=1.20",
     "asdf >=2.15.1",
-    "pandas >=1.0",
+    "pandas >=1.5",
     "xarray >=2022.9.0",
     "scipy >=1.6.2",
     "sympy >=1.6",
@@ -64,7 +64,7 @@ test = [
     "pytest >=6",
     "pytest-cov",
     "pytest-xdist",
-    "nbval <0.10",
+    "nbval",
 ]
 vis = [
     "weldx_widgets >=0.2",
@@ -125,6 +125,7 @@ filterwarnings = [
     "ignore::DeprecationWarning:traittypes.*:",
     "ignore:Passing method to :FutureWarning:xarray.*:",
     "error::pint.UnitStrippedWarning",
+    #"error::FutureWarning",  # todo: we want to enable this, as it notifies us about upcoming failures due to upstream changes.
 ]
 
 [tool.coverage.run]
diff --git a/weldx/schemas/weldx.bam.de/weldx/time/time-0.1.0.yaml b/weldx/schemas/weldx.bam.de/weldx/time/time-0.1.0.yaml
index ddb82852a..0274cb826 100644
--- a/weldx/schemas/weldx.bam.de/weldx/time/time-0.1.0.yaml
+++ b/weldx/schemas/weldx.bam.de/weldx/time/time-0.1.0.yaml
@@ -34,7 +34,7 @@ examples:
         values: !<asdf://weldx.bam.de/weldx/tags/time/datetimeindex-0.1.0>
           start: !<asdf://weldx.bam.de/weldx/tags/time/timestamp-0.1.0> '2021-01-01T00:00:00'
           end: !<asdf://weldx.bam.de/weldx/tags/time/timestamp-0.1.0> '2021-01-01T00:00:02'
-          freq: S
+          freq: s
           min: !<asdf://weldx.bam.de/weldx/tags/time/timestamp-0.1.0> '2021-01-01T00:00:00'
           max: !<asdf://weldx.bam.de/weldx/tags/time/timestamp-0.1.0> '2021-01-01T00:00:02'
         reference_time: !<asdf://weldx.bam.de/weldx/tags/time/timestamp-0.1.0> '2021-01-01T00:00:00'
diff --git a/weldx/schemas/weldx.bam.de/weldx/time/timedeltaindex-0.1.0.yaml b/weldx/schemas/weldx.bam.de/weldx/time/timedeltaindex-0.1.0.yaml
index cf83e4f85..e5a8c5587 100644
--- a/weldx/schemas/weldx.bam.de/weldx/time/timedeltaindex-0.1.0.yaml
+++ b/weldx/schemas/weldx.bam.de/weldx/time/timedeltaindex-0.1.0.yaml
@@ -13,7 +13,7 @@ examples:
       !<asdf://weldx.bam.de/weldx/tags/time/timedeltaindex-0.1.0>
         start: !<asdf://weldx.bam.de/weldx/tags/time/timedelta-0.1.0> P0DT0H0M0S
         end: !<asdf://weldx.bam.de/weldx/tags/time/timedelta-0.1.0> P0DT0H0M10S
-        freq: 2S
+        freq: 2s
         min: !<asdf://weldx.bam.de/weldx/tags/time/timedelta-0.1.0> P0DT0H0M0S
         max: !<asdf://weldx.bam.de/weldx/tags/time/timedelta-0.1.0> P0DT0H0M10S
   -
diff --git a/weldx/tags/time/timedeltaindex.py b/weldx/tags/time/timedeltaindex.py
index d6b72f574..b0aeac6eb 100644
--- a/weldx/tags/time/timedeltaindex.py
+++ b/weldx/tags/time/timedeltaindex.py
@@ -8,6 +8,14 @@
 
 __all__ = ["TimedeltaIndexConverter"]
 
+PANDAS_OLD_UNIT_SUFFIXES = dict(H="h", T="min", S="s", L="ms", U="us", N="ns")
+
+
+def _handle_converted_pd_tdi_units(node: TaggedDict):
+    """Convert changed units in Pandas.Datetimeindex to valid values."""
+    for suf in PANDAS_OLD_UNIT_SUFFIXES:
+        node["freq"] = node["freq"].replace(suf, PANDAS_OLD_UNIT_SUFFIXES[suf])
+
 
 class TimedeltaIndexConverter(WeldxConverter):
     """A simple implementation of serializing pandas TimedeltaIndex."""
@@ -33,6 +41,7 @@ def to_yaml_tree(self, obj: pd.TimedeltaIndex, tag: str, ctx) -> dict:
     def from_yaml_tree(self, node: dict, tag: str, ctx):
         """Construct TimedeltaIndex from tree."""
         if "freq" in node:
+            _handle_converted_pd_tdi_units(node)
             return pd.timedelta_range(
                 start=node["start"], end=node["end"], freq=node["freq"]
             )
@@ -43,6 +52,7 @@ def from_yaml_tree(self, node: dict, tag: str, ctx):
     def shape_from_tagged(node: TaggedDict) -> list[int]:
         """Calculate the shape from static tagged tree instance."""
         if "freq" in node:
+            _handle_converted_pd_tdi_units(node)
             tdi_temp = pd.timedelta_range(
                 start=str(node["start"]),  # can't handle TaggedString directly
                 end=str(node["end"]),
diff --git a/weldx/tests/asdf_tests/test_asdf_core.py b/weldx/tests/asdf_tests/test_asdf_core.py
index 67e92bdc9..dadc7c270 100644
--- a/weldx/tests/asdf_tests/test_asdf_core.py
+++ b/weldx/tests/asdf_tests/test_asdf_core.py
@@ -424,12 +424,12 @@ def test_coordinate_system_manager_time_dependencies(
         lcs_tdp_1_time_ref = pd.Timestamp("2000-03-17")
     lcs_tdp_1 = tf.LocalCoordinateSystem(
         coordinates=Q_([[1, 2, 3], [4, 5, 6]], "mm"),
-        time=pd.TimedeltaIndex([1, 2], "D"),
+        time=pd.to_timedelta([1, 2], "D"),
         time_ref=lcs_tdp_1_time_ref,
     )
     lcs_tdp_2 = tf.LocalCoordinateSystem(
         coordinates=Q_([[3, 7, 3], [9, 5, 8]], "mm"),
-        time=pd.TimedeltaIndex([1, 2], "D"),
+        time=pd.to_timedelta([1, 2], "D"),
         time_ref=pd.Timestamp("2000-03-21"),
     )
 
diff --git a/weldx/tests/test_core.py b/weldx/tests/test_core.py
index a8ac6cdd8..b70d111eb 100644
--- a/weldx/tests/test_core.py
+++ b/weldx/tests/test_core.py
@@ -227,10 +227,9 @@ class TestTimeSeries:
 
     ME = MathematicalExpression
     DTI = pd.DatetimeIndex
-    TDI = pd.TimedeltaIndex
     TS = TimeSeries
 
-    time_discrete = pd.TimedeltaIndex([0, 1, 2, 3, 4], unit="s")
+    time_discrete = pd.to_timedelta([0, 1, 2, 3, 4], "s")
     value_constant = Q_(1, "m")
     values_discrete = Q_(np.array([10, 11, 12, 14, 16]), "mm")
     me_expr_str = "a*t + b"
@@ -251,7 +250,7 @@ class TestTimeSeries:
         "data, time, interpolation, shape_exp",
         [
             (Q_(1, "m"), None, None, (1,)),
-            (Q_([3, 7, 1], "m"), TDI([0, 1, 2], unit="s"), "step", (3,)),
+            (Q_([3, 7, 1], "m"), pd.to_timedelta([0, 1, 2], unit="s"), "step", (3,)),
             (Q_([3, 7, 1], ""), Q_([0, 1, 2], "s"), "step", (3,)),
             (Q_([3, 7, 1], ""), DTI(["2010", "2011", "2012"]), "step", (3,)),
         ],
@@ -329,12 +328,17 @@ def test_construction_expression(data, shape_exp, unit_exp):
     @pytest.mark.parametrize(
         "data, dims, coords, exception_type",
         [
-            (Q_([1, 2, 3], "m"), "time", dict(time=TDI([1, 2, 3])), None),
-            (Q_([1, 2, 3], "m"), "a", dict(a=TDI([1, 2, 3])), KeyError),
-            (Q_([[1, 2]], "m"), ("a", "time"), dict(a=[2], time=TDI([1, 2])), None),
+            (Q_([1, 2, 3], "m"), "time", dict(time=pd.to_timedelta([1, 2, 3])), None),
+            (Q_([1, 2, 3], "m"), "a", dict(a=pd.to_timedelta([1, 2, 3])), KeyError),
+            (
+                Q_([[1, 2]], "m"),
+                ("a", "time"),
+                dict(a=[2], time=pd.to_timedelta([1, 2])),
+                None,
+            ),
             (Q_([1, 2, 3], "m"), "time", None, KeyError),
             (Q_([1, 2, 3], "m"), "time", dict(time=[1, 2, 3]), TypeError),
-            ([1, 2, 3], "time", dict(time=TDI([1, 2, 3])), TypeError),
+            ([1, 2, 3], "time", dict(time=pd.to_timedelta([1, 2, 3])), TypeError),
         ],
     )
     @pytest.mark.parametrize("reference_time", [None, "2000-01-01"])
@@ -382,7 +386,7 @@ def test_construction_exceptions(
 
     # test_comparison -------------------------------------
 
-    time_wrong_values = TDI([0, 1, 2, 3, 5], unit="s")
+    time_wrong_values = pd.to_timedelta([0, 1, 2, 3, 5], "s")
     values_discrete_wrong = Q_(np.array([10, 11, 12, 15, 16]), "mm")
     values_unit_wrong = Q_(np.array([10, 11, 12, 14, 16]), "s")
     values_unit_prefix_wrong = Q_(np.array([10, 11, 12, 14, 16]), "m")
@@ -426,9 +430,9 @@ def test_comparison(ts, ts_other, result_exp):
 
     # test_interp_time -----------------------------------------------------------------
 
-    time_single = pd.TimedeltaIndex([2.1], "s")
+    time_single = pd.to_timedelta([2.1], "s")
     time_single_q = Q_(2.1, "s")
-    time_mul = pd.TimedeltaIndex([-3, 0.7, 1.1, 1.9, 2.5, 3, 4, 7], "s")
+    time_mul = pd.to_timedelta([-3, 0.7, 1.1, 1.9, 2.5, 3, 4, 7], "s")
     time_mul_q = Q_([-3, 0.7, 1.1, 1.9, 2.5, 3, 4, 7], "s")
     results_exp_vec = [
         [-8, 3, -3],
diff --git a/weldx/tests/test_time.py b/weldx/tests/test_time.py
index 8e979fdad..2ca0028ee 100644
--- a/weldx/tests/test_time.py
+++ b/weldx/tests/test_time.py
@@ -7,7 +7,6 @@
 import xarray as xr
 from pandas import DatetimeIndex as DTI
 from pandas import Timedelta, Timestamp, date_range
-from pandas import TimedeltaIndex as TDI
 from pint import DimensionalityError
 
 from weldx.constants import Q_
@@ -77,7 +76,7 @@ def _initialize_time_type(
 
 def _is_timedelta(cls_type):
     """Return ``True`` if the passed type is a timedelta type."""
-    return cls_type in [TDI, Timedelta, np.timedelta64] or (
+    return cls_type in [pd.to_timedelta, Timedelta, np.timedelta64] or (
         cls_type is Time and not Time.is_absolute
     )
 
@@ -143,7 +142,9 @@ def _get_init_exp_values(
             val = [v + offset for v in delta_val]
 
         val = val[0] if data_was_scalar else val
-        exp_timedelta = Timedelta(val, "s") if data_was_scalar else TDI(val, "s")
+        exp_timedelta = (
+            Timedelta(val, "s") if data_was_scalar else pd.to_timedelta(val, "s")
+        )
 
         # expected datetime
         exp_datetime = None
@@ -168,7 +169,7 @@ def _get_init_exp_values(
             (str, "timedelta"),
             (Time, "timedelta"),
             (Q_, "timedelta"),
-            TDI,
+            pd.to_timedelta,
             Timedelta,
             np.timedelta64,
             (str, "datetime"),
@@ -209,7 +210,7 @@ def test_init(
         # skip matrix cases that do not work --------------------
         if arr and input_type in [Timedelta, Timestamp]:
             return
-        if not arr and input_type in [DTI, TDI]:
+        if not arr and input_type in [DTI, pd.to_timedelta]:
             return
 
         # create input values -----------------------------------
@@ -247,7 +248,7 @@ def test_init(
             LocalCoordinateSystem(
                 coordinates=Q_(np.zeros((2, 3)), "mm"), time=["2000", "2001"]
             ),
-            TimeSeries(Q_([2, 4, 1], "m"), TDI([1, 2, 3], "s")),
+            TimeSeries(Q_([2, 4, 1], "m"), pd.to_timedelta([1, 2, 3], "s")),
             TimeSeries(Q_([2, 4, 1], "m"), ["2001", "2002", "2003"]),
         ],
     )
@@ -262,7 +263,7 @@ def test_init_from_time_dependent_types(time_dep_type):
     @pytest.mark.parametrize(
         "time, time_ref, raises",
         [
-            (TDI([3, 2, 1]), None, ValueError),
+            (pd.to_timedelta([3, 2, 1]), None, ValueError),
             (DTI(["2010", "2000"]), None, ValueError),
             (["2010", "2000"], None, ValueError),
             (Q_([3, 2, 1], "s"), None, ValueError),
@@ -290,7 +291,7 @@ def test_init_exception(time, time_ref, raises):
             (str, "timedelta"),
             (Time, "timedelta"),
             (Q_, "timedelta"),
-            TDI,
+            pd.to_timedelta,
             Timedelta,
             np.timedelta64,
             (str, "datetime"),
@@ -331,7 +332,7 @@ def test_add_timedelta(
         # skip array cases where the type does not support arrays
         if other_type in [Timedelta, Timestamp] and other_is_array:
             return
-        if not other_is_array and other_type in [DTI, TDI]:
+        if not other_is_array and other_type in [DTI, pd.to_timedelta]:
             return
 
         # skip __radd__ cases where we got conflicts with the other types' __add__
@@ -341,7 +342,7 @@ def test_add_timedelta(
             np.timedelta64,
             np.datetime64,
             DTI,
-            TDI,
+            pd.to_timedelta,
         ):
             return
 
@@ -392,7 +393,7 @@ def test_add_timedelta(
             str,
             Time,
             Q_,
-            TDI,
+            pd.to_timedelta,
             Timedelta,
             np.timedelta64,
         ],
@@ -421,11 +422,16 @@ def test_add_datetime(
         # skip array cases where the type does not support arrays
         if other_type in [Timedelta, Timestamp] and other_is_array:
             return
-        if not other_is_array and other_type in [DTI, TDI]:
+        if not other_is_array and other_type in [DTI, pd.to_timedelta]:
             return
 
         # skip __radd__ cases where we got conflicts with the other types' __add__
-        if not other_on_rhs and other_type in (Q_, np.ndarray, np.timedelta64, TDI):
+        if not other_on_rhs and other_type in (
+            Q_,
+            np.ndarray,
+            np.timedelta64,
+            pd.to_timedelta,
+        ):
             return
 
         # setup rhs
@@ -477,7 +483,7 @@ def _date_diff(date_1: str, date_2: str, unit: str) -> int:
             (str, "timedelta"),
             (Time, "timedelta"),
             (Q_, "timedelta"),
-            TDI,
+            pd.to_timedelta,
             Timedelta,
             np.timedelta64,
             (str, "datetime"),
@@ -532,7 +538,7 @@ def test_sub(
         # skip array cases where the type does not support arrays or scalars
         if other_type in [Timedelta, Timestamp] and other_is_array:
             return
-        if not other_is_array and other_type in [DTI, TDI]:
+        if not other_is_array and other_type in [DTI, pd.to_timedelta]:
             return
 
         # skip __rsub__ cases where we got conflicts with the other types' __sub__
@@ -542,7 +548,7 @@ def test_sub(
             np.timedelta64,
             np.datetime64,
             DTI,
-            TDI,
+            pd.to_timedelta,
         ):
             return
 
@@ -612,13 +618,16 @@ def test_sub(
         "arg, expected",
         [
             # timedeltas
-            (TDI([42], unit="ns"), TDI([42], unit="ns")),
+            (pd.to_timedelta([42], unit="ns"), pd.to_timedelta([42], unit="ns")),
             (pd.timedelta_range("0s", "20s", 10), pd.timedelta_range("0s", "20s", 10)),
-            (np.timedelta64(42), TDI([42], unit="ns")),
-            (np.array([-10, 0, 20]).astype("timedelta64[ns]"), TDI([-10, 0, 20], "ns")),
-            (Q_(42, "ns"), TDI([42], unit="ns")),
-            ("10s", TDI(["10s"])),
-            (["5ms", "10s", "2D"], TDI(["5 ms", "10s", "2D"])),
+            (np.timedelta64(42), pd.to_timedelta([42], unit="ns")),
+            (
+                np.array([-10, 0, 20]).astype("timedelta64[ns]"),
+                pd.to_timedelta([-10, 0, 20], "ns"),
+            ),
+            (Q_(42, "ns"), pd.to_timedelta([42], unit="ns")),
+            ("10s", pd.to_timedelta(["10s"])),
+            (["5ms", "10s", "2D"], pd.to_timedelta(["5 ms", "10s", "2D"])),
             # datetimes
             (np.datetime64(50, "Y"), DTI(["2020-01-01"])),
             ("2020-01-01", DTI(["2020-01-01"])),
@@ -647,10 +656,10 @@ def test_pandas_index(arg, expected):
             ("1s", "ms", 1000),
             ("1s", "us", 1000000),
             ("1s", "ns", 1000000000),
-            (TDI([1, 2, 3], "s"), "s", [1, 2, 3]),
-            (TDI([1, 2, 3], "s"), "ms", np.array([1, 2, 3]) * 1e3),
-            (TDI([1, 2, 3], "s"), "us", np.array([1, 2, 3]) * 1e6),
-            (TDI([1, 2, 3], "s"), "ns", np.array([1, 2, 3]) * 1e9),
+            (pd.to_timedelta([1, 2, 3], "s"), "s", [1, 2, 3]),
+            (pd.to_timedelta([1, 2, 3], "s"), "ms", np.array([1, 2, 3]) * 1e3),
+            (pd.to_timedelta([1, 2, 3], "s"), "us", np.array([1, 2, 3]) * 1e6),
+            (pd.to_timedelta([1, 2, 3], "s"), "ns", np.array([1, 2, 3]) * 1e9),
             ("2020-01-01", "s", 0),
         ],
     )
@@ -775,7 +784,14 @@ def test_resample_exceptions(values, number_or_interval, raises):
                 ],
                 date_range("2020-02-01", periods=8, freq="1D"),
             ),
-            ([TDI([1, 5]), TDI([2, 6, 7]), TDI([1, 3, 7])], TDI([1, 2, 3, 5, 6, 7])),
+            (
+                [
+                    pd.to_timedelta([1, 5]),
+                    pd.to_timedelta([2, 6, 7]),
+                    pd.to_timedelta([1, 3, 7]),
+                ],
+                pd.to_timedelta([1, 2, 3, 5, 6, 7]),
+            ),
         ],
     )
     @pytest.mark.parametrize("test_instance", [True, False])
diff --git a/weldx/tests/test_utility.py b/weldx/tests/test_utility.py
index 6658fd3a9..1caa7847a 100644
--- a/weldx/tests/test_utility.py
+++ b/weldx/tests/test_utility.py
@@ -333,7 +333,7 @@ def test_xr_fill_all():
         "d1": np.array([-1, 1], dtype=float),
         "d2": np.array([-1, 1], dtype=int),
         "d3": pd.DatetimeIndex(["2020-05-01", "2020-05-03"]),
-        "d4": pd.TimedeltaIndex([0, 1, 2, 3], "s"),
+        "d4": pd.to_timedelta([0, 1, 2, 3], "s"),
         "d5": ["x", "y", "z"],
     },
 )
@@ -352,7 +352,7 @@ def test_xr_fill_all():
         "dtype": ["datetime64[ns]", "timedelta64[ns]"],
     },
     d4={
-        "values": pd.TimedeltaIndex([0, 1, 2, 3], "s"),
+        "values": pd.to_timedelta([0, 1, 2, 3], "s"),
         "dtype": ["datetime64[ns]", "timedelta64[ns]"],
     },
     d5={"values": ["x", "y", "z"], "dtype": "<U1"},
@@ -404,7 +404,7 @@ def test_xr_check_coords_exception(dax, ref_dict, exception_type):
 
 def test_xr_time_ref():
     """Test weldx accessor functions for time handling."""
-    dt = pd.TimedeltaIndex([0, 1, 2, 3], "s")
+    dt = pd.to_timedelta([0, 1, 2, 3], "s")
     da1 = xr.DataArray(
         data=np.ones(4),
         dims=["time"],
@@ -425,7 +425,7 @@ def test_xr_time_ref():
     assert np.all(da.time.data == (dt + t0))
 
     da = da.weldx.reset_reference_time(pd.Timestamp("2021-01-01 00:00:01"))
-    assert np.all(da.time.data == pd.TimedeltaIndex([-1, 0, 1, 2], "s"))
+    assert np.all(da.time.data == pd.to_timedelta([-1, 0, 1, 2], "s"))
 
     da2 = xr.DataArray(
         data=np.ones(4),
@@ -433,7 +433,7 @@ def test_xr_time_ref():
         coords={"time": t0 + dt},
     )
     da2 = da2.weldx.time_ref_restore()
-    assert np.all(da2.time.data == pd.TimedeltaIndex([0, 1, 2, 3], "s"))
+    assert np.all(da2.time.data == pd.to_timedelta([0, 1, 2, 3], "s"))
     assert da2.time.attrs["time_ref"] == t0
 
     da2.weldx.time_ref = t0
diff --git a/weldx/tests/transformations/test_cs_manager.py b/weldx/tests/transformations/test_cs_manager.py
index d3bd1a657..d69979cab 100644
--- a/weldx/tests/transformations/test_cs_manager.py
+++ b/weldx/tests/transformations/test_cs_manager.py
@@ -7,7 +7,6 @@
 import pandas as pd
 import pytest
 import xarray as xr
-from pandas import TimedeltaIndex as TDI
 from pandas import Timestamp as TS
 
 import weldx.transformations as tf
@@ -846,7 +845,7 @@ def test_time_union(
     lcs_time_ref = [None for _ in range(len(lcs_times))]
     for i, _ in enumerate(lcs_times):
         if lcs_times[i] is not None:
-            lcs_times[i] = pd.TimedeltaIndex(lcs_times[i], "D")
+            lcs_times[i] = pd.to_timedelta(lcs_times[i], "D")
         if lcs_ref_time_days[i] is not None:
             lcs_time_ref[i] = pd.Timestamp(f"2010-03-{lcs_ref_time_days[i]}")
 
@@ -872,7 +871,7 @@ def test_time_union(
         csm.add_cs(f"lcs_{i}", "root", lcs_)
 
     # create expected data type
-    exp_time = pd.TimedeltaIndex(exp_time, "D")
+    exp_time = pd.to_timedelta(exp_time, "D")
     if exp_ref_time_day is not None:
         exp_time = pd.Timestamp(f"2010-03-{exp_ref_time_day}") + exp_time
 
@@ -953,7 +952,7 @@ def test_time_union_time_series_coords(
         )
 
     if exp_time is not None:
-        exp_time = TDI(exp_time, unit="s")
+        exp_time = pd.to_timedelta(exp_time, unit="s")
     assert np.all(exp_time == csm.time_union(list_of_edges))
 
 
@@ -1042,7 +1041,7 @@ def test_get_local_coordinate_system_no_time_dep(
         ),
         # get cs in its parent system - function and CSM have reference times
         (
-            ("cs_1", None, pd.TimedeltaIndex([6, 9, 18], "D"), "2000-03-10"),
+            ("cs_1", None, pd.to_timedelta([6, 9, 18], "D"), "2000-03-10"),
             ["2000-03-16", None, None, None],
             [np.eye(3) for _ in range(3)],
             [[i, 0, 0] for i in [0, 0.25, 1]],
@@ -1106,7 +1105,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # get transformed cs at specific times - all systems and CSM have a
         # reference time
         (
-            ("cs_3", "root", pd.TimedeltaIndex([-4, 8, 20], "D")),
+            ("cs_3", "root", pd.to_timedelta([-4, 8, 20], "D")),
             ["2000-03-08", "2000-03-04", "2000-03-10", "2000-03-16"],
             r_mat_x([0, 1, 0]),
             [[i, 0, 0] for i in [1, 1.5, 1]],
@@ -1116,7 +1115,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # get transformed cs at specific times - some systems, CSM and function
         # have a reference time
         (
-            ("cs_3", "root", pd.TimedeltaIndex([-4, 8, 20], "D"), "2000-03-08"),
+            ("cs_3", "root", pd.to_timedelta([-4, 8, 20], "D"), "2000-03-08"),
             ["2000-03-10", "2000-03-04", None, "2000-03-16"],
             r_mat_x([0, 1, 0]),
             [[i, 0, 0] for i in [1, 1.5, 1]],
@@ -1126,7 +1125,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # get transformed cs at specific times - all systems, CSM and function
         # have a reference time
         (
-            ("cs_3", "root", pd.TimedeltaIndex([-4, 8, 20], "D"), "2000-03-08"),
+            ("cs_3", "root", pd.to_timedelta([-4, 8, 20], "D"), "2000-03-08"),
             ["2000-03-02", "2000-03-04", "2000-03-10", "2000-03-16"],
             r_mat_x([0, 1, 0]),
             [[i, 0, 0] for i in [1, 1.5, 1]],
@@ -1136,7 +1135,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # get transformed cs at specific times - all systems, and the function
         # have a reference time
         (
-            ("cs_3", "root", pd.TimedeltaIndex([-4, 8, 20], "D"), "2000-03-08"),
+            ("cs_3", "root", pd.to_timedelta([-4, 8, 20], "D"), "2000-03-08"),
             [None, "2000-03-04", "2000-03-10", "2000-03-16"],
             r_mat_x([0, 1, 0]),
             [[i, 0, 0] for i in [1, 1.5, 1]],
@@ -1146,7 +1145,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # get transformed cs at specific times - the function and the CSM have a
         # reference time
         (
-            ("cs_4", "root", pd.TimedeltaIndex([0, 6, 12, 18], "D"), "2000-03-08"),
+            ("cs_4", "root", pd.to_timedelta([0, 6, 12, 18], "D"), "2000-03-08"),
             ["2000-03-14", None, None, None],
             r_mat_x([0, 0, 1, 2]),
             [[0, 1, 0], [0, 1, 0], [0, -1, 0], [0, 1, 0]],
@@ -1164,7 +1163,7 @@ def test_get_local_coordinate_system_no_time_dep(
         ),
         # get transformed cs at specific times - no reference times
         (
-            ("cs_4", "root", pd.TimedeltaIndex([0, 3, 6, 9, 12], "D")),
+            ("cs_4", "root", pd.to_timedelta([0, 3, 6, 9, 12], "D")),
             [None, None, None, None],
             r_mat_x([0, 0.5, 1, 1.5, 2]),
             [[0, 1, 0], [0, 0, 1], [0, -1, 0], [0, 0, -1], [0, 1, 0]],
@@ -1294,7 +1293,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # passing just a time delta results in an undefined reference timestamp of
         # the resulting coordinate system
         (
-            ("cs_3", "root", pd.TimedeltaIndex([0, 8, 20], "D")),
+            ("cs_3", "root", pd.to_timedelta([0, 8, 20], "D")),
             [None, "2000-03-04", "2000-03-10", "2000-03-16"],
             None,
             None,
@@ -1305,7 +1304,7 @@ def test_get_local_coordinate_system_no_time_dep(
         # a reference time, passing one to the function results in undefined
         # behavior
         (
-            ("cs_3", "root", pd.TimedeltaIndex([0, 8, 20], "D"), "2000-03-16"),
+            ("cs_3", "root", pd.to_timedelta([0, 8, 20], "D"), "2000-03-16"),
             [None, None, None, None],
             None,
             None,
@@ -1378,19 +1377,19 @@ def test_get_local_coordinate_system_time_dep(
     time_refs = [t if t is None else pd.Timestamp(t) for t in time_refs]
 
     # moves in positive x-direction
-    time_1 = TDI([0, 3, 12], "D")
+    time_1 = pd.to_timedelta([0, 3, 12], "D")
     time_ref_1 = time_refs[1]
     orientation_1 = None
     coordinates_1 = Q_([[i, 0, 0] for i in [0, 0.25, 1]], "mm")
 
     # moves in negative x-direction and rotates positively around the x-axis
-    time_2 = TDI([0, 4, 8, 12], "D")
+    time_2 = pd.to_timedelta([0, 4, 8, 12], "D")
     time_ref_2 = time_refs[2]
     coordinates_2 = Q_([[-i, 0, 0] for i in [0, 1 / 3, 2 / 3, 1]], "mm")
     orientation_2 = r_mat_x([0, 2 / 3, 4 / 3, 2])
 
     # rotates negatively around the x-axis
-    time_3 = TDI([0, 3, 6, 9, 12], "D")
+    time_3 = pd.to_timedelta([0, 3, 6, 9, 12], "D")
     time_ref_3 = time_refs[3]
     coordinates_3 = Q_([1, 0, 0], "mm")
     orientation_3 = r_mat_x([0, -0.5, -1, -1.5, -2])
@@ -1411,7 +1410,7 @@ def test_get_local_coordinate_system_time_dep(
         # create expected time data
         exp_time = exp_time_data[0]
         if exp_time is not None:
-            exp_time = pd.TimedeltaIndex(exp_time, "D")
+            exp_time = pd.to_timedelta(exp_time, "D")
         exp_time_ref = exp_time_data[1]
         if exp_time_ref is not None:
             exp_time_ref = pd.Timestamp(exp_time_ref)
@@ -1523,8 +1522,8 @@ def test_get_local_coordinate_system_exceptions(
 
     """
     # setup
-    time_1 = TDI([0, 3], "D")
-    time_2 = TDI([4, 7], "D")
+    time_1 = pd.to_timedelta([0, 3], "D")
+    time_2 = pd.to_timedelta([4, 7], "D")
 
     csm = tf.CoordinateSystemManager(root_coordinate_system_name="root")
     csm.create_cs("cs_1", "root", r_mat_z(0.5), Q_([1, 2, 3], "mm"))
@@ -1691,7 +1690,7 @@ def test_merge_reference_times(
     # setup
     lcs_static = tf.LocalCoordinateSystem(coordinates=Q_([1, 1, 1], "mm"))
     lcs_dynamic = tf.LocalCoordinateSystem(
-        coordinates=Q_([[0, 4, 2], [7, 2, 4]], "mm"), time=TDI([4, 8], "D")
+        coordinates=Q_([[0, 4, 2], [7, 2, 4]], "mm"), time=pd.to_timedelta([4, 8], "D")
     )
     time_ref_parent = None
     if time_ref_day_parent is not None:
@@ -2532,18 +2531,18 @@ def _coordinates_from_value(val, clip_min=None, clip_max=None):
 @pytest.mark.parametrize(
     "time, time_ref, systems, csm_has_time_ref, num_abs_systems",
     [
-        (TDI([1, 7, 11, 20], "D"), None, None, False, 0),
-        (TDI([3], "D"), None, None, False, 0),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), None, None, False, 0),
+        (pd.to_timedelta([3], "D"), None, None, False, 0),
         (pd.Timedelta(3, "D"), None, None, False, 0),
         (Q_([1, 7, 11, 20], "days"), None, None, False, 0),
         (["5days", "8days"], None, None, False, 0),
-        (TDI([1, 7, 11, 20], "D"), None, ["lcs_1"], False, 0),
-        (TDI([1, 7, 11, 20], "D"), None, ["lcs_1", "lcs_2"], False, 0),
-        (TDI([1, 7, 11, 20], "D"), "2000-01-10", None, True, 0),
-        (TDI([1, 7, 11, 20], "D"), "2000-01-13", None, True, 0),
-        (TDI([1, 7, 11, 20], "D"), "2000-01-13", None, False, 3),
-        (TDI([1, 7, 11, 20], "D"), "2000-01-13", None, True, 3),
-        (TDI([1, 7, 11, 20], "D"), "2000-01-13", None, True, 2),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), None, ["lcs_1"], False, 0),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), None, ["lcs_1", "lcs_2"], False, 0),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), "2000-01-10", None, True, 0),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), "2000-01-13", None, True, 0),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), "2000-01-13", None, False, 3),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), "2000-01-13", None, True, 3),
+        (pd.to_timedelta([1, 7, 11, 20], "D"), "2000-01-13", None, True, 2),
         (["2000-01-13", "2000-01-17"], None, None, True, 2),
     ],
 )
@@ -2745,7 +2744,7 @@ def test_coordinate_system_manager_create_coordinate_system():
     rot_mat_x = WXRotation.from_euler("x", angles_x).as_matrix()
     rot_mat_y = WXRotation.from_euler("y", angles_y).as_matrix()
 
-    time = TDI([0, 6, 12, 18], "H")
+    time = pd.to_timedelta([0, 6, 12, 18], "h")
     orientations = np.matmul(rot_mat_x, rot_mat_y)
     coords = Q_([[1, 0, 0], [-1, 0, 2], [3, 5, 7], [-4, -5, -6]], "mm")
 
diff --git a/weldx/tests/transformations/test_local_cs.py b/weldx/tests/transformations/test_local_cs.py
index 8445db843..7de20db85 100644
--- a/weldx/tests/transformations/test_local_cs.py
+++ b/weldx/tests/transformations/test_local_cs.py
@@ -9,7 +9,6 @@
 import pint
 import pytest
 import xarray as xr
-from pandas import TimedeltaIndex as TDI
 from pandas import Timestamp as TS
 from pandas import date_range
 from pint import DimensionalityError
@@ -57,7 +56,7 @@ def test_init(orient, coords, time, time_ref, exception, data_array_coords):
 # test_init_time_formats ---------------------------------------------------------------
 
 timestamp = TS("2000-01-01")
-time_delta = TDI([0, 1, 2], "s")
+time_delta = pd.to_timedelta([0, 1, 2], "s")
 time_quantity = Q_([0, 1, 2], "s")
 date_time = date_range("2000-01-01", periods=3, freq="s")
 
@@ -73,7 +72,7 @@ def test_init(orient, coords, time, time_ref, exception, data_array_coords):
         (
             date_time,
             TS("1999-12-31"),
-            TDI([86400, 86401, 86402], "s"),
+            pd.to_timedelta([86400, 86401, 86402], "s"),
             TS("1999-12-31"),
         ),
     ],
@@ -110,8 +109,13 @@ def test_init_time_formats(time, time_ref, time_exp, time_ref_exp):
 @pytest.mark.parametrize(
     "coordinates, orientation, time, warning",
     [
-        (Q_(np.zeros(3), "mm"), np.eye(3, 3), TDI([0, 2], "s"), UserWarning),
-        (Q_(np.zeros((2, 3)), "mm"), np.eye(3, 3), TDI([0, 2], "s"), None),
+        (
+            Q_(np.zeros(3), "mm"),
+            np.eye(3, 3),
+            pd.to_timedelta([0, 2], "s"),
+            UserWarning,
+        ),
+        (Q_(np.zeros((2, 3)), "mm"), np.eye(3, 3), pd.to_timedelta([0, 2], "s"), None),
         (Q_(np.zeros(3), "mm"), np.eye(3, 3), None, None),
     ],
 )
@@ -149,11 +153,15 @@ def _call():
 @pytest.mark.parametrize(
     "time_o,  time_c,  time_exp",
     [
-        (TDI([0, 1, 2], "s"), TDI([0, 1, 2], "s"), TDI([0, 1, 2], "s")),
         (
-            TDI([0, 2, 4], "s"),
-            TDI([1, 3, 5], "s"),
-            TDI([0, 1, 2, 3, 4, 5], "s"),
+            pd.to_timedelta([0, 1, 2], "s"),
+            pd.to_timedelta([0, 1, 2], "s"),
+            pd.to_timedelta([0, 1, 2], "s"),
+        ),
+        (
+            pd.to_timedelta([0, 2, 4], "s"),
+            pd.to_timedelta([1, 3, 5], "s"),
+            pd.to_timedelta([0, 1, 2, 3, 4, 5], "s"),
         ),
     ],
 )
@@ -326,22 +334,22 @@ def test_from_axis_vectors_exceptions(kwargs, exception_type, test_name):
     "time, time_ref, time_ref_new, time_exp",
     [
         (
-            TDI([1, 2, 3], "D"),
+            pd.to_timedelta([1, 2, 3], "D"),
             TS("2020-02-02"),
             TS("2020-02-01"),
-            TDI([2, 3, 4], "D"),
+            pd.to_timedelta([2, 3, 4], "D"),
         ),
         (
-            TDI([1, 2, 3], "D"),
+            pd.to_timedelta([1, 2, 3], "D"),
             TS("2020-02-02"),
             "2020-02-01",
-            TDI([2, 3, 4], "D"),
+            pd.to_timedelta([2, 3, 4], "D"),
         ),
         (
-            TDI([1, 2, 3], "D"),
+            pd.to_timedelta([1, 2, 3], "D"),
             None,
             "2020-02-01",
-            TDI([1, 2, 3], "D"),
+            pd.to_timedelta([1, 2, 3], "D"),
         ),
     ],
 )
@@ -401,7 +409,7 @@ def test_reset_reference_time_exceptions(
     """
     orientation = WXRotation.from_euler("z", [1, 2, 3]).as_matrix()
     coordinates = Q_([[i, i, i] for i in range(3)], "mm")
-    time = TDI([1, 2, 3], "D")
+    time = pd.to_timedelta([1, 2, 3], "D")
 
     lcs = tf.LocalCoordinateSystem(orientation, coordinates, time, time_ref=time_ref)
 
@@ -417,42 +425,42 @@ def test_reset_reference_time_exceptions(
     [
         (  # broadcast left
             TS("2020-02-10"),
-            TDI([1, 2, 14], "D"),
+            pd.to_timedelta([1, 2, 14], "D"),
             TS("2020-02-10"),
             r_mat_z([0, 0, 0.5]),
             np.array([[2, 8, 7], [2, 8, 7], [4, 9, 2]]),
         ),
         (  # broadcast right
             TS("2020-02-10"),
-            TDI([14, 29, 30], "D"),
+            pd.to_timedelta([14, 29, 30], "D"),
             TS("2020-02-10"),
             r_mat_z([0.5, 0.5, 0.5]),
             np.array([[4, 9, 2], [3, 1, 2], [3, 1, 2]]),
         ),
         (  # pure interpolation
             TS("2020-02-10"),
-            TDI([11, 14, 17, 20], "D"),
+            pd.to_timedelta([11, 14, 17, 20], "D"),
             TS("2020-02-10"),
             r_mat_z([0.125, 0.5, 0.875, 0.75]),
             np.array([[2.5, 8.25, 5.75], [4, 9, 2], [1, 3.75, 1.25], [1.5, 1.5, 1.5]]),
         ),
         (  # mixed
             TS("2020-02-10"),
-            TDI([6, 12, 18, 24, 32], "D"),
+            pd.to_timedelta([6, 12, 18, 24, 32], "D"),
             TS("2020-02-10"),
             r_mat_z([0, 0.25, 1, 0.5, 0.5]),
             np.array([[2, 8, 7], [3, 8.5, 4.5], [0, 2, 1], [3, 1, 2], [3, 1, 2]]),
         ),
         (  # different reference times
             TS("2020-02-10"),
-            TDI([8, 14, 20, 26, 34], "D"),
+            pd.to_timedelta([8, 14, 20, 26, 34], "D"),
             TS("2020-02-08"),
             r_mat_z([0, 0.25, 1, 0.5, 0.5]),
             np.array([[2, 8, 7], [3, 8.5, 4.5], [0, 2, 1], [3, 1, 2], [3, 1, 2]]),
         ),
         (  # no reference time
             None,
-            TDI([6, 12, 18, 24, 32], "D"),
+            pd.to_timedelta([6, 12, 18, 24, 32], "D"),
             None,
             r_mat_z([0, 0.25, 1, 0.5, 0.5]),
             np.array([[2, 8, 7], [3, 8.5, 4.5], [0, 2, 1], [3, 1, 2], [3, 1, 2]]),
@@ -483,7 +491,7 @@ def test_interp_time_discrete(
     lcs = tf.LocalCoordinateSystem(
         orientation=r_mat_z([0, 0.5, 1, 0.5]),
         coordinates=Q_([[2, 8, 7], [4, 9, 2], [0, 2, 1], [3, 1, 2]], "mm"),
-        time=TDI([10, 14, 18, 22], "D"),
+        time=pd.to_timedelta([10, 14, 18, 22], "D"),
         time_ref=time_ref_lcs,
     )
 
@@ -708,10 +716,22 @@ def test_interp_time_timeseries_as_coords(
 @pytest.mark.parametrize(
     "time_ref_lcs, time, time_ref,  exception_type, test_name",
     [
-        (TS("2020-02-02"), TDI([1]), None, TypeError, "# mixed ref. times #1"),
-        (None, TDI([1]), TS("2020-02-02"), TypeError, "# mixed ref. times #2"),
+        (
+            TS("2020-02-02"),
+            pd.to_timedelta([1]),
+            None,
+            TypeError,
+            "# mixed ref. times #1",
+        ),
+        (
+            None,
+            pd.to_timedelta([1]),
+            TS("2020-02-02"),
+            TypeError,
+            "# mixed ref. times #2",
+        ),
         (TS("2020-02-02"), "no", TS("2020-02-02"), TypeError, "# wrong type #1"),
-        (TS("2020-02-02"), TDI([1]), "no", Exception, "# wrong type #2"),
+        (TS("2020-02-02"), pd.to_timedelta([1]), "no", Exception, "# wrong type #2"),
     ],
     ids=get_test_name,
 )
@@ -736,7 +756,7 @@ def test_interp_time_exceptions(
     """
     orientation = r_mat_z([1, 2, 3])
     coordinates = Q_([[i, i, i] for i in range(3)], "mm")
-    time_lcs = TDI([1, 2, 3], "D")
+    time_lcs = pd.to_timedelta([1, 2, 3], "D")
 
     lcs = tf.LocalCoordinateSystem(
         orientation, coordinates, time_lcs, time_ref=time_ref_lcs
@@ -764,26 +784,26 @@ def test_interp_time_exceptions(
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([1, 4, 2], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(r_mat_z(0.5), Q_([3, 7, 1], "mm")),
             r_mat_z([0.5, 1, 1.5]),
             [[-1, 8, 3], [-1, 8, 3], [-1, 8, 3]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 3 - left system coordinates time dependent
             LCS(
                 r_mat_y(0.5),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(r_mat_z(0.5), Q_([3, 7, 1], "mm")),
             [[[0, -1, 0], [0, 0, 1], [-1, 0, 0]] for _ in range(3)],
             [[-4, 10, 2], [5, 11, 9], [0, 2, 0]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 4 - right system orientation time dependent
@@ -791,12 +811,12 @@ def test_interp_time_exceptions(
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([1, 4, 2], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 1, 1.5]),
             [[4, 11, 3], [-6, 7, 3], [-2, -3, 3]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 5 - right system coordinates time dependent
@@ -804,12 +824,12 @@ def test_interp_time_exceptions(
             LCS(
                 r_mat_z(0.5),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z(1),
             [[-4, 10, 2], [-3, 1, 9], [-12, 6, 0]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 6 - right system fully time dependent
@@ -817,84 +837,84 @@ def test_interp_time_exceptions(
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 1, 1.5]),
             [[6, 14, 2], [-3, 1, 9], [-8, -4, 0]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 7 - both fully time dependent - same time and reference time
             LCS(
                 r_mat_z([1, 0, 0]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([1, 0.5, 1]),
             [[7, 9, 6], [7, 1, 10], [-6, -4, -10]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 8 - both fully time dependent - different time but same reference time
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([2, 4, 6], "D"),
+                pd.to_timedelta([2, 4, 6], "D"),
                 TS("2020-02-02"),
             ),
             LCS(
                 r_mat_z([0.75, 1.25, 0.75]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 0.0, 1.5]),
             [[-0.5, 0.5, 9.5], [-3.5, 3.5, 5.5], [-10.6568542, -1.242640687, -10]],
-            TDI([2, 4, 6], "D"),
+            pd.to_timedelta([2, 4, 6], "D"),
             TS("2020-02-02"),
         ),
         (  # 9 - both fully time dependent - different time and reference time #1
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-03"),
             ),
             LCS(
                 r_mat_z([0.75, 1.25, 0.75]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 0.0, 1.5]),
             [[-0.5, 0.5, 9.5], [-3.5, 3.5, 5.5], [-10.6568542, -1.242640687, -10]],
-            TDI([2, 4, 6], "D"),
+            pd.to_timedelta([2, 4, 6], "D"),
             TS("2020-02-02"),
         ),
         (  # 10 - both fully time dependent - different time and reference time #2
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([3, 5, 7], "D"),
+                pd.to_timedelta([3, 5, 7], "D"),
                 TS("2020-02-01"),
             ),
             LCS(
                 r_mat_z([0.75, 1.25, 0.75]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 0.0, 1.5]),
             [[-0.5, 0.5, 9.5], [-3.5, 3.5, 5.5], [-10.6568542, -1.242640687, -10]],
-            TDI([3, 5, 7], "D"),
+            pd.to_timedelta([3, 5, 7], "D"),
             TS("2020-02-01"),
         ),
     ],
@@ -949,26 +969,26 @@ def test_addition(
             LCS(
                 r_mat_z([0.5, 1, 1.5]),
                 Q_([-1, 8, 3], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(r_mat_z(0.5), Q_([3, 7, 1], "mm")),
             r_mat_z([0, 0.5, 1]),
             [[1, 4, 2], [1, 4, 2], [1, 4, 2]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 3 - left system coordinates time dependent
             LCS(
                 [[0, -1, 0], [0, 0, 1], [-1, 0, 0]],
                 Q_([[-4, 10, 2], [5, 11, 9], [0, 2, 0]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(r_mat_z(0.5), Q_([3, 7, 1], "mm")),
             r_mat_y([0.5, 0.5, 0.5]),
             [[3, 7, 1], [4, -2, 8], [-5, 3, -1]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 4 - right system orientation time dependent
@@ -976,12 +996,12 @@ def test_addition(
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([1, 4, 2], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 0, 1.5]),
             [[2, 3, -1], [3, -2, -1], [-2, -3, -1]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 5 - right system coordinates time dependent
@@ -989,12 +1009,12 @@ def test_addition(
             LCS(
                 r_mat_z(0.5),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z(0),
             [[0, 0, 0], [9, 1, -7], [4, -8, 2]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 6 - right system fully time dependent
@@ -1002,84 +1022,84 @@ def test_addition(
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.5, 0, 1.5]),
             [[0, 0, 0], [9, 1, -7], [-8, -4, 2]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 7 - both fully time dependent - same time and reference time
             LCS(
                 r_mat_z([1, 0.5, 1]),
                 Q_([[7, 9, 6], [7, 1, 10], [-6, -4, -10]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             LCS(
                 r_mat_z([0, 0.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([1, 0, 0]),
             [[4, 2, 5], [3, -3, 2], [1, 7, -9]],
-            TDI([1, 3, 5], "D"),
+            pd.to_timedelta([1, 3, 5], "D"),
             TS("2020-02-02"),
         ),
         (  # 8 - both fully time dependent - different time but same reference time
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([2, 4, 6], "D"),
+                pd.to_timedelta([2, 4, 6], "D"),
                 TS("2020-02-02"),
             ),
             LCS(
                 r_mat_z([1, 1.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.25, 1.75, 1.75]),
             [[-3.7426406, 2.9142135, 0.5], [-3.5, 3.742640, -1.5], [-6, -4, -8.0]],
-            TDI([2, 4, 6], "D"),
+            pd.to_timedelta([2, 4, 6], "D"),
             TS("2020-02-02"),
         ),
         (  # 9 - both fully time dependent - different time and reference time #1
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-03"),
             ),
             LCS(
                 r_mat_z([1, 1.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.25, 1.75, 1.75]),
             [[-3.7426406, 2.9142135, 0.5], [-3.5, 3.742640, -1.5], [-6, -4, -8.0]],
-            TDI([2, 4, 6], "D"),
+            pd.to_timedelta([2, 4, 6], "D"),
             TS("2020-02-02"),
         ),
         (  # 10 - both fully time dependent - different time and reference time #2
             LCS(
                 r_mat_z([1.5, 1.0, 0.75]),
                 Q_([[4, 2, 5], [3, -3, 2], [1, 7, -9]], "mm"),
-                TDI([3, 5, 7], "D"),
+                pd.to_timedelta([3, 5, 7], "D"),
                 TS("2020-02-01"),
             ),
             LCS(
                 r_mat_z([1, 1.5, 1]),
                 Q_([[3, 7, 1], [4, -2, 8], [-5, 3, -1]], "mm"),
-                TDI([1, 3, 5], "D"),
+                pd.to_timedelta([1, 3, 5], "D"),
                 TS("2020-02-02"),
             ),
             r_mat_z([0.25, 1.75, 1.75]),
             [[-3.7426406, 2.9142135, 0.5], [-3.5, 3.742640, -1.5], [-6, -4, -8.0]],
-            TDI([3, 5, 7], "D"),
+            pd.to_timedelta([3, 5, 7], "D"),
             TS("2020-02-01"),
         ),
     ],
@@ -1184,8 +1204,8 @@ def test_comparison_coords_timeseries(
 def test_coordinate_system_init():
     """Check the __init__ method with and without time dependency."""
     # reference data
-    time_0 = TDI([1, 3, 5], "s")
-    time_1 = TDI([2, 4, 6], "s")
+    time_0 = pd.to_timedelta([1, 3, 5], "s")
+    time_1 = pd.to_timedelta([2, 4, 6], "s")
 
     orientation_fix = r_mat_z(1)
     orientation_tdp = r_mat_z([0, 0.25, 0.5])
@@ -1261,7 +1281,7 @@ def test_coordinate_system_init():
         orientation=xr_orientation_tdp_0, coordinates=xr_coordinates_tdp_1
     )
 
-    time_exp = TDI([1, 2, 3, 4, 5, 6], "s")
+    time_exp = pd.to_timedelta([1, 2, 3, 4, 5, 6], "s")
     coordinates_exp = Q_(
         [
             [3, 7, 1],
@@ -1366,7 +1386,7 @@ def test_coordinate_system_factories_time_dependent():
     rot_mat_x = WXRotation.from_euler("x", angles_x).as_matrix()
     rot_mat_y = WXRotation.from_euler("y", angles_y).as_matrix()
 
-    time = TDI([0, 6, 12, 18], "H")
+    time = pd.to_timedelta([0, 6, 12, 18], "h")
     orientations = np.matmul(rot_mat_x, rot_mat_y)
     coords = Q_([[1, 0, 0], [-1, 0, 2], [3, 5, 7], [-4, -5, -6]], "mm")
 
@@ -1408,7 +1428,7 @@ def test_coordinate_system_invert():
     )
 
     # time dependent ----------------------------
-    time = TDI([1, 2, 3, 4], "s")
+    time = pd.to_timedelta([1, 2, 3, 4], "s")
     orientation = r_mat_z([0, 0.5, 1, 0.5])
     coordinates = Q_([[2, 8, 7], [4, 9, 2], [0, 2, 1], [3, 1, 2]], "mm")
 
@@ -1467,7 +1487,7 @@ def coordinate_system_time_interpolation_test_case(
 
 def test_coordinate_system_time_interpolation():
     """Test the local coordinate systems interp_time and interp_like functions."""
-    time_0 = TDI([10, 14, 18, 22], "D")
+    time_0 = pd.to_timedelta([10, 14, 18, 22], "D")
     orientation = r_mat_z([0, 0.5, 1, 0.5])
     coordinates = Q_([[2, 8, 7], [4, 9, 2], [0, 2, 1], [3, 1, 2]], "mm")
 
diff --git a/weldx/time.py b/weldx/time.py
index 5095f9d91..8aded0950 100644
--- a/weldx/time.py
+++ b/weldx/time.py
@@ -629,7 +629,7 @@ def resample(self, number_or_interval: int | types_timedelta_like):
         TimedeltaIndex([       '0 days 00:00:03', '0 days 00:00:04.500000',
                                '0 days 00:00:06', '0 days 00:00:07.500000',
                                '0 days 00:00:09'],
-                       dtype='timedelta64[ns]', freq='1500L')
+                       dtype='timedelta64[ns]', freq='1500ms')
 
         """
         if len(self) <= 1:
@@ -670,7 +670,7 @@ def _convert_quantity(
             # necessary interfaces so that the function works as expected
             time = np.expand_dims(time, 0)  # type: ignore[assignment]
 
-        delta = pd.TimedeltaIndex(data=time.to(base).magnitude, unit=base)
+        delta = pd.to_timedelta(time.to(base).magnitude, base)
         if time_ref is not None:
             delta = delta + time_ref
         return delta