Repository: scikit-hep/vector

Issue:
Remove underscores from module names
Just before Vector went public, we (@henryiii and I) chose to add underscores on the module names that are not expected to be used by data analysts.

Prepended underscores in `_backends` and `_compute` were for hiding internals; appended underscores in `object_`, `numpy_`, and `awkward_` were for avoiding Python built-in and module name ambiguity, but these aren't really needed because

   * `vector.object_` would never be confused with `object` if we don't `import object from vector` (why would anyone do that?)
   * this is a purely Python 3 project; my apprehension about nested submodules with the same name as top-level modules is obsolete.

Back to the prepended underscores: `_backends` has a lot of useful classes for third party developers. For instance, I foresee @nsmith- needing to access quite a bit in `vector._backends.awkward_` in order to move NanoEvents to use Vector.

I propose

   1. to remove the appended underscores because they're not needed and ugly and
   2. to remove the prepended underscore from `_backends`. I still don't see any reason why even a third-party developer would need to see inside `_compute`.

So @henryiii, what do you think?

Discussion:
Saransh-cpp: Is there a file where I should add a warning for this? The issue mentions that the `_backends` package is being used outside of vector; would this be a breaking change?

Patch:
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 4236f83..95a63e6 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -72,7 +72,7 @@ repos:
   hooks:
   - id: python-check-blanket-noqa
   - id: python-check-blanket-type-ignore
-    exclude: ^src/vector/_backends/numba_object.py$
+    exclude: ^src/vector/backends/_numba_object.py$
   - id: python-no-log-warn
   - id: python-no-eval
   - id: python-use-type-annotations
diff --git a/docs/api/vector._backends.rst b/docs/api/vector._backends.rst
deleted file mode 100644
index 56e1c03..0000000
--- a/docs/api/vector._backends.rst
+++ /dev/null
@@ -1,68 +0,0 @@
-vector.\_backends package
-=========================
-
-Submodules
-----------
-
-vector.\_backends.awkward\_ module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.awkward_
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-vector.\_backends.numba\_ module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.numba_
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-vector.\_backends.numba\_numpy module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.numba_numpy
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-vector.\_backends.numba\_object module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.numba_object
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-vector.\_backends.numpy\_ module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.numpy_
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-vector.\_backends.object\_ module
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. automodule:: vector._backends.object_
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
-
-Module contents
----------------
-
-.. automodule:: vector._backends
-   :members:
-   :undoc-members:
-   :show-inheritance:
-   :private-members:
diff --git a/docs/api/vector.backends.rst b/docs/api/vector.backends.rst
new file mode 100644
index 0000000..24fa4a7
--- /dev/null
+++ b/docs/api/vector.backends.rst
@@ -0,0 +1,68 @@
+vector.backends package
+=========================
+
+Submodules
+----------
+
+vector.backends.awkward module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends.awkward
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+vector.backends.\_numba module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends._numba
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+vector.backends.numba\_numpy module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends.numba_numpy
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+vector.backends.\_numba\_object module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends._numba_object
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+vector.backends.numpy module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends.numpy
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+vector.backends.object module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. automodule:: vector.backends.object
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
+
+Module contents
+---------------
+
+.. automodule:: vector.backends
+   :members:
+   :undoc-members:
+   :show-inheritance:
+   :private-members:
diff --git a/docs/api/vector.rst b/docs/api/vector.rst
index 8756d9a..53ce5f0 100644
--- a/docs/api/vector.rst
+++ b/docs/api/vector.rst
@@ -7,7 +7,7 @@ Subpackages
 .. toctree::
    :maxdepth: 5
 
-   vector._backends
+   vector.backends
    vector._compute
 
 Submodules
diff --git a/src/vector/__init__.py b/src/vector/__init__.py
index e15af7e..90429be 100644
--- a/src/vector/__init__.py
+++ b/src/vector/__init__.py
@@ -8,30 +8,6 @@ import typing
 
 import packaging.version
 
-from vector._backends.awkward_constructors import Array as Array
-from vector._backends.awkward_constructors import Array as arr
-from vector._backends.awkward_constructors import Array as awk
-from vector._backends.awkward_constructors import zip
-from vector._backends.numpy_ import (
-    MomentumNumpy2D,
-    MomentumNumpy3D,
-    MomentumNumpy4D,
-    VectorNumpy,
-    VectorNumpy2D,
-    VectorNumpy3D,
-    VectorNumpy4D,
-    array,
-)
-from vector._backends.object_ import (
-    MomentumObject2D,
-    MomentumObject3D,
-    MomentumObject4D,
-    VectorObject,
-    VectorObject2D,
-    VectorObject3D,
-    VectorObject4D,
-    obj,
-)
 from vector._methods import (
     Azimuthal,
     AzimuthalRhoPhi,
@@ -54,6 +30,30 @@ from vector._methods import (
     Vector4D,
     dim,
 )
+from vector.backends.awkward_constructors import Array as Array
+from vector.backends.awkward_constructors import Array as arr
+from vector.backends.awkward_constructors import Array as awk
+from vector.backends.awkward_constructors import zip
+from vector.backends.numpy import (
+    MomentumNumpy2D,
+    MomentumNumpy3D,
+    MomentumNumpy4D,
+    VectorNumpy,
+    VectorNumpy2D,
+    VectorNumpy3D,
+    VectorNumpy4D,
+    array,
+)
+from vector.backends.object import (
+    MomentumObject2D,
+    MomentumObject3D,
+    MomentumObject4D,
+    VectorObject,
+    VectorObject2D,
+    VectorObject3D,
+    VectorObject4D,
+    obj,
+)
 from vector.version import version as __version__
 
 if sys.version_info < (3, 8):
@@ -80,7 +80,7 @@ except ImportError:
     if not typing.TYPE_CHECKING:
         VectorAwkward = None
 else:
-    from vector._backends.awkward_ import VectorAwkward
+    from vector.backends.awkward import VectorAwkward
 
 
 __all__: typing.Tuple[str, ...] = (
@@ -147,8 +147,8 @@ def register_numba() -> None:
     This usually isn't necessary, as it is passed to Numba's ``entry_point`` and
     is therefore executed as soon as Numba is imported.
     """
-    import vector._backends.numba_numpy  # noqa: 401
-    import vector._backends.numba_object  # noqa: 401
+    import vector.backends._numba_object  # noqa: 401
+    import vector.backends.numba_numpy  # noqa: 401
 
 
 _awkward_registered = False
@@ -168,8 +168,8 @@ def register_awkward() -> None:
     """
     import awkward
 
-    import vector._backends.awkward_  # noqa: 401
+    import vector.backends.awkward  # noqa: 401
 
     global _awkward_registered
-    awkward.behavior.update(vector._backends.awkward_.behavior)
+    awkward.behavior.update(vector.backends.awkward.behavior)
     _awkward_registered = True
diff --git a/src/vector/_methods.py b/src/vector/_methods.py
index 65cd07a..5acb9fa 100644
--- a/src/vector/_methods.py
+++ b/src/vector/_methods.py
@@ -2769,9 +2769,9 @@ def _from_signature(
 
 
 _handler_priority = [
-    "vector._backends.object_",
-    "vector._backends.numpy_",
-    "vector._backends.awkward_",
+    "vector.backends.object",
+    "vector.backends.numpy",
+    "vector.backends.awkward",
 ]
 
 
@@ -2812,8 +2812,8 @@ def _flavor_of(*objects: VectorProtocol) -> typing.Type[VectorProtocol]:
     Determines the flavor of the output of a dispatched function, where
     "flavor" is generic vs momentum.
     """
-    from vector._backends.numpy_ import VectorNumpy
-    from vector._backends.object_ import VectorObject
+    from vector.backends.numpy import VectorNumpy
+    from vector.backends.object import VectorObject
 
     handler = None
     is_momentum = True
diff --git a/src/vector/_backends/__init__.py b/src/vector/backends/__init__.py
similarity index 100%
rename from src/vector/_backends/__init__.py
rename to src/vector/backends/__init__.py
diff --git a/src/vector/_backends/numba_.py b/src/vector/backends/_numba.py
similarity index 96%
rename from src/vector/_backends/numba_.py
rename to src/vector/backends/_numba.py
index 93644db..033a225 100644
--- a/src/vector/_backends/numba_.py
+++ b/src/vector/backends/_numba.py
@@ -29,7 +29,7 @@ for groupname, module in names_and_modules:
             "vector._compute."
         ):
             new_name = submodule.__name__.replace(
-                "vector._compute.", "vector._compute.numba."
+                "vector._compute.", "vector._compute._numba."
             )
             numba_modules[groupname][modname] = {}
 
diff --git a/src/vector/_backends/numba_object.py b/src/vector/backends/_numba_object.py
similarity index 99%
rename from src/vector/_backends/numba_object.py
rename to src/vector/backends/_numba_object.py
index 3eb3f75..1c307b6 100644
--- a/src/vector/_backends/numba_object.py
+++ b/src/vector/backends/_numba_object.py
@@ -15,8 +15,19 @@ import numba
 import numpy
 
 import vector
-from vector._backends.numba_ import numba_modules
-from vector._backends.object_ import (
+from vector._methods import (
+    AzimuthalRhoPhi,
+    AzimuthalXY,
+    LongitudinalEta,
+    LongitudinalTheta,
+    LongitudinalZ,
+    Momentum,
+    TemporalT,
+    TemporalTau,
+    _from_signature,
+)
+from vector.backends._numba import numba_modules
+from vector.backends.object import (
     AzimuthalObject,
     AzimuthalObjectRhoPhi,
     AzimuthalObjectXY,
@@ -35,17 +46,6 @@ from vector._backends.object_ import (
     VectorObject4D,
     _coord_object_type,
 )
-from vector._methods import (
-    AzimuthalRhoPhi,
-    AzimuthalXY,
-    LongitudinalEta,
-    LongitudinalTheta,
-    LongitudinalZ,
-    Momentum,
-    TemporalT,
-    TemporalTau,
-    _from_signature,
-)
 
 
 @numba.extending.overload(numpy.nan_to_num)  # FIXME: This needs to go into Numba!
diff --git a/src/vector/_backends/awkward_.py b/src/vector/backends/awkward.py
similarity index 96%
rename from src/vector/_backends/awkward_.py
rename to src/vector/backends/awkward.py
index 1d2ca97..85735a8 100644
--- a/src/vector/_backends/awkward_.py
+++ b/src/vector/backends/awkward.py
@@ -36,19 +36,6 @@ import awkward as ak
 import numpy
 
 import vector
-from vector._backends.numpy_ import VectorNumpy2D, VectorNumpy3D, VectorNumpy4D
-from vector._backends.object_ import (
-    AzimuthalObjectRhoPhi,
-    AzimuthalObjectXY,
-    LongitudinalObjectEta,
-    LongitudinalObjectTheta,
-    LongitudinalObjectZ,
-    TemporalObjectT,
-    TemporalObjectTau,
-    VectorObject2D,
-    VectorObject3D,
-    VectorObject4D,
-)
 from vector._methods import (
     Azimuthal,
     AzimuthalRhoPhi,
@@ -73,6 +60,19 @@ from vector._methods import (
     VectorProtocol,
 )
 from vector._typeutils import BoolCollection, ScalarCollection
+from vector.backends.numpy import VectorNumpy2D, VectorNumpy3D, VectorNumpy4D
+from vector.backends.object import (
+    AzimuthalObjectRhoPhi,
+    AzimuthalObjectXY,
+    LongitudinalObjectEta,
+    LongitudinalObjectTheta,
+    LongitudinalObjectZ,
+    TemporalObjectT,
+    TemporalObjectTau,
+    VectorObject2D,
+    VectorObject3D,
+    VectorObject4D,
+)
 
 # Throws an error if awkward is too old
 vector._import_awkward()
@@ -93,8 +93,8 @@ class AzimuthalAwkward(CoordinatesAwkward, Azimuthal):
     @classmethod
     def from_fields(cls, array: ak.Array) -> "AzimuthalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.AzimuthalAwkwardXY` or a
-        :doc:`vector._backends.awkward_.AzimuthalAwkwardRhoPhi`, depending on
+        Create a :doc:`vector.backends.awkward.AzimuthalAwkwardXY` or a
+        :doc:`vector.backends.awkward.AzimuthalAwkwardRhoPhi`, depending on
         the fields in ``array``.
         """
         fields = ak.fields(array)
@@ -111,8 +111,8 @@ class AzimuthalAwkward(CoordinatesAwkward, Azimuthal):
     @classmethod
     def from_momentum_fields(cls, array: ak.Array) -> "AzimuthalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.AzimuthalAwkwardXY` or a
-        :doc:`vector._backends.awkward_.AzimuthalAwkwardRhoPhi`, depending on
+        Create a :doc:`vector.backends.awkward.AzimuthalAwkwardXY` or a
+        :doc:`vector.backends.awkward.AzimuthalAwkwardRhoPhi`, depending on
         the fields in ``array``, allowing momentum synonyms.
         """
         fields = ak.fields(array)
@@ -139,9 +139,9 @@ class LongitudinalAwkward(CoordinatesAwkward, Longitudinal):
     @classmethod
     def from_fields(cls, array: ak.Array) -> "LongitudinalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.LongitudinalAwkwardZ`, a
-        :doc:`vector._backends.awkward_.LongitudinalAwkwardTheta`, or a
-        :doc:`vector._backends.awkward_.LongitudinalAwkwardEta`, depending on
+        Create a :doc:`vector.backends.awkward.LongitudinalAwkwardZ`, a
+        :doc:`vector.backends.awkward.LongitudinalAwkwardTheta`, or a
+        :doc:`vector.backends.awkward.LongitudinalAwkwardEta`, depending on
         the fields in ``array``.
         """
         fields = ak.fields(array)
@@ -160,9 +160,9 @@ class LongitudinalAwkward(CoordinatesAwkward, Longitudinal):
     @classmethod
     def from_momentum_fields(cls, array: ak.Array) -> "LongitudinalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.LongitudinalAwkwardZ`, a
-        :doc:`vector._backends.awkward_.LongitudinalAwkwardTheta`, or a
-        :doc:`vector._backends.awkward_.LongitudinalAwkwardEta`, depending on
+        Create a :doc:`vector.backends.awkward.LongitudinalAwkwardZ`, a
+        :doc:`vector.backends.awkward.LongitudinalAwkwardTheta`, or a
+        :doc:`vector.backends.awkward.LongitudinalAwkwardEta`, depending on
         the fields in ``array``, allowing momentum synonyms.
         """
         fields = ak.fields(array)
@@ -185,8 +185,8 @@ class TemporalAwkward(CoordinatesAwkward, Temporal):
     @classmethod
     def from_fields(cls, array: ak.Array) -> "TemporalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.TemporalT` or a
-        :doc:`vector._backends.awkward_.TemporalTau`, depending on
+        Create a :doc:`vector.backends.awkward.TemporalT` or a
+        :doc:`vector.backends.awkward.TemporalTau`, depending on
         the fields in ``array``.
         """
         fields = ak.fields(array)
@@ -203,8 +203,8 @@ class TemporalAwkward(CoordinatesAwkward, Temporal):
     @classmethod
     def from_momentum_fields(cls, array: ak.Array) -> "TemporalAwkward":
         """
-        Create a :doc:`vector._backends.awkward_.TemporalT` or a
-        :doc:`vector._backends.awkward_.TemporalTau`, depending on
+        Create a :doc:`vector.backends.awkward.TemporalT` or a
+        :doc:`vector.backends.awkward.TemporalTau`, depending on
         the fields in ``array``, allowing momentum synonyms.
         """
         fields = ak.fields(array)
@@ -1228,27 +1228,27 @@ def _ttype_of(recordarraytype: typing.Any, is_momentum: bool) -> typing.Any:
 
 
 def _numba_typer_Vector2D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
     # These exist, but the file is type ignored, so can't be found
-    return vector._backends.numba_object.VectorObject2DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.VectorObject2DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, False)
     )
 
 
 def _numba_typer_Vector3D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
-    return vector._backends.numba_object.VectorObject3DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.VectorObject3DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, False),
         _ltype_of(viewtype.arrayviewtype.type, False),
     )
 
 
 def _numba_typer_Vector4D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
-    return vector._backends.numba_object.VectorObject4DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.VectorObject4DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, False),
         _ltype_of(viewtype.arrayviewtype.type, False),
         _ttype_of(viewtype.arrayviewtype.type, False),
@@ -1256,26 +1256,26 @@ def _numba_typer_Vector4D(viewtype: typing.Any) -> typing.Any:
 
 
 def _numba_typer_Momentum2D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
-    return vector._backends.numba_object.MomentumObject2DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.MomentumObject2DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, True)
     )
 
 
 def _numba_typer_Momentum3D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
-    return vector._backends.numba_object.MomentumObject3DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.MomentumObject3DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, True),
         _ltype_of(viewtype.arrayviewtype.type, True),
     )
 
 
 def _numba_typer_Momentum4D(viewtype: typing.Any) -> typing.Any:
-    import vector._backends.numba_object
+    import vector.backends._numba_object
 
-    return vector._backends.numba_object.MomentumObject4DType(  # type: ignore[attr-defined]
+    return vector.backends._numba_object.MomentumObject4DType(  # type: ignore[attr-defined]
         _aztype_of(viewtype.arrayviewtype.type, True),
         _ltype_of(viewtype.arrayviewtype.type, True),
         _ttype_of(viewtype.arrayviewtype.type, True),
@@ -1285,7 +1285,7 @@ def _numba_typer_Momentum4D(viewtype: typing.Any) -> typing.Any:
 def _numba_lower(
     context: typing.Any, builder: typing.Any, sig: typing.Any, args: typing.Any
 ) -> typing.Any:
-    from vector._backends.numba_object import (  # type: ignore[attr-defined]
+    from vector.backends._numba_object import (  # type: ignore[attr-defined]
         _awkward_numba_E,
         _awkward_numba_e,
         _awkward_numba_energy,
diff --git a/src/vector/_backends/awkward_constructors.py b/src/vector/backends/awkward_constructors.py
similarity index 97%
rename from src/vector/_backends/awkward_constructors.py
rename to src/vector/backends/awkward_constructors.py
index f17c463..f8896d6 100644
--- a/src/vector/_backends/awkward_constructors.py
+++ b/src/vector/backends/awkward_constructors.py
@@ -254,7 +254,7 @@ def Array(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
     import awkward
 
     import vector
-    import vector._backends.awkward_  # noqa: 401
+    import vector.backends.awkward  # noqa: 401
 
     akarray = awkward.Array(*args, **kwargs)
     fields = awkward.fields(akarray)
@@ -265,10 +265,10 @@ def Array(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
     for x in arrays:
         if needs_behavior:
             if x.behavior is None:
-                x.behavior = vector._backends.awkward_.behavior
+                x.behavior = vector.backends.awkward.behavior
             else:
                 x.behavior = dict(x.behavior)
-                x.behavior.update(vector._backends.awkward_.behavior)
+                x.behavior.update(vector.backends.awkward.behavior)
         else:
             x.behavior = None
         needs_behavior = False
@@ -345,13 +345,13 @@ def zip(
     import awkward
 
     import vector
-    import vector._backends.awkward_
+    import vector.backends.awkward
 
     is_momentum, dimension, names, columns = _check_names(arrays, list(arrays.keys()))
 
     behavior = None
     if not vector._awkward_registered:
-        behavior = dict(vector._backends.awkward_.behavior)
+        behavior = dict(vector.backends.awkward.behavior)
 
     return awkward.zip(
         dict(__builtins__["zip"](names, columns)),  # type: ignore[index]
diff --git a/src/vector/_backends/numba_numpy.py b/src/vector/backends/numba_numpy.py
similarity index 100%
rename from src/vector/_backends/numba_numpy.py
rename to src/vector/backends/numba_numpy.py
diff --git a/src/vector/_backends/numpy_.py b/src/vector/backends/numpy.py
similarity index 98%
rename from src/vector/_backends/numpy_.py
rename to src/vector/backends/numpy.py
index 7f30fa6..9119bd8 100644
--- a/src/vector/_backends/numpy_.py
+++ b/src/vector/backends/numpy.py
@@ -8,7 +8,7 @@ import typing
 
 import numpy
 
-import vector._backends.object_
+import vector.backends.object
 from vector._methods import (
     Azimuthal,
     AzimuthalRhoPhi,
@@ -224,19 +224,19 @@ class CoordinatesNumpy:
 
 
 class AzimuthalNumpy(CoordinatesNumpy, Azimuthal):
-    ObjectClass: typing.Type[vector._backends.object_.AzimuthalObject]
+    ObjectClass: typing.Type[vector.backends.object.AzimuthalObject]
 
 
 class LongitudinalNumpy(CoordinatesNumpy, Longitudinal):
-    ObjectClass: typing.Type[vector._backends.object_.LongitudinalObject]
+    ObjectClass: typing.Type[vector.backends.object.LongitudinalObject]
 
 
 class TemporalNumpy(CoordinatesNumpy, Temporal):
-    ObjectClass: typing.Type[vector._backends.object_.TemporalObject]
+    ObjectClass: typing.Type[vector.backends.object.TemporalObject]
 
 
 class AzimuthalNumpyXY(AzimuthalNumpy, AzimuthalXY, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.AzimuthalObjectXY
+    ObjectClass = vector.backends.object.AzimuthalObjectXY
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "AzimuthalNumpyXY":
@@ -263,7 +263,7 @@ class AzimuthalNumpyXY(AzimuthalNumpy, AzimuthalXY, GetItem, FloatArray):  # typ
 
 
 class AzimuthalNumpyRhoPhi(AzimuthalNumpy, AzimuthalRhoPhi, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.AzimuthalObjectRhoPhi
+    ObjectClass = vector.backends.object.AzimuthalObjectRhoPhi
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "AzimuthalNumpyRhoPhi":
@@ -290,7 +290,7 @@ class AzimuthalNumpyRhoPhi(AzimuthalNumpy, AzimuthalRhoPhi, GetItem, FloatArray)
 
 
 class LongitudinalNumpyZ(LongitudinalNumpy, LongitudinalZ, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.LongitudinalObjectZ
+    ObjectClass = vector.backends.object.LongitudinalObjectZ
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "LongitudinalNumpyZ":
@@ -313,7 +313,7 @@ class LongitudinalNumpyZ(LongitudinalNumpy, LongitudinalZ, GetItem, FloatArray):
 
 
 class LongitudinalNumpyTheta(LongitudinalNumpy, LongitudinalTheta, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.LongitudinalObjectTheta
+    ObjectClass = vector.backends.object.LongitudinalObjectTheta
     _IS_MOMENTUM = False
 
     def __new__(
@@ -338,7 +338,7 @@ class LongitudinalNumpyTheta(LongitudinalNumpy, LongitudinalTheta, GetItem, Floa
 
 
 class LongitudinalNumpyEta(LongitudinalNumpy, LongitudinalEta, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.LongitudinalObjectEta
+    ObjectClass = vector.backends.object.LongitudinalObjectEta
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "LongitudinalNumpyEta":
@@ -361,7 +361,7 @@ class LongitudinalNumpyEta(LongitudinalNumpy, LongitudinalEta, GetItem, FloatArr
 
 
 class TemporalNumpyT(TemporalNumpy, TemporalT, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.TemporalObjectT
+    ObjectClass = vector.backends.object.TemporalObjectT
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "TemporalNumpyT":
@@ -384,7 +384,7 @@ class TemporalNumpyT(TemporalNumpy, TemporalT, GetItem, FloatArray):  # type: ig
 
 
 class TemporalNumpyTau(TemporalNumpy, TemporalTau, GetItem, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.TemporalObjectTau
+    ObjectClass = vector.backends.object.TemporalObjectTau
     _IS_MOMENTUM = False
 
     def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> "TemporalNumpyTau":
@@ -657,7 +657,7 @@ class VectorNumpy(Vector, GetItem):
 
 
 class VectorNumpy2D(VectorNumpy, Planar, Vector2D, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.VectorObject2D
+    ObjectClass = vector.backends.object.VectorObject2D
     _IS_MOMENTUM = False
 
     _azimuthal_type: typing.Union[
@@ -845,7 +845,7 @@ class VectorNumpy2D(VectorNumpy, Planar, Vector2D, FloatArray):  # type: ignore[
 
 
 class MomentumNumpy2D(PlanarMomentum, VectorNumpy2D):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.MomentumObject2D
+    ObjectClass = vector.backends.object.MomentumObject2D
     _IS_MOMENTUM = True
     dtype: "numpy.dtype[typing.Any]"
 
@@ -875,7 +875,7 @@ class MomentumNumpy2D(PlanarMomentum, VectorNumpy2D):  # type: ignore[misc]
 
 
 class VectorNumpy3D(VectorNumpy, Spatial, Vector3D, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.VectorObject3D
+    ObjectClass = vector.backends.object.VectorObject3D
     _IS_MOMENTUM = False
 
     _azimuthal_type: typing.Union[
@@ -1087,7 +1087,7 @@ class VectorNumpy3D(VectorNumpy, Spatial, Vector3D, FloatArray):  # type: ignore
 
 
 class MomentumNumpy3D(SpatialMomentum, VectorNumpy3D):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.MomentumObject3D
+    ObjectClass = vector.backends.object.MomentumObject3D
     _IS_MOMENTUM = True
     dtype: "numpy.dtype[typing.Any]"
 
@@ -1127,7 +1127,7 @@ class MomentumNumpy3D(SpatialMomentum, VectorNumpy3D):  # type: ignore[misc]
 
 
 class VectorNumpy4D(VectorNumpy, Lorentz, Vector4D, FloatArray):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.VectorObject4D
+    ObjectClass = vector.backends.object.VectorObject4D
     _IS_MOMENTUM = False
 
     _azimuthal_type: typing.Union[
@@ -1366,7 +1366,7 @@ class VectorNumpy4D(VectorNumpy, Lorentz, Vector4D, FloatArray):  # type: ignore
 
 
 class MomentumNumpy4D(LorentzMomentum, VectorNumpy4D):  # type: ignore[misc]
-    ObjectClass = vector._backends.object_.MomentumObject4D
+    ObjectClass = vector.backends.object.MomentumObject4D
     _IS_MOMENTUM = True
     dtype: "numpy.dtype[typing.Any]"
 
diff --git a/src/vector/_backends/object_.py b/src/vector/backends/object.py
similarity index 95%
rename from src/vector/_backends/object_.py
rename to src/vector/backends/object.py
index f98f224..07a5a7a 100644
--- a/src/vector/_backends/object_.py
+++ b/src/vector/backends/object.py
@@ -441,7 +441,7 @@ class VectorObject2D(VectorObject, Planar, Vector2D):
         """
         Constructs a ``VectorObject2D`` from Cartesian coordinates.
 
-        Use :doc:`vector._backends.object_.MomentumObject2D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject2D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectXY(x, y))
@@ -451,7 +451,7 @@ class VectorObject2D(VectorObject, Planar, Vector2D):
         """
         Constructs a ``VectorObject2D`` from polar coordinates.
 
-        Use :doc:`vector._backends.object_.MomentumObject2D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject2D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectRhoPhi(rho, phi))
@@ -465,7 +465,7 @@ class VectorObject2D(VectorObject, Planar, Vector2D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import VectorNumpy2D
+        from vector.backends.numpy import VectorNumpy2D
 
         return VectorNumpy2D(
             self.azimuthal.elements,
@@ -595,7 +595,7 @@ class MomentumObject2D(PlanarMomentum, VectorObject2D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import MomentumNumpy2D
+        from vector.backends.numpy import MomentumNumpy2D
 
         return MomentumNumpy2D(
             self.azimuthal.elements,
@@ -640,7 +640,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         """
         Constructs a ``VectorObject3D`` from Cartesian coordinates.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectXY(x, y), LongitudinalObjectZ(z))
@@ -651,7 +651,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         Constructs a ``VectorObject3D`` from Cartesian azimuthal coordinates and
         a polar angle $\theta$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectXY(x, y), LongitudinalObjectTheta(theta))
@@ -662,7 +662,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         Constructs a ``VectorObject3D`` from Cartesian coordinates and a
         pseudorapidity $\eta$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectXY(x, y), LongitudinalObjectEta(eta))
@@ -673,7 +673,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates and a
         Cartesian longitudinal coordinate $z$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectRhoPhi(rho, phi), LongitudinalObjectZ(z))
@@ -684,7 +684,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates and a
         polar angle $\theta$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectRhoPhi(rho, phi), LongitudinalObjectTheta(theta))
@@ -695,7 +695,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates and a
         pseudorapidity $\eta$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectRhoPhi(rho, phi), LongitudinalObjectEta(eta))
@@ -715,7 +715,7 @@ class VectorObject3D(VectorObject, Spatial, Vector3D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import VectorNumpy3D
+        from vector.backends.numpy import VectorNumpy3D
 
         return VectorNumpy3D(
             self.azimuthal.elements + self.longitudinal.elements,
@@ -875,7 +875,7 @@ class MomentumObject3D(SpatialMomentum, VectorObject3D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import MomentumNumpy3D
+        from vector.backends.numpy import MomentumNumpy3D
 
         return MomentumNumpy3D(
             self.azimuthal.elements + self.longitudinal.elements,
@@ -938,7 +938,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian coordinates and a time
         coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(AzimuthalObjectXY(x, y), LongitudinalObjectZ(z), TemporalObjectT(t))
@@ -955,7 +955,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian coordinates and a proper time
         coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -974,7 +974,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian azimuthal coordinates, a
         polar angle $\theta$, and a time coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -993,7 +993,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian azimuthal coordinates, a
         polar angle $\theta$, and a proper time coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1014,7 +1014,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian coordinates, a pseudorapidity
         $\eta$, and a time coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1033,7 +1033,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from Cartesian coordinates, a pseudorapidity
         $\eta$, and a proper time coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1052,7 +1052,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a Cartesian
         longitudinal coordinate $z$, and a time coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1071,7 +1071,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a Cartesian
         longitudinal coordinate $z$, and a proper time coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1092,7 +1092,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a polar
         angle $\theta$, and a time coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1113,7 +1113,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a polar
         angle $\theta$, and a proper time coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1134,7 +1134,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a
         pseudorapidity $\eta$, and a time coordinate $t$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1155,7 +1155,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         Constructs a ``VectorObject3D`` from polar azimuthal coordinates, a
         pseudorapidity $\eta$, and a proper time coordinate $\tau$.
 
-        Use :doc:`vector._backends.object_.MomentumObject3D` to construct a vector
+        Use :doc:`vector.backends.object.MomentumObject3D` to construct a vector
         with momentum properties and methods.
         """
         return cls(
@@ -1186,7 +1186,7 @@ class VectorObject4D(VectorObject, Lorentz, Vector4D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import VectorNumpy4D
+        from vector.backends.numpy import VectorNumpy4D
 
         return VectorNumpy4D(
             self.azimuthal.elements
@@ -1369,7 +1369,7 @@ class MomentumObject4D(LorentzMomentum, VectorObject4D):
         return "vector.obj(" + ", ".join(out) + ")"
 
     def __array__(self) -> FloatArray:
-        from vector._backends.numpy_ import MomentumNumpy4D
+        from vector.backends.numpy import MomentumNumpy4D
 
         return MomentumNumpy4D(
             self.azimuthal.elements
@@ -1471,7 +1471,7 @@ def _gather_coordinates(
     coordinates: typing.Dict[str, typing.Any],
 ) -> typing.Any:
     """
-    Helper function for :doc:`vector._backends.object_.obj`.
+    Helper function for :doc:`vector.backends.object.obj`.
     """
     azimuthal: typing.Optional[
         typing.Union[AzimuthalObjectXY, AzimuthalObjectRhoPhi]
@@ -2704,33 +2704,33 @@ def obj(**coordinates: float) -> VectorObject:
     if they are not numbers, mathematical operations will fail. Usually, you want
     them to be ``int`` or ``float``.
 
-    Alternatively, the :doc:`vector._backends.object_.VectorObject2D`,
-    :doc:`vector._backends.object_.VectorObject3D`, and
-    :doc:`vector._backends.object_.VectorObject4D` classes (with momentum
+    Alternatively, the :doc:`vector.backends.object.VectorObject2D`,
+    :doc:`vector.backends.object.VectorObject3D`, and
+    :doc:`vector.backends.object.VectorObject4D` classes (with momentum
     subclasses) have explicit constructors:
 
-    - :doc:`vector._backends.object_.VectorObject2D.from_xy`
-    - :doc:`vector._backends.object_.VectorObject2D.from_rhophi`
-
-    - :doc:`vector._backends.object_.VectorObject3D.from_xyz`
-    - :doc:`vector._backends.object_.VectorObject3D.from_xytheta`
-    - :doc:`vector._backends.object_.VectorObject3D.from_xyeta`
-    - :doc:`vector._backends.object_.VectorObject3D.from_rhophiz`
-    - :doc:`vector._backends.object_.VectorObject3D.from_rhophitheta`
-    - :doc:`vector._backends.object_.VectorObject3D.from_rhophieta`
-
-    - :doc:`vector._backends.object_.VectorObject4D.from_xyzt`
-    - :doc:`vector._backends.object_.VectorObject4D.from_xyztau`
-    - :doc:`vector._backends.object_.VectorObject4D.from_xythetat`
-    - :doc:`vector._backends.object_.VectorObject4D.from_xythetatau`
-    - :doc:`vector._backends.object_.VectorObject4D.from_xyetat`
-    - :doc:`vector._backends.object_.VectorObject4D.from_xyetatau`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophizt`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophiztau`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophithetat`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophithetatau`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophietat`
-    - :doc:`vector._backends.object_.VectorObject4D.from_rhophietatau`
+    - :doc:`vector.backends.object.VectorObject2D.from_xy`
+    - :doc:`vector.backends.object.VectorObject2D.from_rhophi`
+
+    - :doc:`vector.backends.object.VectorObject3D.from_xyz`
+    - :doc:`vector.backends.object.VectorObject3D.from_xytheta`
+    - :doc:`vector.backends.object.VectorObject3D.from_xyeta`
+    - :doc:`vector.backends.object.VectorObject3D.from_rhophiz`
+    - :doc:`vector.backends.object.VectorObject3D.from_rhophitheta`
+    - :doc:`vector.backends.object.VectorObject3D.from_rhophieta`
+
+    - :doc:`vector.backends.object.VectorObject4D.from_xyzt`
+    - :doc:`vector.backends.object.VectorObject4D.from_xyztau`
+    - :doc:`vector.backends.object.VectorObject4D.from_xythetat`
+    - :doc:`vector.backends.object.VectorObject4D.from_xythetatau`
+    - :doc:`vector.backends.object.VectorObject4D.from_xyetat`
+    - :doc:`vector.backends.object.VectorObject4D.from_xyetatau`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophizt`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophiztau`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophithetat`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophithetatau`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophietat`
+    - :doc:`vector.backends.object.VectorObject4D.from_rhophietatau`
     """
     is_momentum = False
     generic_coordinates = {}


Test patch:
diff --git a/tests/backends/test_awkward.py b/tests/backends/test_awkward.py
index 21761a1..95f7031 100644
--- a/tests/backends/test_awkward.py
+++ b/tests/backends/test_awkward.py
@@ -14,17 +14,17 @@ pytestmark = pytest.mark.awkward
 
 def test_basic():
     array = vector.Array([[{"x": 1, "y": 2}], [], [{"x": 3, "y": 4}]])
-    assert isinstance(array, vector._backends.awkward_.VectorArray2D)
+    assert isinstance(array, vector.backends.awkward.VectorArray2D)
     assert array.x.tolist() == [[1], [], [3]]
     assert array.y.tolist() == [[2], [], [4]]
     assert array.rho.tolist() == [[2.23606797749979], [], [5]]
     assert array.phi.tolist() == [[1.1071487177940904], [], [0.9272952180016122]]
-    assert isinstance(array[2, 0], vector._backends.awkward_.VectorRecord2D)
+    assert isinstance(array[2, 0], vector.backends.awkward.VectorRecord2D)
     assert array[2, 0].rho == 5
     assert array.deltaphi(array).tolist() == [[0], [], [0]]
 
     array = vector.Array([[{"pt": 1, "phi": 2}], [], [{"pt": 3, "phi": 4}]])
-    assert isinstance(array, vector._backends.awkward_.MomentumArray2D)
+    assert isinstance(array, vector.backends.awkward.MomentumArray2D)
     assert array.pt.tolist() == [[1], [], [3]]
 
     array = vector.Array(
@@ -34,21 +34,21 @@ def test_basic():
             [{"x": 4, "y": 5, "z": 6, "wow": 123}],
         ]
     )
-    assert isinstance(array, vector._backends.awkward_.VectorArray3D)
+    assert isinstance(array, vector.backends.awkward.VectorArray3D)
     assert array.wow.tolist() == [[99], [], [123]]
 
 
 def test_rotateZ():
     array = vector.Array([[{"pt": 1, "phi": 0}], [], [{"pt": 2, "phi": 1}]])
     out = array.rotateZ(1)
-    assert isinstance(out, vector._backends.awkward_.MomentumArray2D)
+    assert isinstance(out, vector.backends.awkward.MomentumArray2D)
     assert out.tolist() == [[{"rho": 1, "phi": 1}], [], [{"rho": 2, "phi": 2}]]
 
     array = vector.Array(
         [[{"x": 1, "y": 0, "wow": 99}], [], [{"x": 2, "y": 1, "wow": 123}]]
     )
     out = array.rotateZ(0.1)
-    assert isinstance(out, vector._backends.awkward_.VectorArray2D)
+    assert isinstance(out, vector.backends.awkward.VectorArray2D)
     assert out.wow.tolist() == [[99], [], [123]]
 
 
@@ -61,7 +61,7 @@ def test_projection():
         ]
     )
     out = array.to_Vector2D()
-    assert isinstance(out, vector._backends.awkward_.VectorArray2D)
+    assert isinstance(out, vector.backends.awkward.VectorArray2D)
     assert out.tolist() == [
         [{"x": 1, "y": 2, "wow": 99}],
         [],
@@ -69,7 +69,7 @@ def test_projection():
     ]
 
     out = array.to_Vector4D()
-    assert isinstance(out, vector._backends.awkward_.VectorArray4D)
+    assert isinstance(out, vector.backends.awkward.VectorArray4D)
     assert out.tolist() == [
         [{"x": 1, "y": 2, "z": 3, "t": 0, "wow": 99}],
         [],
@@ -77,7 +77,7 @@ def test_projection():
     ]
 
     out = array.to_rhophietatau()
-    assert isinstance(out, vector._backends.awkward_.VectorArray4D)
+    assert isinstance(out, vector.backends.awkward.VectorArray4D)
     (a,), (), (c,) = out.tolist()
     assert a == pytest.approx(
         {
@@ -107,8 +107,8 @@ def test_add():
     two = vector.Array(
         [{"x": 10, "y": 20}, {"x": 100, "y": 200}, {"x": 1000, "y": 2000}]
     )
-    assert isinstance(one.add(two), vector._backends.awkward_.VectorArray2D)
-    assert isinstance(two.add(one), vector._backends.awkward_.VectorArray2D)
+    assert isinstance(one.add(two), vector.backends.awkward.VectorArray2D)
+    assert isinstance(two.add(one), vector.backends.awkward.VectorArray2D)
     assert one.add(two).tolist() == [
         [{"x": 11, "y": 21.1}, {"x": 12, "y": 22.2}],
         [],
@@ -121,8 +121,8 @@ def test_add():
     ]
 
     two = vector.array({"x": [10, 100, 1000], "y": [20, 200, 2000]})
-    assert isinstance(one.add(two), vector._backends.awkward_.VectorArray2D)
-    assert isinstance(two.add(one), vector._backends.awkward_.VectorArray2D)
+    assert isinstance(one.add(two), vector.backends.awkward.VectorArray2D)
+    assert isinstance(two.add(one), vector.backends.awkward.VectorArray2D)
     assert one.add(two).tolist() == [
         [{"x": 11, "y": 21.1}, {"x": 12, "y": 22.2}],
         [],
@@ -135,8 +135,8 @@ def test_add():
     ]
 
     two = vector.obj(x=10, y=20)
-    assert isinstance(one.add(two), vector._backends.awkward_.VectorArray2D)
-    assert isinstance(two.add(one), vector._backends.awkward_.VectorArray2D)
+    assert isinstance(one.add(two), vector.backends.awkward.VectorArray2D)
+    assert isinstance(two.add(one), vector.backends.awkward.VectorArray2D)
     assert one.add(two).tolist() == [
         [{"x": 11, "y": 21.1}, {"x": 12, "y": 22.2}],
         [],
@@ -177,9 +177,9 @@ def test_ufuncs():
 
 def test_zip():
     v = vector.zip({"x": [[], [1]], "y": [[], [1]]})
-    assert isinstance(v, vector._backends.awkward_.VectorArray2D)
-    assert isinstance(v[1], vector._backends.awkward_.VectorArray2D)
-    assert isinstance(v[1, 0], vector._backends.awkward_.VectorRecord2D)
+    assert isinstance(v, vector.backends.awkward.VectorArray2D)
+    assert isinstance(v[1], vector.backends.awkward.VectorArray2D)
+    assert isinstance(v[1, 0], vector.backends.awkward.VectorRecord2D)
     assert v.tolist() == [[], [{"x": 1, "y": 1}]]
     assert v.x.tolist() == [[], [1]]
     assert v.y.tolist() == [[], [1]]
diff --git a/tests/backends/test_awkward_numba.py b/tests/backends/test_awkward_numba.py
index c1cffc0..984d146 100644
--- a/tests/backends/test_awkward_numba.py
+++ b/tests/backends/test_awkward_numba.py
@@ -9,7 +9,7 @@ import vector
 
 ak = pytest.importorskip("awkward")
 numba = pytest.importorskip("numba")
-pytest.importorskip("vector._backends.numba_object")
+pytest.importorskip("vector.backends._numba_object")
 
 
 pytestmark = [pytest.mark.numba, pytest.mark.awkward]
@@ -22,7 +22,7 @@ def test():
 
     array = vector.Array([[{"x": 1, "y": 2}], [], [{"x": 3, "y": 4}, {"x": 5, "y": 6}]])
     out = extract(array)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(3)
     assert out.y == pytest.approx(4)
 
@@ -30,7 +30,7 @@ def test():
         [[{"x": 1, "y": 2, "z": 3, "E": 4}], [], [{"x": 5, "y": 6, "z": 7, "E": 15}]]
     )
     out = extract(array)
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.x == pytest.approx(5)
     assert out.y == pytest.approx(6)
     assert out.z == pytest.approx(7)
diff --git a/tests/backends/test_numba_numpy.py b/tests/backends/test_numba_numpy.py
index d7db56d..7df04ef 100644
--- a/tests/backends/test_numba_numpy.py
+++ b/tests/backends/test_numba_numpy.py
@@ -6,12 +6,12 @@
 import pytest
 
 import vector
-import vector._backends.object_
+import vector.backends.object
 
 numba = pytest.importorskip("numba")
 
 
-import vector._backends.numba_numpy  # noqa: E402
+import vector.backends.numba_numpy  # noqa: E402
 
 pytestmark = pytest.mark.numba
 
@@ -22,5 +22,5 @@ def test_pass_through():
         return obj
 
     array = vector.array({"px": [1, 2, 3], "py": [10, 20, 30]})
-    assert isinstance(array, vector._backends.numpy_.VectorNumpy)
-    assert isinstance(pass_through(array), vector._backends.numpy_.VectorNumpy)
+    assert isinstance(array, vector.backends.numpy.VectorNumpy)
+    assert isinstance(pass_through(array), vector.backends.numpy.VectorNumpy)
diff --git a/tests/backends/test_numba_object.py b/tests/backends/test_numba_object.py
index b699b7b..9a0c76e 100644
--- a/tests/backends/test_numba_object.py
+++ b/tests/backends/test_numba_object.py
@@ -9,12 +9,12 @@ import numpy
 import pytest
 
 import vector
-import vector._backends.object_
+import vector.backends.object
 
 numba = pytest.importorskip("numba")
 
 
-import vector._backends.numba_object  # noqa: E402
+import vector.backends._numba_object  # noqa: E402
 
 pytestmark = pytest.mark.numba
 
@@ -24,8 +24,8 @@ def test_namedtuples():
     def get_x(obj):
         return obj.x
 
-    assert get_x(vector._backends.object_.AzimuthalObjectXY(1, 2.2)) == 1
-    assert get_x(vector._backends.object_.AzimuthalObjectXY(1.1, 2)) == 1.1
+    assert get_x(vector.backends.object.AzimuthalObjectXY(1, 2.2)) == 1
+    assert get_x(vector.backends.object.AzimuthalObjectXY(1.1, 2)) == 1.1
 
 
 def test_VectorObjectType():
@@ -53,10 +53,8 @@ def test_VectorObjectType():
         zero(obj)
         assert (sys.getrefcount(obj), sys.getrefcount(obj.azimuthal)) == (2, 2)
         if class_refs is None:
-            class_refs = sys.getrefcount(vector._backends.object_.VectorObject2D)
-        assert class_refs + 1 == sys.getrefcount(
-            vector._backends.object_.VectorObject2D
-        )
+            class_refs = sys.getrefcount(vector.backends.object.VectorObject2D)
+        assert class_refs + 1 == sys.getrefcount(vector.backends.object.VectorObject2D)
 
     class_refs = None
     for _ in range(10):
@@ -64,10 +62,8 @@ def test_VectorObjectType():
         assert (sys.getrefcount(obj), sys.getrefcount(obj.azimuthal)) == (2, 2)
         assert (sys.getrefcount(a), sys.getrefcount(a.azimuthal)) == (2, 2)
         if class_refs is None:
-            class_refs = sys.getrefcount(vector._backends.object_.VectorObject2D)
-        assert class_refs + 1 == sys.getrefcount(
-            vector._backends.object_.VectorObject2D
-        )
+            class_refs = sys.getrefcount(vector.backends.object.VectorObject2D)
+        assert class_refs + 1 == sys.getrefcount(vector.backends.object.VectorObject2D)
 
     class_refs = None
     for _ in range(10):
@@ -80,42 +76,40 @@ def test_VectorObjectType():
             sys.getrefcount(b.azimuthal),
         ) == (2, 2, 2, 2)
         if class_refs is None:
-            class_refs = sys.getrefcount(vector._backends.object_.VectorObject2D)
-        assert class_refs + 1 == sys.getrefcount(
-            vector._backends.object_.VectorObject2D
-        )
+            class_refs = sys.getrefcount(vector.backends.object.VectorObject2D)
+        assert class_refs + 1 == sys.getrefcount(vector.backends.object.VectorObject2D)
 
     # These tests just check that the rest of the implementations are sane.
 
     obj = vector.obj(x=1, y=2)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
 
     obj = vector.obj(px=1, py=2)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
 
     obj = vector.obj(x=1, y=2, z=3)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
     assert out.z == pytest.approx(3)
 
     obj = vector.obj(px=1, py=2, pz=3)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
     assert out.z == pytest.approx(3)
 
     obj = vector.obj(x=1, y=2, z=3, t=4)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
     assert out.z == pytest.approx(3)
@@ -123,165 +117,165 @@ def test_VectorObjectType():
 
     obj = vector.obj(px=1, py=2, pz=3, t=4)
     out = one(obj)
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2)
     assert out.z == pytest.approx(3)
     assert out.t == pytest.approx(4)
 
 
-def test_VectorObject_constructor():
+def test_VectorObjectconstructor():
     @numba.njit
     def vector_xy():
-        return vector._backends.object_.VectorObject2D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2)
+        return vector.backends.object.VectorObject2D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2)
         )
 
     @numba.njit
     def vector_rhophi():
-        return vector._backends.object_.VectorObject2D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2)
+        return vector.backends.object.VectorObject2D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2)
         )
 
     @numba.njit
     def momentum_xy():
-        return vector._backends.object_.MomentumObject2D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2)
+        return vector.backends.object.MomentumObject2D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2)
         )
 
     @numba.njit
     def momentum_rhophi():
-        return vector._backends.object_.MomentumObject2D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2)
+        return vector.backends.object.MomentumObject2D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2)
         )
 
     @numba.njit
     def vector_xyz():
-        return vector._backends.object_.VectorObject3D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2),
-            vector._backends.object_.LongitudinalObjectZ(3),
+        return vector.backends.object.VectorObject3D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2),
+            vector.backends.object.LongitudinalObjectZ(3),
         )
 
     @numba.njit
     def momentum_xyz():
-        return vector._backends.object_.MomentumObject3D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2),
-            vector._backends.object_.LongitudinalObjectZ(3),
+        return vector.backends.object.MomentumObject3D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2),
+            vector.backends.object.LongitudinalObjectZ(3),
         )
 
     @numba.njit
     def vector_rhophitheta():
-        return vector._backends.object_.VectorObject3D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2),
-            vector._backends.object_.LongitudinalObjectTheta(3),
+        return vector.backends.object.VectorObject3D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2),
+            vector.backends.object.LongitudinalObjectTheta(3),
         )
 
     @numba.njit
     def momentum_rhophitheta():
-        return vector._backends.object_.MomentumObject3D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2),
-            vector._backends.object_.LongitudinalObjectTheta(3),
+        return vector.backends.object.MomentumObject3D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2),
+            vector.backends.object.LongitudinalObjectTheta(3),
         )
 
     @numba.njit
     def vector_xyzt():
-        return vector._backends.object_.VectorObject4D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2),
-            vector._backends.object_.LongitudinalObjectZ(3),
-            vector._backends.object_.TemporalObjectT(4),
+        return vector.backends.object.VectorObject4D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2),
+            vector.backends.object.LongitudinalObjectZ(3),
+            vector.backends.object.TemporalObjectT(4),
         )
 
     @numba.njit
     def momentum_xyzt():
-        return vector._backends.object_.MomentumObject4D(
-            vector._backends.object_.AzimuthalObjectXY(1, 2.2),
-            vector._backends.object_.LongitudinalObjectZ(3),
-            vector._backends.object_.TemporalObjectT(4),
+        return vector.backends.object.MomentumObject4D(
+            vector.backends.object.AzimuthalObjectXY(1, 2.2),
+            vector.backends.object.LongitudinalObjectZ(3),
+            vector.backends.object.TemporalObjectT(4),
         )
 
     @numba.njit
     def vector_rhophietatau():
-        return vector._backends.object_.VectorObject4D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2),
-            vector._backends.object_.LongitudinalObjectEta(3),
-            vector._backends.object_.TemporalObjectTau(4),
+        return vector.backends.object.VectorObject4D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2),
+            vector.backends.object.LongitudinalObjectEta(3),
+            vector.backends.object.TemporalObjectTau(4),
         )
 
     @numba.njit
     def momentum_rhophietatau():
-        return vector._backends.object_.MomentumObject4D(
-            vector._backends.object_.AzimuthalObjectRhoPhi(1, 2.2),
-            vector._backends.object_.LongitudinalObjectEta(3),
-            vector._backends.object_.TemporalObjectTau(4),
+        return vector.backends.object.MomentumObject4D(
+            vector.backends.object.AzimuthalObjectRhoPhi(1, 2.2),
+            vector.backends.object.LongitudinalObjectEta(3),
+            vector.backends.object.TemporalObjectTau(4),
         )
 
     out = vector_xy()
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
 
     out = vector_rhophi()
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
 
     out = momentum_xy()
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
 
     out = momentum_rhophi()
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
 
     out = vector_xyz()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
     assert out.z == pytest.approx(3)
 
     out = momentum_xyz()
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
     assert out.z == pytest.approx(3)
 
     out = vector_rhophitheta()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
     assert out.theta == pytest.approx(3)
 
     out = momentum_rhophitheta()
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
     assert out.theta == pytest.approx(3)
 
     out = vector_xyzt()
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
     assert out.z == pytest.approx(3)
     assert out.t == pytest.approx(4)
 
     out = momentum_xyzt()
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.x == pytest.approx(1)
     assert out.y == pytest.approx(2.2)
     assert out.z == pytest.approx(3)
     assert out.t == pytest.approx(4)
 
     out = vector_rhophietatau()
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
     assert out.eta == pytest.approx(3)
     assert out.tau == pytest.approx(4)
 
     out = momentum_rhophietatau()
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(2.2)
     assert out.eta == pytest.approx(3)
@@ -302,75 +296,75 @@ def test_projections():
         return x.to_Vector4D()
 
     assert isinstance(
-        to_Vector2D(vector.obj(x=1.1, y=2.2)), vector._backends.object_.VectorObject2D
+        to_Vector2D(vector.obj(x=1.1, y=2.2)), vector.backends.object.VectorObject2D
     )
     assert isinstance(
         to_Vector2D(vector.obj(x=1.1, y=2.2, z=3.3)),
-        vector._backends.object_.VectorObject2D,
+        vector.backends.object.VectorObject2D,
     )
     assert isinstance(
         to_Vector2D(vector.obj(x=1.1, y=2.2, z=3.3, t=4.4)),
-        vector._backends.object_.VectorObject2D,
+        vector.backends.object.VectorObject2D,
     )
     assert isinstance(
         to_Vector2D(vector.obj(px=1.1, py=2.2)),
-        vector._backends.object_.MomentumObject2D,
+        vector.backends.object.MomentumObject2D,
     )
     assert isinstance(
         to_Vector2D(vector.obj(px=1.1, py=2.2, pz=3.3)),
-        vector._backends.object_.MomentumObject2D,
+        vector.backends.object.MomentumObject2D,
     )
     assert isinstance(
         to_Vector2D(vector.obj(px=1.1, py=2.2, pz=3.3, E=4.4)),
-        vector._backends.object_.MomentumObject2D,
+        vector.backends.object.MomentumObject2D,
     )
 
     assert isinstance(
-        to_Vector3D(vector.obj(x=1.1, y=2.2)), vector._backends.object_.VectorObject3D
+        to_Vector3D(vector.obj(x=1.1, y=2.2)), vector.backends.object.VectorObject3D
     )
     assert isinstance(
         to_Vector3D(vector.obj(x=1.1, y=2.2, z=3.3)),
-        vector._backends.object_.VectorObject3D,
+        vector.backends.object.VectorObject3D,
     )
     assert isinstance(
         to_Vector3D(vector.obj(x=1.1, y=2.2, z=3.3, t=4.4)),
-        vector._backends.object_.VectorObject3D,
+        vector.backends.object.VectorObject3D,
     )
     assert isinstance(
         to_Vector3D(vector.obj(px=1.1, py=2.2)),
-        vector._backends.object_.MomentumObject3D,
+        vector.backends.object.MomentumObject3D,
     )
     assert isinstance(
         to_Vector3D(vector.obj(px=1.1, py=2.2, pz=3.3)),
-        vector._backends.object_.MomentumObject3D,
+        vector.backends.object.MomentumObject3D,
     )
     assert isinstance(
         to_Vector3D(vector.obj(px=1.1, py=2.2, pz=3.3, E=4.4)),
-        vector._backends.object_.MomentumObject3D,
+        vector.backends.object.MomentumObject3D,
     )
 
     assert isinstance(
-        to_Vector4D(vector.obj(x=1.1, y=2.2)), vector._backends.object_.VectorObject4D
+        to_Vector4D(vector.obj(x=1.1, y=2.2)), vector.backends.object.VectorObject4D
     )
     assert isinstance(
         to_Vector4D(vector.obj(x=1.1, y=2.2, z=3.3)),
-        vector._backends.object_.VectorObject4D,
+        vector.backends.object.VectorObject4D,
     )
     assert isinstance(
         to_Vector4D(vector.obj(x=1.1, y=2.2, z=3.3, t=4.4)),
-        vector._backends.object_.VectorObject4D,
+        vector.backends.object.VectorObject4D,
     )
     assert isinstance(
         to_Vector4D(vector.obj(px=1.1, py=2.2)),
-        vector._backends.object_.MomentumObject4D,
+        vector.backends.object.MomentumObject4D,
     )
     assert isinstance(
         to_Vector4D(vector.obj(px=1.1, py=2.2, pz=3.3)),
-        vector._backends.object_.MomentumObject4D,
+        vector.backends.object.MomentumObject4D,
     )
     assert isinstance(
         to_Vector4D(vector.obj(px=1.1, py=2.2, pz=3.3, E=4.4)),
-        vector._backends.object_.MomentumObject4D,
+        vector.backends.object.MomentumObject4D,
     )
 
 
@@ -466,116 +460,112 @@ def test_conversions():
         print(v)
 
         out = to_xy(v)
-        assert isinstance(out, vector._backends.object_.VectorObject2D)
+        assert isinstance(out, vector.backends.object.VectorObject2D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject2D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.MomentumObject2D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
 
         out = to_rhophi(v)
-        assert isinstance(out, vector._backends.object_.VectorObject2D)
+        assert isinstance(out, vector.backends.object.VectorObject2D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject2D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectRhoPhi)
+            assert isinstance(out, vector.backends.object.MomentumObject2D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectRhoPhi)
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
 
         out = to_xyz(v)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
+        assert isinstance(out, vector.backends.object.VectorObject3D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-        assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectZ
-        )
+            assert isinstance(out, vector.backends.object.MomentumObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+        assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.z == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
 
         out = to_rhophiz(v)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
+        assert isinstance(out, vector.backends.object.VectorObject3D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectRhoPhi)
-        assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectZ
-        )
+            assert isinstance(out, vector.backends.object.MomentumObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectRhoPhi)
+        assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.z == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
 
         out = to_xytheta(v)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
+        assert isinstance(out, vector.backends.object.VectorObject3D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.MomentumObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
         assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectTheta
+            out.longitudinal, vector.backends.object.LongitudinalObjectTheta
         )
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.theta == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
 
         out = to_rhophitheta(v)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
+        assert isinstance(out, vector.backends.object.VectorObject3D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectRhoPhi)
+            assert isinstance(out, vector.backends.object.MomentumObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectRhoPhi)
         assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectTheta
+            out.longitudinal, vector.backends.object.LongitudinalObjectTheta
         )
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.theta == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
 
         out = to_xyeta(v)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
+        assert isinstance(out, vector.backends.object.VectorObject3D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.MomentumObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
         assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectEta
+            out.longitudinal, vector.backends.object.LongitudinalObjectEta
         )
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.eta == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
 
         out = to_rhophietatau(v)
-        assert isinstance(out, vector._backends.object_.VectorObject4D)
+        assert isinstance(out, vector.backends.object.VectorObject4D)
         if isinstance(v, vector._methods.Momentum):
-            assert isinstance(out, vector._backends.object_.MomentumObject4D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectRhoPhi)
+            assert isinstance(out, vector.backends.object.MomentumObject4D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectRhoPhi)
         assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectEta
+            out.longitudinal, vector.backends.object.LongitudinalObjectEta
         )
-        assert isinstance(out.temporal, vector._backends.object_.TemporalObjectTau)
+        assert isinstance(out.temporal, vector.backends.object.TemporalObjectTau)
         assert out.x == pytest.approx(1.1)
         assert out.y == pytest.approx(2.2)
-        if isinstance(v, vector._backends.object_.VectorObject2D):
+        if isinstance(v, vector.backends.object.VectorObject2D):
             assert out.eta == pytest.approx(0)
         else:
             assert out.z == pytest.approx(3.3)
         if isinstance(
             v,
             (
-                vector._backends.object_.VectorObject2D,
-                vector._backends.object_.VectorObject3D,
+                vector.backends.object.VectorObject2D,
+                vector.backends.object.VectorObject3D,
             ),
         ):
             assert out.tau == pytest.approx(0)
@@ -633,72 +623,72 @@ def test_factory():
         return vector.obj(rho=2, phi=3.3, z=5, energy=10)
 
     out = vector_xy()
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
 
     out = momentum_xy()
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
 
     out = vector_rhophi()
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.rho == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
 
     out = momentum_rhophi()
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.pt == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
 
     out = vector_xyz()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
 
     out = momentum_xyz()
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
 
     out = vector_rhophieta()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.rho == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
     assert out.eta == pytest.approx(5)
 
     out = momentum_rhophieta()
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.pt == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
     assert out.eta == pytest.approx(5)
 
     out = vector_xyztau()
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
     assert out.tau == pytest.approx(10)
 
     out = momentum_xyztau()
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
     assert out.tau == pytest.approx(10)
 
     out = vector_rhophizt()
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.rho == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
     assert out.t == pytest.approx(10)
 
     out = momentum_rhophizt()
-    assert isinstance(out, vector._backends.object_.MomentumObject4D)
+    assert isinstance(out, vector.backends.object.MomentumObject4D)
     assert out.pt == pytest.approx(2)
     assert out.phi == pytest.approx(3.3)
     assert out.z == pytest.approx(5)
@@ -812,85 +802,85 @@ def test_method_add():
         return v1.add(v2)
 
     out = get_add(vector.obj(x=1.1, y=2.2), vector.obj(x=3, y=4))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2), vector.obj(x=3, y=4, z=5))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2, z=3.3), vector.obj(x=3, y=4))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2, z=3.3), vector.obj(x=3, y=4, z=5))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
     assert out.z == pytest.approx(8.3)
 
     out = get_add(vector.obj(px=1.1, py=2.2), vector.obj(px=3, py=4))
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2), vector.obj(px=3, py=4, pz=5))
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2, pz=3.3), vector.obj(px=3, py=4))
-    assert isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2, pz=3.3), vector.obj(px=3, py=4, pz=5))
-    assert isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
     assert out.z == pytest.approx(8.3)
 
     out = get_add(vector.obj(x=1.1, y=2.2), vector.obj(px=3, py=4))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2), vector.obj(px=3, py=4, pz=5))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2, z=3.3), vector.obj(px=3, py=4))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(x=1.1, y=2.2, z=3.3), vector.obj(px=3, py=4, pz=5))
-    assert not isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert not isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
     assert out.z == pytest.approx(8.3)
 
     out = get_add(vector.obj(px=1.1, py=2.2), vector.obj(x=3, y=4))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2), vector.obj(x=3, y=4, z=5))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2, pz=3.3), vector.obj(x=3, y=4))
-    assert not isinstance(out, vector._backends.object_.MomentumObject2D)
+    assert not isinstance(out, vector.backends.object.MomentumObject2D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
 
     out = get_add(vector.obj(px=1.1, py=2.2, pz=3.3), vector.obj(x=3, y=4, z=5))
-    assert not isinstance(out, vector._backends.object_.MomentumObject3D)
+    assert not isinstance(out, vector.backends.object.MomentumObject3D)
     assert out.x == pytest.approx(4.1)
     assert out.y == pytest.approx(6.2)
     assert out.z == pytest.approx(8.3)
@@ -936,17 +926,17 @@ def test_method_rotateZ():
         return v.rotateZ(angle)
 
     out = get_rotateZ(vector.obj(x=1, y=0), 0.1)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
 
     out = get_rotateZ(vector.obj(rho=1, phi=0), 0.1)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(0.1)
 
     out = get_rotateZ(vector.obj(x=1, y=0, z=2.2), 0.1)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
     assert out.z == pytest.approx(2.2)
@@ -964,17 +954,17 @@ def test_method_transform2D():
     obj["yy"] = numpy.cos(0.1)
 
     out = get_transform2D(vector.obj(x=1, y=0), obj)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
 
     out = get_transform2D(vector.obj(rho=1, phi=0), obj)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.rho == pytest.approx(1)
     assert out.phi == pytest.approx(0.1)
 
     out = get_transform2D(vector.obj(x=1, y=0, z=2.2), obj)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
     assert out.z == pytest.approx(2.2)
@@ -986,18 +976,18 @@ def test_method_unit():
         return v.unit()
 
     out = get_unit(vector.obj(x=1, y=1))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(1 / numpy.sqrt(2))
     assert out.y == pytest.approx(1 / numpy.sqrt(2))
 
     out = get_unit(vector.obj(x=1, y=1, z=1))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(1 / numpy.sqrt(3))
     assert out.y == pytest.approx(1 / numpy.sqrt(3))
     assert out.z == pytest.approx(1 / numpy.sqrt(3))
 
     out = get_unit(vector.obj(x=1, y=1, z=1, t=1))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(1 / numpy.sqrt(2))
     assert out.y == pytest.approx(1 / numpy.sqrt(2))
     assert out.z == pytest.approx(1 / numpy.sqrt(2))
@@ -1010,18 +1000,18 @@ def test_method_scale():
         return v.scale(2)
 
     out = get_scale(vector.obj(x=1.1, y=2.2))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(2.2)
     assert out.y == pytest.approx(4.4)
 
     out = get_scale(vector.obj(x=1.1, y=2.2, z=3.3))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(2.2)
     assert out.y == pytest.approx(4.4)
     assert out.z == pytest.approx(6.6)
 
     out = get_scale(vector.obj(x=1.1, y=2.2, z=3.3, t=4.4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(2.2)
     assert out.y == pytest.approx(4.4)
     assert out.z == pytest.approx(6.6)
@@ -1034,33 +1024,33 @@ def test_method_cross():
         return v1.cross(v2)
 
     out = get_cross(vector.obj(x=0.1, y=0.2, z=0.3), vector.obj(x=0.4, y=0.5, z=0.6))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
     out = get_cross(
         vector.obj(x=0.1, y=0.2, z=0.3, t=999), vector.obj(x=0.4, y=0.5, z=0.6)
     )
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
     out = get_cross(
         vector.obj(x=0.1, y=0.2, z=0.3), vector.obj(x=0.4, y=0.5, z=0.6, t=999)
     )
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
     out = get_cross(
         vector.obj(x=0.1, y=0.2, z=0.3, t=999), vector.obj(x=0.4, y=0.5, z=0.6, t=999)
     )
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
 
@@ -1070,13 +1060,13 @@ def test_method_rotateX():
         return v.rotateX(0.25)
 
     out = get_rotateX(vector.obj(x=0.1, y=0.2, z=0.3))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.1)
     assert out.y == pytest.approx(0.1195612965657721)
     assert out.z == pytest.approx(0.340154518364098)
 
     out = get_rotateX(vector.obj(x=0.1, y=0.2, z=0.3, t=0.4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(0.1)
     assert out.y == pytest.approx(0.1195612965657721)
     assert out.z == pytest.approx(0.340154518364098)
@@ -1089,13 +1079,13 @@ def test_method_rotateY():
         return v.rotateY(0.25)
 
     out = get_rotateY(vector.obj(x=0.1, y=0.2, z=0.3))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.17111242994742137)
     assert out.y == pytest.approx(0.2)
     assert out.z == pytest.approx(0.2659333305877411)
 
     out = get_rotateY(vector.obj(x=0.1, y=0.2, z=0.3, t=0.4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(0.17111242994742137)
     assert out.y == pytest.approx(0.2)
     assert out.z == pytest.approx(0.2659333305877411)
@@ -1110,7 +1100,7 @@ def test_method_rotate_axis():
     axis = vector.obj(x=0.1, y=0.2, z=0.3)
     vec = vector.obj(x=0.4, y=0.5, z=0.6)
     out = get_rotate_axis(vec, axis)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
     assert out.z == pytest.approx(0.5828282027463345)
@@ -1118,7 +1108,7 @@ def test_method_rotate_axis():
     axis = vector.obj(x=0.1, y=0.2, z=0.3)
     vec = vector.obj(x=0.4, y=0.5, z=0.6, t=999)
     out = get_rotate_axis(vec, axis)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
     assert out.z == pytest.approx(0.5828282027463345)
@@ -1127,7 +1117,7 @@ def test_method_rotate_axis():
     axis = vector.obj(x=0.1, y=0.2, z=0.3, t=999)
     vec = vector.obj(x=0.4, y=0.5, z=0.6)
     out = get_rotate_axis(vec, axis)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
     assert out.z == pytest.approx(0.5828282027463345)
@@ -1135,7 +1125,7 @@ def test_method_rotate_axis():
     axis = vector.obj(x=0.1, y=0.2, z=0.3, t=999)
     vec = vector.obj(x=0.4, y=0.5, z=0.6, t=999)
     out = get_rotate_axis(vec, axis)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
     assert out.z == pytest.approx(0.5828282027463345)
@@ -1149,7 +1139,7 @@ def test_method_rotate_euler():
 
     vec = vector.obj(x=0.4, y=0.5, z=0.6)
     out = get_rotate_euler(vec, 0.1, 0.2, 0.3)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.5956646364506655)
     assert out.y == pytest.approx(0.409927258162962)
     assert out.z == pytest.approx(0.4971350761081869)
@@ -1162,7 +1152,7 @@ def test_method_rotate_quaternion():
 
     vec = vector.obj(x=0.5, y=0.6, z=0.7)
     out = get_rotate_quaternion(vec, 0.1, 0.2, 0.3, 0.4)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.078)
     assert out.y == pytest.approx(0.18)
     assert out.z == pytest.approx(0.246)
@@ -1185,7 +1175,7 @@ def test_method_transform3D():
     obj["zz"] = 1
 
     out = get_transform3D(vector.obj(x=1, y=0, z=99), obj)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
     assert out.z == pytest.approx(99)
@@ -1261,7 +1251,7 @@ def test_method_to_beta3():
         return vec.to_beta3()
 
     out = get_to_beta3(vector.obj(x=3, y=4, z=10, t=20))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(3 / 20)
     assert out.y == pytest.approx(4 / 20)
     assert out.z == pytest.approx(10 / 20)
@@ -1291,7 +1281,7 @@ def test_method_transform4D():
     obj["tt"] = 1
 
     out = get_transform4D(vector.obj(x=1, y=0, z=99, t=123), obj)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(0.9950041652780258)
     assert out.y == pytest.approx(0.09983341664682815)
     assert out.z == pytest.approx(99)
@@ -1435,23 +1425,23 @@ def test_operator_add():
         return v1 - v2
 
     out = get_add(vector.obj(x=1, y=2), vector.obj(px=3, py=4))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(4)
     assert out.y == pytest.approx(6)
 
     out = get_add(vector.obj(x=1, y=2), vector.obj(x=3, y=4, z=5))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(4)
     assert out.y == pytest.approx(6)
 
     out = get_add(vector.obj(x=1, y=2, z=0), vector.obj(x=3, y=4, z=5))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(4)
     assert out.y == pytest.approx(6)
     assert out.z == pytest.approx(5)
 
     out = get_subtract(vector.obj(x=1, y=2), vector.obj(px=3, py=4))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(-2)
     assert out.y == pytest.approx(-2)
 
@@ -1466,17 +1456,17 @@ def test_operator_mul():
         return a / b
 
     out = get_mul(vector.obj(x=1, y=2), 2)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(4)
 
     out = get_mul(2, vector.obj(x=1, y=2))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(2)
     assert out.y == pytest.approx(4)
 
     out = get_div(vector.obj(x=1, y=2), 2)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(0.5)
     assert out.y == pytest.approx(1)
 
@@ -1518,7 +1508,7 @@ def test_numpy_functions():
         return numpy.add(v1, v2)
 
     out = get_add(vector.obj(x=3, y=4), vector.obj(x=10, y=20))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(13)
     assert out.y == pytest.approx(24)
 
@@ -1533,36 +1523,36 @@ def test_scale2D_3D_4D():
         return v.neg2D
 
     out = get_scale2D(vector.obj(x=1, y=2), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
 
     out = get_scale2D(vector.obj(x=1, y=2, z=3), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
     assert out.z == pytest.approx(3)
 
     out = get_scale2D(vector.obj(x=1, y=2, z=3, t=4), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
     assert out.z == pytest.approx(3)
     assert out.t == pytest.approx(4)
 
     out = get_neg2D(vector.obj(x=1, y=2))
-    assert isinstance(out, vector._backends.object_.VectorObject2D)
+    assert isinstance(out, vector.backends.object.VectorObject2D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
 
     out = get_neg2D(vector.obj(x=1, y=2, z=3))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
     assert out.z == pytest.approx(3)
 
     out = get_neg2D(vector.obj(x=1, y=2, z=3, t=4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
     assert out.z == pytest.approx(3)
@@ -1577,26 +1567,26 @@ def test_scale2D_3D_4D():
         return v.neg3D
 
     out = get_scale3D(vector.obj(x=1, y=2, z=3), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
     assert out.z == pytest.approx(30)
 
     out = get_scale3D(vector.obj(x=1, y=2, z=3, t=4), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
     assert out.z == pytest.approx(30)
     assert out.t == pytest.approx(4)
 
     out = get_neg3D(vector.obj(x=1, y=2, z=3))
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
     assert out.z == pytest.approx(-3)
 
     out = get_neg3D(vector.obj(x=1, y=2, z=3, t=4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
     assert out.z == pytest.approx(-3)
@@ -1611,14 +1601,14 @@ def test_scale2D_3D_4D():
         return v.neg4D
 
     out = get_scale4D(vector.obj(x=1, y=2, z=3, t=4), 10)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(10)
     assert out.y == pytest.approx(20)
     assert out.z == pytest.approx(30)
     assert out.t == pytest.approx(40)
 
     out = get_neg4D(vector.obj(x=1, y=2, z=3, t=4))
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
     assert out.x == pytest.approx(-1)
     assert out.y == pytest.approx(-2)
     assert out.z == pytest.approx(-3)
diff --git a/tests/backends/test_numpy.py b/tests/backends/test_numpy.py
index f3ebfc0..fe2f6bf 100644
--- a/tests/backends/test_numpy.py
+++ b/tests/backends/test_numpy.py
@@ -8,11 +8,11 @@ import pickle
 
 import numpy
 
-import vector._backends.numpy_
+import vector.backends.numpy
 
 
 def test_xy():
-    array = vector._backends.numpy_.VectorNumpy2D(
+    array = vector.backends.numpy.VectorNumpy2D(
         [(0, 0), (0, 1), (3, 4)], dtype=[("x", numpy.float64), ("y", numpy.float64)]
     )
     assert numpy.allclose(array.x, [0, 0, 3])
@@ -22,7 +22,7 @@ def test_xy():
 
 
 def test_rhophi():
-    array = vector._backends.numpy_.VectorNumpy2D(
+    array = vector.backends.numpy.VectorNumpy2D(
         [(0, 10), (1, math.atan2(1, 0)), (5, math.atan2(4, 3))],
         dtype=[("rho", numpy.float64), ("phi", numpy.float64)],
     )
@@ -33,7 +33,7 @@ def test_rhophi():
 
 
 def test_pickle_vector_numpy_2d():
-    array = vector._backends.numpy_.VectorNumpy2D(
+    array = vector.backends.numpy.VectorNumpy2D(
         [(0, 0), (0, 1), (3, 4)], dtype=[("x", numpy.float64), ("y", numpy.float64)]
     )
 
@@ -45,7 +45,7 @@ def test_pickle_vector_numpy_2d():
 
 
 def test_pickle_momentum_numpy_2d():
-    array = vector._backends.numpy_.MomentumNumpy2D(
+    array = vector.backends.numpy.MomentumNumpy2D(
         [(0, 0), (0, 1), (3, 4)], dtype=[("rho", numpy.float64), ("phi", numpy.float64)]
     )
 
@@ -57,7 +57,7 @@ def test_pickle_momentum_numpy_2d():
 
 
 def test_pickle_vector_numpy_3d():
-    array = vector._backends.numpy_.VectorNumpy3D(
+    array = vector.backends.numpy.VectorNumpy3D(
         [(0, 0, 0), (0, 1, 1), (3, 4, 5)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -71,7 +71,7 @@ def test_pickle_vector_numpy_3d():
 
 
 def test_pickle_momentum_numpy_3d():
-    array = vector._backends.numpy_.MomentumNumpy3D(
+    array = vector.backends.numpy.MomentumNumpy3D(
         [(0, 0, 0), (0, 1, 1), (3, 4, 5)],
         dtype=[
             ("rho", numpy.float64),
@@ -89,7 +89,7 @@ def test_pickle_momentum_numpy_3d():
 
 
 def test_pickle_vector_numpy_4d():
-    array = vector._backends.numpy_.VectorNumpy4D(
+    array = vector.backends.numpy.VectorNumpy4D(
         [(0, 0, 0, 0), (0, 1, 1, 1), (3, 4, 5, 6)],
         dtype=[
             ("x", numpy.float64),
@@ -109,7 +109,7 @@ def test_pickle_vector_numpy_4d():
 
 
 def test_pickle_momentum_numpy_4d():
-    array = vector._backends.numpy_.MomentumNumpy4D(
+    array = vector.backends.numpy.MomentumNumpy4D(
         [(0, 0, 0, 0), (0, 1, 1, 1), (3, 4, 5, 6)],
         dtype=[
             ("rho", numpy.float64),
diff --git a/tests/compute/lorentz/test_Et.py b/tests/compute/lorentz/test_Et.py
index 512558f..4a87719 100644
--- a/tests/compute/lorentz/test_Et.py
+++ b/tests/compute/lorentz/test_Et.py
@@ -7,112 +7,112 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et == pytest.approx(math.sqrt(80))
diff --git a/tests/compute/lorentz/test_Et2.py b/tests/compute/lorentz/test_Et2.py
index c09b906..36d2125 100644
--- a/tests/compute/lorentz/test_Et2.py
+++ b/tests/compute/lorentz/test_Et2.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Et2 == pytest.approx(80)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Et2 == pytest.approx(80)
diff --git a/tests/compute/lorentz/test_Mt.py b/tests/compute/lorentz/test_Mt.py
index 7fbf2d2..8730f0a 100644
--- a/tests/compute/lorentz/test_Mt.py
+++ b/tests/compute/lorentz/test_Mt.py
@@ -7,112 +7,112 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt == pytest.approx(math.sqrt(300))
diff --git a/tests/compute/lorentz/test_Mt2.py b/tests/compute/lorentz/test_Mt2.py
index 23d171b..7cef75e 100644
--- a/tests/compute/lorentz/test_Mt2.py
+++ b/tests/compute/lorentz/test_Mt2.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.Mt2 == pytest.approx(300)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.Mt2 == pytest.approx(300)
diff --git a/tests/compute/lorentz/test_beta.py b/tests/compute/lorentz/test_beta.py
index 92f483e..ca7f1a9 100644
--- a/tests/compute/lorentz/test_beta.py
+++ b/tests/compute/lorentz/test_beta.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.beta == pytest.approx(0.5590169943749475)
diff --git a/tests/compute/lorentz/test_boostX_beta.py b/tests/compute/lorentz/test_boostX_beta.py
index 5d8303f..2fe1694 100644
--- a/tests/compute/lorentz/test_boostX_beta.py
+++ b/tests/compute/lorentz/test_boostX_beta.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 2),
-        vector._backends.object_.LongitudinalObjectZ(1),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 2),
+        vector.backends.object.LongitudinalObjectZ(1),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostX(beta=-0.9428090415820634)
     assert out.x == pytest.approx(-2.313708498984761)
diff --git a/tests/compute/lorentz/test_boostX_gamma.py b/tests/compute/lorentz/test_boostX_gamma.py
index a64b2b3..2f08b95 100644
--- a/tests/compute/lorentz/test_boostX_gamma.py
+++ b/tests/compute/lorentz/test_boostX_gamma.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 2),
-        vector._backends.object_.LongitudinalObjectZ(1),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 2),
+        vector.backends.object.LongitudinalObjectZ(1),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostX(gamma=-3)
     assert out.x == pytest.approx(-2.313708498984761)
diff --git a/tests/compute/lorentz/test_boostY_beta.py b/tests/compute/lorentz/test_boostY_beta.py
index b183e9c..6c242fc 100644
--- a/tests/compute/lorentz/test_boostY_beta.py
+++ b/tests/compute/lorentz/test_boostY_beta.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(2, 3),
-        vector._backends.object_.LongitudinalObjectZ(1),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(2, 3),
+        vector.backends.object.LongitudinalObjectZ(1),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostY(beta=-0.9428090415820634)
     assert out.x == pytest.approx(2)
diff --git a/tests/compute/lorentz/test_boostY_gamma.py b/tests/compute/lorentz/test_boostY_gamma.py
index abb9bb3..87766fe 100644
--- a/tests/compute/lorentz/test_boostY_gamma.py
+++ b/tests/compute/lorentz/test_boostY_gamma.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(2, 3),
-        vector._backends.object_.LongitudinalObjectZ(1),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(2, 3),
+        vector.backends.object.LongitudinalObjectZ(1),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostY(gamma=-3)
     assert out.x == pytest.approx(2)
diff --git a/tests/compute/lorentz/test_boostZ_beta.py b/tests/compute/lorentz/test_boostZ_beta.py
index 28c96a5..cc6da9d 100644
--- a/tests/compute/lorentz/test_boostZ_beta.py
+++ b/tests/compute/lorentz/test_boostZ_beta.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostZ(beta=-0.9428090415820634)
     assert out.x == pytest.approx(1)
diff --git a/tests/compute/lorentz/test_boostZ_gamma.py b/tests/compute/lorentz/test_boostZ_gamma.py
index 211f0e5..1f2ad4f 100644
--- a/tests/compute/lorentz/test_boostZ_gamma.py
+++ b/tests/compute/lorentz/test_boostZ_gamma.py
@@ -5,15 +5,15 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.boostZ(gamma=-3)
     assert out.x == pytest.approx(1)
diff --git a/tests/compute/lorentz/test_boost_beta3.py b/tests/compute/lorentz/test_boost_beta3.py
index 3dc4385..243bb3a 100644
--- a/tests/compute/lorentz/test_boost_beta3.py
+++ b/tests/compute/lorentz/test_boost_beta3.py
@@ -5,19 +5,19 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
-    beta = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(5 / 15, 6 / 15),
-        vector._backends.object_.LongitudinalObjectZ(7 / 15),
+    beta = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(5 / 15, 6 / 15),
+        vector.backends.object.LongitudinalObjectZ(7 / 15),
     )
     out = vec.boost_beta3(beta)
     assert out.x == pytest.approx(3.5537720741941676)
diff --git a/tests/compute/lorentz/test_boost_p4.py b/tests/compute/lorentz/test_boost_p4.py
index ae119d0..8106316 100644
--- a/tests/compute/lorentz/test_boost_p4.py
+++ b/tests/compute/lorentz/test_boost_p4.py
@@ -5,20 +5,20 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
-    p4 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(5, 6),
-        vector._backends.object_.LongitudinalObjectZ(7),
-        vector._backends.object_.TemporalObjectT(15),
+    p4 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(5, 6),
+        vector.backends.object.LongitudinalObjectZ(7),
+        vector.backends.object.TemporalObjectT(15),
     )
     out = vec.boost_p4(p4)
     assert out.x == pytest.approx(3.5537720741941676)
diff --git a/tests/compute/lorentz/test_deltaRapidityPhi.py b/tests/compute/lorentz/test_deltaRapidityPhi.py
index fb4c163..19f658c 100644
--- a/tests/compute/lorentz/test_deltaRapidityPhi.py
+++ b/tests/compute/lorentz/test_deltaRapidityPhi.py
@@ -6,20 +6,20 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1.0, 1.0),
-        vector._backends.object_.LongitudinalObjectZ(1.0),
-        vector._backends.object_.TemporalObjectTau(1.0),
+    v1 = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(1.0, 1.0),
+        vector.backends.object.LongitudinalObjectZ(1.0),
+        vector.backends.object.TemporalObjectTau(1.0),
     )
-    v2 = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(-1.0, -1.0),
-        vector._backends.object_.LongitudinalObjectZ(-1.0),
-        vector._backends.object_.TemporalObjectTau(1.0),
+    v2 = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(-1.0, -1.0),
+        vector.backends.object.LongitudinalObjectZ(-1.0),
+        vector.backends.object.TemporalObjectTau(1.0),
     )
     expected_result = numpy.sqrt(
         # phi
@@ -62,7 +62,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(1.0, 1.0, 1.0, 1.0)],
         dtype=[
             ("x", numpy.float64),
@@ -71,7 +71,7 @@ def test_lorentz_numpy():
             ("tau", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(-1.0, -1.0, -1.0, 1.0)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/lorentz/test_deltaRapidityPhi2.py b/tests/compute/lorentz/test_deltaRapidityPhi2.py
index 151174b..dcb8586 100644
--- a/tests/compute/lorentz/test_deltaRapidityPhi2.py
+++ b/tests/compute/lorentz/test_deltaRapidityPhi2.py
@@ -6,20 +6,20 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1.0, 1.0),
-        vector._backends.object_.LongitudinalObjectZ(1.0),
-        vector._backends.object_.TemporalObjectTau(1.0),
+    v1 = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(1.0, 1.0),
+        vector.backends.object.LongitudinalObjectZ(1.0),
+        vector.backends.object.TemporalObjectTau(1.0),
     )
-    v2 = vector._backends.object_.MomentumObject4D(
-        vector._backends.object_.AzimuthalObjectXY(-1.0, -1.0),
-        vector._backends.object_.LongitudinalObjectZ(-1.0),
-        vector._backends.object_.TemporalObjectTau(1.0),
+    v2 = vector.backends.object.MomentumObject4D(
+        vector.backends.object.AzimuthalObjectXY(-1.0, -1.0),
+        vector.backends.object.LongitudinalObjectZ(-1.0),
+        vector.backends.object.TemporalObjectTau(1.0),
     )
     expected_result = (
         # phi
@@ -62,7 +62,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(1.0, 1.0, 1.0, 1.0)],
         dtype=[
             ("x", numpy.float64),
@@ -71,7 +71,7 @@ def test_lorentz_numpy():
             ("tau", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(-1.0, -1.0, -1.0, 1.0)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/lorentz/test_gamma.py b/tests/compute/lorentz/test_gamma.py
index 457606e..65c7914 100644
--- a/tests/compute/lorentz/test_gamma.py
+++ b/tests/compute/lorentz/test_gamma.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.gamma == pytest.approx(1.2060453783110545)
diff --git a/tests/compute/lorentz/test_rapidity.py b/tests/compute/lorentz/test_rapidity.py
index 4be6bc6..5c68dd0 100644
--- a/tests/compute/lorentz/test_rapidity.py
+++ b/tests/compute/lorentz/test_rapidity.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.rapidity == pytest.approx(0.5493061443340549)
diff --git a/tests/compute/lorentz/test_t.py b/tests/compute/lorentz/test_t.py
index d3193b8..66ad8c8 100644
--- a/tests/compute/lorentz/test_t.py
+++ b/tests/compute/lorentz/test_t.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t == pytest.approx(20)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t == pytest.approx(20)
diff --git a/tests/compute/lorentz/test_t2.py b/tests/compute/lorentz/test_t2.py
index 464663f..97ddcb4 100644
--- a/tests/compute/lorentz/test_t2.py
+++ b/tests/compute/lorentz/test_t2.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.t2 == pytest.approx(400)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.t2 == pytest.approx(400)
diff --git a/tests/compute/lorentz/test_tau.py b/tests/compute/lorentz/test_tau.py
index 140d014..0850dab 100644
--- a/tests/compute/lorentz/test_tau.py
+++ b/tests/compute/lorentz/test_tau.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau == pytest.approx(16.583123951777)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau == pytest.approx(16.583123951777)
diff --git a/tests/compute/lorentz/test_tau2.py b/tests/compute/lorentz/test_tau2.py
index aa7d8a4..947e119 100644
--- a/tests/compute/lorentz/test_tau2.py
+++ b/tests/compute/lorentz/test_tau2.py
@@ -5,112 +5,112 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     assert vec.tau2 == pytest.approx(275)
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     assert vec.tau2 == pytest.approx(275)
diff --git a/tests/compute/lorentz/test_to_beta3.py b/tests/compute/lorentz/test_to_beta3.py
index 977f4af..5a7493d 100644
--- a/tests/compute/lorentz/test_to_beta3.py
+++ b/tests/compute/lorentz/test_to_beta3.py
@@ -5,17 +5,17 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -24,13 +24,13 @@ def test_xy_z_t():
 
 
 def test_xy_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -39,13 +39,13 @@ def test_xy_z_tau():
 
 
 def test_xy_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -54,13 +54,13 @@ def test_xy_theta_t():
 
 
 def test_xy_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -69,13 +69,13 @@ def test_xy_theta_tau():
 
 
 def test_xy_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -84,13 +84,13 @@ def test_xy_eta_t():
 
 
 def test_xy_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(3 / 20)
@@ -99,13 +99,13 @@ def test_xy_eta_tau():
 
 
 def test_rhophi_z_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
@@ -114,13 +114,13 @@ def test_rhophi_z_t():
 
 
 def test_rhophi_z_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
@@ -129,13 +129,13 @@ def test_rhophi_z_tau():
 
 
 def test_rhophi_theta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
@@ -144,13 +144,13 @@ def test_rhophi_theta_t():
 
 
 def test_rhophi_theta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
@@ -159,13 +159,13 @@ def test_rhophi_theta_tau():
 
 
 def test_rhophi_eta_t():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectT(20),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectT(20),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
@@ -174,13 +174,13 @@ def test_rhophi_eta_t():
 
 
 def test_rhophi_eta_tau():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
-        vector._backends.object_.TemporalObjectTau(16.583123951777),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
+        vector.backends.object.TemporalObjectTau(16.583123951777),
     )
     out = vec.to_beta3()
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
     assert type(vec.azimuthal) == type(out.azimuthal)  # noqa: E721
     assert type(vec.longitudinal) == type(out.longitudinal)  # noqa: E721
     assert out.x == pytest.approx(5 / 20)
diff --git a/tests/compute/planar/test_deltaphi.py b/tests/compute/planar/test_deltaphi.py
index ecce1e1..2148265 100644
--- a/tests/compute/planar/test_deltaphi.py
+++ b/tests/compute/planar/test_deltaphi.py
@@ -7,44 +7,44 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_xy():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(1, 2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert v1.deltaphi(v2) == pytest.approx(math.atan2(2, 1) - math.atan2(4, 3))
 
 
 def test_xy_rhophi():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(1, 2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(3, 4)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(3, 4)
     )
     assert v1.deltaphi(v2) == pytest.approx(math.atan2(2, 1) - 4)
 
 
 def test_rhophi_xy():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(1, 2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(1, 2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert v1.deltaphi(v2) == pytest.approx(2 - math.atan2(4, 3))
 
 
 def test_rhophi_rhophi():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(1, 2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(1, 2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(3, 4)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(3, 4)
     )
     assert v1.deltaphi(v2) == pytest.approx(2 - 4)
diff --git a/tests/compute/planar/test_phi.py b/tests/compute/planar/test_phi.py
index 6e8a1ad..7a0e78d 100644
--- a/tests/compute/planar/test_phi.py
+++ b/tests/compute/planar/test_phi.py
@@ -7,18 +7,18 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert vec.phi == pytest.approx(math.atan2(4, 3))
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
     )
     assert vec.phi == pytest.approx(math.atan2(4, 3))
diff --git a/tests/compute/planar/test_rho.py b/tests/compute/planar/test_rho.py
index 1ad5ffc..e075d08 100644
--- a/tests/compute/planar/test_rho.py
+++ b/tests/compute/planar/test_rho.py
@@ -7,18 +7,18 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert vec.rho == pytest.approx(5)
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
     )
     assert vec.rho == pytest.approx(5)
diff --git a/tests/compute/planar/test_rho2.py b/tests/compute/planar/test_rho2.py
index b157bdf..52593ff 100644
--- a/tests/compute/planar/test_rho2.py
+++ b/tests/compute/planar/test_rho2.py
@@ -7,18 +7,18 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert vec.rho2 == pytest.approx(25)
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
     )
     assert vec.rho2 == pytest.approx(25)
diff --git a/tests/compute/planar/test_rotateZ.py b/tests/compute/planar/test_rotateZ.py
index a93e8a8..39b8ef1 100644
--- a/tests/compute/planar/test_rotateZ.py
+++ b/tests/compute/planar/test_rotateZ.py
@@ -6,21 +6,21 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(1, 0)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(1, 0)
     )
     assert vec.rotateZ(0.1).x == pytest.approx(0.9950041652780258)
     assert vec.rotateZ(0.1).y == pytest.approx(0.09983341664682815)
 
-    array = vector._backends.numpy_.VectorNumpy2D(
+    array = vector.backends.numpy.VectorNumpy2D(
         [(0, 0), (1, 0), (0, 1)], dtype=[("x", numpy.float64), ("y", numpy.float64)]
     )
-    assert isinstance(array.rotateZ(0.1), vector._backends.numpy_.VectorNumpy2D)
+    assert isinstance(array.rotateZ(0.1), vector.backends.numpy.VectorNumpy2D)
     out = array.rotateZ(0.1)
     assert out.dtype.names == ("x", "y")
     assert numpy.allclose(out.x, [0, 0.9950041652780258, -0.09983341664682815])
@@ -28,16 +28,16 @@ def test_xy():
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(1, 0)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(1, 0)
     )
     assert vec.rotateZ(0.1).rho == pytest.approx(1)
     assert vec.rotateZ(0.1).phi == pytest.approx(0.1)
 
-    array = vector._backends.numpy_.VectorNumpy2D(
+    array = vector.backends.numpy.VectorNumpy2D(
         [(0, 0), (1, 0), (0, 1)], dtype=[("rho", numpy.float64), ("phi", numpy.float64)]
     )
-    assert isinstance(array.rotateZ(0.1), vector._backends.numpy_.VectorNumpy2D)
+    assert isinstance(array.rotateZ(0.1), vector.backends.numpy.VectorNumpy2D)
     out = array.rotateZ(0.1)
     assert out.dtype.names == ("rho", "phi")
     assert numpy.allclose(out.rho, [0, 1, 0])
diff --git a/tests/compute/planar/test_x.py b/tests/compute/planar/test_x.py
index 9cbe9f1..a2bf16d 100644
--- a/tests/compute/planar/test_x.py
+++ b/tests/compute/planar/test_x.py
@@ -7,18 +7,18 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert vec.x == pytest.approx(3)
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
     )
     assert vec.x == pytest.approx(3)
diff --git a/tests/compute/planar/test_y.py b/tests/compute/planar/test_y.py
index ee37f90..819ce77 100644
--- a/tests/compute/planar/test_y.py
+++ b/tests/compute/planar/test_y.py
@@ -7,18 +7,18 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
     assert vec.y == pytest.approx(4)
 
 
 def test_rhophi():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, math.atan2(4, 3))
     )
     assert vec.y == pytest.approx(4)
diff --git a/tests/compute/spatial/test_costheta.py b/tests/compute/spatial/test_costheta.py
index f082139..2476e5d 100644
--- a/tests/compute/spatial/test_costheta.py
+++ b/tests/compute/spatial/test_costheta.py
@@ -7,52 +7,52 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.costheta == pytest.approx(math.cos(0.4636476090008061))
diff --git a/tests/compute/spatial/test_cottheta.py b/tests/compute/spatial/test_cottheta.py
index 4b37383..88cc45f 100644
--- a/tests/compute/spatial/test_cottheta.py
+++ b/tests/compute/spatial/test_cottheta.py
@@ -7,52 +7,52 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.cottheta == pytest.approx(1 / math.tan(0.4636476090008061))
diff --git a/tests/compute/spatial/test_cross.py b/tests/compute/spatial/test_cross.py
index 3b41813..413f7d1 100644
--- a/tests/compute/spatial/test_cross.py
+++ b/tests/compute/spatial/test_cross.py
@@ -6,23 +6,23 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     out = v1.cross(v2)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
     for t1 in "xyz", "xytheta", "xyeta", "rhophiz", "rhophitheta", "rhophieta":
@@ -32,25 +32,25 @@ def test_spatial_object():
                 getattr(v2, "to_" + t2)(),
             )
             out = transformed1.cross(transformed2)
-            assert isinstance(out, vector._backends.object_.VectorObject3D)
-            assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.VectorObject3D)
+            assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
             assert isinstance(
-                out.longitudinal, vector._backends.object_.LongitudinalObjectZ
+                out.longitudinal, vector.backends.object.LongitudinalObjectZ
             )
             assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
     out = v1.cross(v2)
-    assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
     assert out.dtype.names == ("x", "y", "z")
     assert (out[0].x, out[0].y, out[0].z) == pytest.approx((-0.03, 0.06, -0.03))
 
@@ -61,26 +61,26 @@ def test_spatial_numpy():
                 getattr(v2, "to_" + t2)(),
             )
             out = transformed1.cross(transformed2)
-            assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
             assert out.dtype.names == ("x", "y", "z")
             assert (out[0].x, out[0].y, out[0].z) == pytest.approx((-0.03, 0.06, -0.03))
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     out = v1.cross(v2)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
     for t1 in (
@@ -116,16 +116,16 @@ def test_lorentz_object():
                 getattr(v2, "to_" + t2)(),
             )
             out = transformed1.cross(transformed2)
-            assert isinstance(out, vector._backends.object_.VectorObject3D)
-            assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.VectorObject3D)
+            assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
             assert isinstance(
-                out.longitudinal, vector._backends.object_.LongitudinalObjectZ
+                out.longitudinal, vector.backends.object.LongitudinalObjectZ
             )
             assert (out.x, out.y, out.z) == pytest.approx((-0.03, 0.06, -0.03))
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -134,7 +134,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -144,7 +144,7 @@ def test_lorentz_numpy():
         ],
     )
     out = v1.cross(v2)
-    assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
     assert out.dtype.names == ("x", "y", "z")
     assert out.tolist() == pytest.approx([(-0.03, 0.06, -0.030000000000000013)])
 
@@ -181,6 +181,6 @@ def test_lorentz_numpy():
                 getattr(v2, "to_" + t2)(),
             )
             out = transformed1.cross(transformed2)
-            assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
             assert out.dtype.names == ("x", "y", "z")
             assert (out[0].x, out[0].y, out[0].z) == pytest.approx((-0.03, 0.06, -0.03))
diff --git a/tests/compute/spatial/test_deltaR.py b/tests/compute/spatial/test_deltaR.py
index 364e2aa..b0a54d4 100644
--- a/tests/compute/spatial/test_deltaR.py
+++ b/tests/compute/spatial/test_deltaR.py
@@ -8,18 +8,18 @@ import math
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     assert v1.deltaR(v2) == pytest.approx(math.sqrt(0.116083865330319))
 
@@ -35,11 +35,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -55,15 +55,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     assert v1.deltaR(v2) == pytest.approx(math.sqrt(0.116083865330319))
 
@@ -100,7 +100,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -109,7 +109,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_deltaR2.py b/tests/compute/spatial/test_deltaR2.py
index 917d853..c13fa61 100644
--- a/tests/compute/spatial/test_deltaR2.py
+++ b/tests/compute/spatial/test_deltaR2.py
@@ -6,18 +6,18 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     assert v1.deltaR2(v2) == pytest.approx(0.116083865330319)
 
@@ -33,11 +33,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -53,15 +53,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     assert v1.deltaR2(v2) == pytest.approx(0.116083865330319)
 
@@ -98,7 +98,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -107,7 +107,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_deltaangle.py b/tests/compute/spatial/test_deltaangle.py
index f4cd2b5..655e250 100644
--- a/tests/compute/spatial/test_deltaangle.py
+++ b/tests/compute/spatial/test_deltaangle.py
@@ -6,18 +6,18 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     assert v1.deltaangle(v2) == pytest.approx(0.225726)
 
@@ -31,11 +31,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -51,15 +51,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     assert v1.deltaangle(v2) == pytest.approx(0.225726)
 
@@ -96,7 +96,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -105,7 +105,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_deltaeta.py b/tests/compute/spatial/test_deltaeta.py
index 86807c1..e0f609a 100644
--- a/tests/compute/spatial/test_deltaeta.py
+++ b/tests/compute/spatial/test_deltaeta.py
@@ -6,18 +6,18 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     assert v1.deltaeta(v2) == pytest.approx(0.2674387219518324)
 
@@ -33,11 +33,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -53,15 +53,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     assert v1.deltaeta(v2) == pytest.approx(0.2674387219518324)
 
@@ -98,7 +98,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -107,7 +107,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_eta.py b/tests/compute/spatial/test_eta.py
index 74305b0..3994fc9 100644
--- a/tests/compute/spatial/test_eta.py
+++ b/tests/compute/spatial/test_eta.py
@@ -5,52 +5,52 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.eta == pytest.approx(1.4436354751788103)
diff --git a/tests/compute/spatial/test_mag.py b/tests/compute/spatial/test_mag.py
index 78d0552..0f4f8cb 100644
--- a/tests/compute/spatial/test_mag.py
+++ b/tests/compute/spatial/test_mag.py
@@ -7,52 +7,52 @@ import math
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.mag == pytest.approx(math.sqrt(125))
diff --git a/tests/compute/spatial/test_mag2.py b/tests/compute/spatial/test_mag2.py
index c59d4f7..e1f4570 100644
--- a/tests/compute/spatial/test_mag2.py
+++ b/tests/compute/spatial/test_mag2.py
@@ -5,52 +5,52 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.mag2 == pytest.approx(125)
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.mag2 == pytest.approx(125)
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.mag2 == pytest.approx(125)
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.mag2 == pytest.approx(125)
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.mag2 == pytest.approx(125)
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.mag2 == pytest.approx(125)
diff --git a/tests/compute/spatial/test_rotateX.py b/tests/compute/spatial/test_rotateX.py
index 3b3c0fd..e192eac 100644
--- a/tests/compute/spatial/test_rotateX.py
+++ b/tests/compute/spatial/test_rotateX.py
@@ -6,15 +6,15 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
 import vector._methods
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     out = vec.rotateX(0.25)
     assert isinstance(out.azimuthal, vector._methods.AzimuthalXY)
@@ -33,7 +33,7 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    vec = vector._backends.numpy_.VectorNumpy3D(
+    vec = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -54,10 +54,10 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
     out = vec.rotateX(0.25)
     assert isinstance(out.azimuthal, vector._methods.AzimuthalXY)
@@ -91,7 +91,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    vec = vector._backends.numpy_.VectorNumpy4D(
+    vec = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_rotateY.py b/tests/compute/spatial/test_rotateY.py
index e09b7f0..ec589a9 100644
--- a/tests/compute/spatial/test_rotateY.py
+++ b/tests/compute/spatial/test_rotateY.py
@@ -6,15 +6,15 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
 import vector._methods
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     out = vec.rotateY(0.25)
     assert isinstance(out.azimuthal, vector._methods.AzimuthalXY)
@@ -33,7 +33,7 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    vec = vector._backends.numpy_.VectorNumpy3D(
+    vec = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -54,10 +54,10 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
     out = vec.rotateY(0.25)
     assert isinstance(out.azimuthal, vector._methods.AzimuthalXY)
@@ -91,7 +91,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    vec = vector._backends.numpy_.VectorNumpy4D(
+    vec = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/spatial/test_rotate_axis.py b/tests/compute/spatial/test_rotate_axis.py
index e14abc0..f471324 100644
--- a/tests/compute/spatial/test_rotate_axis.py
+++ b/tests/compute/spatial/test_rotate_axis.py
@@ -6,23 +6,23 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_spatial_object():
-    axis = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    axis = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     out = vec.rotate_axis(axis, 0.25)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
     assert out.z == pytest.approx(0.5828282027463345)
@@ -34,10 +34,10 @@ def test_spatial_object():
                 getattr(vec, "to_" + t2)(),
             )
             out = tvec.rotate_axis(taxis, 0.25)
-            assert isinstance(out, vector._backends.object_.VectorObject3D)
-            assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.VectorObject3D)
+            assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
             assert isinstance(
-                out.longitudinal, vector._backends.object_.LongitudinalObjectZ
+                out.longitudinal, vector.backends.object.LongitudinalObjectZ
             )
             assert out.x == pytest.approx(0.37483425404335763)
             assert out.y == pytest.approx(0.5383405688588193)
@@ -45,16 +45,16 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    axis = vector._backends.numpy_.VectorNumpy3D(
+    axis = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    vec = vector._backends.numpy_.VectorNumpy3D(
+    vec = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
     out = vec.rotate_axis(axis, 0.25)
-    assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
     assert out.dtype.names == ("x", "y", "z")
     assert out[0].x == pytest.approx(0.37483425404335763)
     assert out[0].y == pytest.approx(0.5383405688588193)
@@ -67,7 +67,7 @@ def test_spatial_numpy():
                 getattr(vec, "to_" + t2)(),
             )
             out = tvec.rotate_axis(taxis, 0.25)
-            assert isinstance(out, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(out, vector.backends.numpy.VectorNumpy3D)
             assert out.dtype.names == ("x", "y", "z")
             assert out[0].x == pytest.approx(0.37483425404335763)
             assert out[0].y == pytest.approx(0.5383405688588193)
@@ -75,20 +75,20 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    axis = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(99),
+    axis = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(99),
     )
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
-        vector._backends.object_.TemporalObjectT(99),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
+        vector.backends.object.TemporalObjectT(99),
     )
     out = vec.rotate_axis(axis, 0.25)
-    assert isinstance(out, vector._backends.object_.VectorObject4D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject4D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert hasattr(out, "temporal")
     assert out.x == pytest.approx(0.37483425404335763)
     assert out.y == pytest.approx(0.5383405688588193)
@@ -127,10 +127,10 @@ def test_lorentz_object():
                 getattr(vec, "to_" + t2)(),
             )
             out = tvec.rotate_axis(taxis, 0.25)
-            assert isinstance(out, vector._backends.object_.VectorObject4D)
-            assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
+            assert isinstance(out, vector.backends.object.VectorObject4D)
+            assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
             assert isinstance(
-                out.longitudinal, vector._backends.object_.LongitudinalObjectZ
+                out.longitudinal, vector.backends.object.LongitudinalObjectZ
             )
             assert hasattr(out, "temporal")
             assert out.x == pytest.approx(0.37483425404335763)
@@ -139,7 +139,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    axis = vector._backends.numpy_.VectorNumpy4D(
+    axis = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -148,7 +148,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    vec = vector._backends.numpy_.VectorNumpy4D(
+    vec = vector.backends.numpy.VectorNumpy4D(
         [(0.4, 0.5, 0.6, 99)],
         dtype=[
             ("x", numpy.float64),
@@ -158,7 +158,7 @@ def test_lorentz_numpy():
         ],
     )
     out = vec.rotate_axis(axis, 0.25)
-    assert isinstance(out, vector._backends.numpy_.VectorNumpy4D)
+    assert isinstance(out, vector.backends.numpy.VectorNumpy4D)
     assert out.dtype.names == ("x", "y", "z", "t")
     assert out[0].x == pytest.approx(0.37483425404335763)
     assert out[0].y == pytest.approx(0.5383405688588193)
@@ -197,7 +197,7 @@ def test_lorentz_numpy():
                 getattr(vec, "to_" + t2)(),
             )
             out = tvec.rotate_axis(taxis, 0.25)
-            assert isinstance(out, vector._backends.numpy_.VectorNumpy4D)
+            assert isinstance(out, vector.backends.numpy.VectorNumpy4D)
             assert out.dtype.names in {
                 ("x", "y", "z", "t"),
                 ("x", "y", "z", "tau"),
diff --git a/tests/compute/spatial/test_rotate_euler.py b/tests/compute/spatial/test_rotate_euler.py
index 9cd4f41..ac85f1e 100644
--- a/tests/compute/spatial/test_rotate_euler.py
+++ b/tests/compute/spatial/test_rotate_euler.py
@@ -5,18 +5,18 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_spatial_object():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     out = vec.rotate_euler(0.1, 0.2, 0.3)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert out.x == pytest.approx(0.5956646364506655)
     assert out.y == pytest.approx(0.409927258162962)
     assert out.z == pytest.approx(0.4971350761081869)
@@ -24,11 +24,9 @@ def test_spatial_object():
     for t in "xyz", "xytheta", "xyeta", "rhophiz", "rhophitheta", "rhophieta":
         tvec = getattr(vec, "to_" + t)()
         out = tvec.rotate_euler(0.1, 0.2, 0.3)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-        assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectZ
-        )
+        assert isinstance(out, vector.backends.object.VectorObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+        assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
         assert out.x == pytest.approx(0.5956646364506655)
         assert out.y == pytest.approx(0.409927258162962)
         assert out.z == pytest.approx(0.4971350761081869)
diff --git a/tests/compute/spatial/test_rotate_quaternion.py b/tests/compute/spatial/test_rotate_quaternion.py
index 8f2e681..0acdee8 100644
--- a/tests/compute/spatial/test_rotate_quaternion.py
+++ b/tests/compute/spatial/test_rotate_quaternion.py
@@ -5,18 +5,18 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_spatial_object():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.5, 0.6),
-        vector._backends.object_.LongitudinalObjectZ(0.7),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.5, 0.6),
+        vector.backends.object.LongitudinalObjectZ(0.7),
     )
     out = vec.rotate_quaternion(0.1, 0.2, 0.3, 0.4)
-    assert isinstance(out, vector._backends.object_.VectorObject3D)
-    assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-    assert isinstance(out.longitudinal, vector._backends.object_.LongitudinalObjectZ)
+    assert isinstance(out, vector.backends.object.VectorObject3D)
+    assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+    assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
     assert out.x == pytest.approx(0.078)
     assert out.y == pytest.approx(0.18)
     assert out.z == pytest.approx(0.246)
@@ -24,11 +24,9 @@ def test_spatial_object():
     for t in "xyz", "xytheta", "xyeta", "rhophiz", "rhophitheta", "rhophieta":
         tvec = getattr(vec, "to_" + t)()
         out = tvec.rotate_quaternion(0.1, 0.2, 0.3, 0.4)
-        assert isinstance(out, vector._backends.object_.VectorObject3D)
-        assert isinstance(out.azimuthal, vector._backends.object_.AzimuthalObjectXY)
-        assert isinstance(
-            out.longitudinal, vector._backends.object_.LongitudinalObjectZ
-        )
+        assert isinstance(out, vector.backends.object.VectorObject3D)
+        assert isinstance(out.azimuthal, vector.backends.object.AzimuthalObjectXY)
+        assert isinstance(out.longitudinal, vector.backends.object.LongitudinalObjectZ)
         assert out.x == pytest.approx(0.078)
         assert out.y == pytest.approx(0.18)
         assert out.z == pytest.approx(0.246)
diff --git a/tests/compute/spatial/test_theta.py b/tests/compute/spatial/test_theta.py
index a9c3824..1913ad9 100644
--- a/tests/compute/spatial/test_theta.py
+++ b/tests/compute/spatial/test_theta.py
@@ -5,52 +5,52 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.theta == pytest.approx(0.4636476090008061)
diff --git a/tests/compute/spatial/test_z.py b/tests/compute/spatial/test_z.py
index cf9c7d0..44bb2a9 100644
--- a/tests/compute/spatial/test_z.py
+++ b/tests/compute/spatial/test_z.py
@@ -5,52 +5,52 @@
 
 import pytest
 
-import vector._backends.object_
+import vector.backends.object
 
 
 def test_xy_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.z == pytest.approx(10)
 
 
 def test_xy_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.z == pytest.approx(10)
 
 
 def test_xy_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.z == pytest.approx(10)
 
 
 def test_rhophi_z():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectZ(10),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectZ(10),
     )
     assert vec.z == pytest.approx(10)
 
 
 def test_rhophi_theta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectTheta(0.4636476090008061),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectTheta(0.4636476090008061),
     )
     assert vec.z == pytest.approx(10)
 
 
 def test_rhophi_eta():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectRhoPhi(5, 0),
-        vector._backends.object_.LongitudinalObjectEta(1.4436354751788103),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectRhoPhi(5, 0),
+        vector.backends.object.LongitudinalObjectEta(1.4436354751788103),
     )
     assert vec.z == pytest.approx(10)
diff --git a/tests/compute/test_add.py b/tests/compute/test_add.py
index 6ac2f26..7983371 100644
--- a/tests/compute/test_add.py
+++ b/tests/compute/test_add.py
@@ -6,16 +6,16 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(5, 12)
     )
     out = v1.add(v2)
     assert out.x == pytest.approx(8)
@@ -33,11 +33,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(3, 4)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(5, 12)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -57,13 +57,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(2),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(2),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12),
-        vector._backends.object_.LongitudinalObjectZ(4),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(5, 12),
+        vector.backends.object.LongitudinalObjectZ(4),
     )
     out = v1.add(v2)
     assert out.x == pytest.approx(8)
@@ -85,11 +85,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(3, 4, 2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(5, 12, 4)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -111,15 +111,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(2),
-        vector._backends.object_.TemporalObjectT(10),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(2),
+        vector.backends.object.TemporalObjectT(10),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12),
-        vector._backends.object_.LongitudinalObjectZ(4),
-        vector._backends.object_.TemporalObjectT(15),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(5, 12),
+        vector.backends.object.LongitudinalObjectZ(4),
+        vector.backends.object.TemporalObjectT(15),
     )
     out = v1.add(v2)
     assert out.x == pytest.approx(8)
@@ -167,7 +167,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(3, 4, 2, 10)],
         dtype=[
             ("x", numpy.float64),
@@ -176,7 +176,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(5, 12, 4, 15)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_conversions.py b/tests/compute/test_conversions.py
index 73801c0..5f7d414 100644
--- a/tests/compute/test_conversions.py
+++ b/tests/compute/test_conversions.py
@@ -5,23 +5,23 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_VectorObject2D():
     v = vector.obj(x=1, y=2)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.VectorObject2D)
+    assert isinstance(tv, vector.backends.object.VectorObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.VectorObject3D)
+    assert isinstance(tv, vector.backends.object.VectorObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(0)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.VectorObject4D)
+    assert isinstance(tv, vector.backends.object.VectorObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(0)
@@ -29,20 +29,20 @@ def test_VectorObject2D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.VectorObject2D)
+        assert isinstance(tv, vector.backends.object.VectorObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.VectorObject3D)
+            assert isinstance(tv, vector.backends.object.VectorObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert getattr(tv, longitudinal) == pytest.approx(0)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.VectorObject4D)
+                assert isinstance(tv, vector.backends.object.VectorObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert getattr(tv, longitudinal) == pytest.approx(0)
@@ -52,16 +52,16 @@ def test_VectorObject2D():
 def test_MomentumObject2D():
     v = vector.obj(px=1, py=2)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+    assert isinstance(tv, vector.backends.object.MomentumObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+    assert isinstance(tv, vector.backends.object.MomentumObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(0)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+    assert isinstance(tv, vector.backends.object.MomentumObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(0)
@@ -69,20 +69,20 @@ def test_MomentumObject2D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+        assert isinstance(tv, vector.backends.object.MomentumObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+            assert isinstance(tv, vector.backends.object.MomentumObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert getattr(tv, longitudinal) == pytest.approx(0)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+                assert isinstance(tv, vector.backends.object.MomentumObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert getattr(tv, longitudinal) == pytest.approx(0)
@@ -92,16 +92,16 @@ def test_MomentumObject2D():
 def test_VectorNumpy2D():
     v = vector.array({"x": [1, 1, 1], "y": [2, 2, 2]})
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(0)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(0)
@@ -109,20 +109,20 @@ def test_VectorNumpy2D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert getattr(tv, longitudinal)[0] == pytest.approx(0)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert getattr(tv, longitudinal)[0] == pytest.approx(0)
@@ -132,16 +132,16 @@ def test_VectorNumpy2D():
 def test_MomentumNumpy2D():
     v = vector.array({"px": [1, 1, 1], "py": [2, 2, 2]})
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(0)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(0)
@@ -149,20 +149,20 @@ def test_MomentumNumpy2D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert getattr(tv, longitudinal)[0] == pytest.approx(0)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert getattr(tv, longitudinal)[0] == pytest.approx(0)
@@ -172,16 +172,16 @@ def test_MomentumNumpy2D():
 def test_VectorObject3D():
     v = vector.obj(x=1, y=2, z=3)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.VectorObject2D)
+    assert isinstance(tv, vector.backends.object.VectorObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.VectorObject3D)
+    assert isinstance(tv, vector.backends.object.VectorObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.VectorObject4D)
+    assert isinstance(tv, vector.backends.object.VectorObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
@@ -189,20 +189,20 @@ def test_VectorObject3D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.VectorObject2D)
+        assert isinstance(tv, vector.backends.object.VectorObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.VectorObject3D)
+            assert isinstance(tv, vector.backends.object.VectorObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert tv.z == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.VectorObject4D)
+                assert isinstance(tv, vector.backends.object.VectorObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert tv.z == pytest.approx(3)
@@ -212,16 +212,16 @@ def test_VectorObject3D():
 def test_MomentumObject3D():
     v = vector.obj(px=1, py=2, pz=3)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+    assert isinstance(tv, vector.backends.object.MomentumObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+    assert isinstance(tv, vector.backends.object.MomentumObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+    assert isinstance(tv, vector.backends.object.MomentumObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
@@ -229,20 +229,20 @@ def test_MomentumObject3D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+        assert isinstance(tv, vector.backends.object.MomentumObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+            assert isinstance(tv, vector.backends.object.MomentumObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert tv.z == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+                assert isinstance(tv, vector.backends.object.MomentumObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert tv.z == pytest.approx(3)
@@ -252,16 +252,16 @@ def test_MomentumObject3D():
 def test_VectorNumpy3D():
     v = vector.array({"x": [1, 1, 1], "y": [2, 2, 2], "z": [3, 3, 3]})
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
@@ -269,20 +269,20 @@ def test_VectorNumpy3D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert tv.z[0] == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert tv.z[0] == pytest.approx(3)
@@ -292,16 +292,16 @@ def test_VectorNumpy3D():
 def test_MomentumNumpy3D():
     v = vector.array({"px": [1, 1, 1], "py": [2, 2, 2], "pz": [3, 3, 3]})
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
@@ -309,20 +309,20 @@ def test_MomentumNumpy3D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert tv.z[0] == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert tv.z[0] == pytest.approx(3)
@@ -332,16 +332,16 @@ def test_MomentumNumpy3D():
 def test_VectorObject4D():
     v = vector.obj(x=1, y=2, z=3, t=4)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.VectorObject2D)
+    assert isinstance(tv, vector.backends.object.VectorObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.VectorObject3D)
+    assert isinstance(tv, vector.backends.object.VectorObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.VectorObject4D)
+    assert isinstance(tv, vector.backends.object.VectorObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
@@ -349,20 +349,20 @@ def test_VectorObject4D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.VectorObject2D)
+        assert isinstance(tv, vector.backends.object.VectorObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.VectorObject3D)
+            assert isinstance(tv, vector.backends.object.VectorObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert tv.z == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.VectorObject4D)
+                assert isinstance(tv, vector.backends.object.VectorObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert tv.z == pytest.approx(3)
@@ -372,16 +372,16 @@ def test_VectorObject4D():
 def test_MomentumObject4D():
     v = vector.obj(px=1, py=2, pz=3, E=4)
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+    assert isinstance(tv, vector.backends.object.MomentumObject2D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+    assert isinstance(tv, vector.backends.object.MomentumObject3D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+    assert isinstance(tv, vector.backends.object.MomentumObject4D)
     assert tv.x == pytest.approx(1)
     assert tv.y == pytest.approx(2)
     assert tv.z == pytest.approx(3)
@@ -389,20 +389,20 @@ def test_MomentumObject4D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.object_.MomentumObject2D)
+        assert isinstance(tv, vector.backends.object.MomentumObject2D)
         assert tv.x == pytest.approx(1)
         assert tv.y == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.object_.MomentumObject3D)
+            assert isinstance(tv, vector.backends.object.MomentumObject3D)
             assert tv.x == pytest.approx(1)
             assert tv.y == pytest.approx(2)
             assert tv.z == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.object_.MomentumObject4D)
+                assert isinstance(tv, vector.backends.object.MomentumObject4D)
                 assert tv.x == pytest.approx(1)
                 assert tv.y == pytest.approx(2)
                 assert tv.z == pytest.approx(3)
@@ -412,16 +412,16 @@ def test_MomentumObject4D():
 def test_VectorNumpy4D():
     v = vector.array({"x": [1, 1, 1], "y": [2, 2, 2], "z": [3, 3, 3], "t": [4, 4, 4]})
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
@@ -429,20 +429,20 @@ def test_VectorNumpy4D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.VectorNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.VectorNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.VectorNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.VectorNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert tv.z[0] == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.VectorNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.VectorNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert tv.z[0] == pytest.approx(3)
@@ -454,16 +454,16 @@ def test_MomentumNumpy4D():
         {"px": [1, 1, 1], "py": [2, 2, 2], "pz": [3, 3, 3], "E": [4, 4, 4]}
     )
     tv = v.to_Vector2D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     tv = v.to_Vector3D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
     tv = v.to_Vector4D()
-    assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+    assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
     assert tv.x[0] == pytest.approx(1)
     assert tv.y[0] == pytest.approx(2)
     assert tv.z[0] == pytest.approx(3)
@@ -471,20 +471,20 @@ def test_MomentumNumpy4D():
 
     for azimuthal in "xy", "rhophi":
         tv = getattr(v, "to_" + azimuthal)()
-        assert isinstance(tv, vector._backends.numpy_.MomentumNumpy2D)
+        assert isinstance(tv, vector.backends.numpy.MomentumNumpy2D)
         assert tv.x[0] == pytest.approx(1)
         assert tv.y[0] == pytest.approx(2)
 
         for longitudinal in "z", "theta", "eta":
             tv = getattr(v, "to_" + azimuthal + longitudinal)()
-            assert isinstance(tv, vector._backends.numpy_.MomentumNumpy3D)
+            assert isinstance(tv, vector.backends.numpy.MomentumNumpy3D)
             assert tv.x[0] == pytest.approx(1)
             assert tv.y[0] == pytest.approx(2)
             assert tv.z[0] == pytest.approx(3)
 
             for temporal in "t", "tau":
                 tv = getattr(v, "to_" + azimuthal + longitudinal + temporal)()
-                assert isinstance(tv, vector._backends.numpy_.MomentumNumpy4D)
+                assert isinstance(tv, vector.backends.numpy.MomentumNumpy4D)
                 assert tv.x[0] == pytest.approx(1)
                 assert tv.y[0] == pytest.approx(2)
                 assert tv.z[0] == pytest.approx(3)
diff --git a/tests/compute/test_dot.py b/tests/compute/test_dot.py
index 36b03e1..e6d729b 100644
--- a/tests/compute/test_dot.py
+++ b/tests/compute/test_dot.py
@@ -6,16 +6,16 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.3, 0.4)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.3, 0.4)
     )
     assert v1.dot(v2) == pytest.approx(0.11)
 
@@ -29,11 +29,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(0.3, 0.4)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -49,13 +49,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.4, 0.5),
-        vector._backends.object_.LongitudinalObjectZ(0.6),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.4, 0.5),
+        vector.backends.object.LongitudinalObjectZ(0.6),
     )
     assert v1.dot(v2) == pytest.approx(0.32)
 
@@ -69,11 +69,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.4, 0.5, 0.6)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -89,15 +89,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.5, 0.6),
-        vector._backends.object_.LongitudinalObjectZ(0.7),
-        vector._backends.object_.TemporalObjectT(0.8),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.5, 0.6),
+        vector.backends.object.LongitudinalObjectZ(0.7),
+        vector.backends.object.TemporalObjectT(0.8),
     )
     assert v1.dot(v2) == pytest.approx(-0.06)
 
@@ -134,7 +134,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
@@ -143,7 +143,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.5, 0.6, 0.7, 0.8)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_equal.py b/tests/compute/test_equal.py
index a3ee39b..4cd888c 100644
--- a/tests/compute/test_equal.py
+++ b/tests/compute/test_equal.py
@@ -5,16 +5,16 @@
 
 import numpy
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
     assert v1.equal(v2)
 
@@ -29,11 +29,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -50,13 +50,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     assert v1.equal(v2)
 
@@ -71,11 +71,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -92,15 +92,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
     assert v1.equal(v2)
 
@@ -138,7 +138,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
@@ -147,7 +147,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_isclose.py b/tests/compute/test_isclose.py
index 00a0221..0092750 100644
--- a/tests/compute/test_isclose.py
+++ b/tests/compute/test_isclose.py
@@ -5,16 +5,16 @@
 
 import numpy
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
     assert v1.isclose(v2)
 
@@ -28,11 +28,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -48,13 +48,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     assert v1.isclose(v2)
 
@@ -70,11 +70,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -90,15 +90,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
     assert v1.isclose(v2)
 
@@ -135,7 +135,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
@@ -144,7 +144,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_not_equal.py b/tests/compute/test_not_equal.py
index 05f751e..911e181 100644
--- a/tests/compute/test_not_equal.py
+++ b/tests/compute/test_not_equal.py
@@ -5,16 +5,16 @@
 
 import numpy
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
     assert not v1.not_equal(v2)
 
@@ -29,11 +29,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -50,13 +50,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     assert not v1.not_equal(v2)
 
@@ -71,11 +71,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -92,15 +92,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
     assert not v1.not_equal(v2)
 
@@ -138,7 +138,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
@@ -147,7 +147,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_scale.py b/tests/compute/test_scale.py
index ce962cb..eeba4f7 100644
--- a/tests/compute/test_scale.py
+++ b/tests/compute/test_scale.py
@@ -5,13 +5,13 @@
 
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_posfactor():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
     )
     out = vec.scale(1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -27,8 +27,8 @@ def test_planar_posfactor():
 
 
 def test_planar_negfactor():
-    vec = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
+    vec = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
     )
     out = vec.scale(-1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -44,9 +44,9 @@ def test_planar_negfactor():
 
 
 def test_spatial_posfactor():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
     )
     out = vec.scale(1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -73,9 +73,9 @@ def test_spatial_posfactor():
 
 
 def test_spatial_negfactor():
-    vec = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
+    vec = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
     )
     out = vec.scale(-1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -102,10 +102,10 @@ def test_spatial_negfactor():
 
 
 def test_lorentz_postime_posfactor():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.scale(1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -142,10 +142,10 @@ def test_lorentz_postime_posfactor():
 
 
 def test_lorentz_postime_negfactor():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(4),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(4),
     )
     out = vec.scale(-1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -194,10 +194,10 @@ def test_lorentz_postime_negfactor():
 
 
 def test_lorentz_negtime_posfactor():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(-1.5),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(-1.5),
     )
     out = vec.scale(1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
@@ -246,10 +246,10 @@ def test_lorentz_negtime_posfactor():
 
 
 def test_lorentz_negtime_negfactor():
-    vec = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(1, 2),
-        vector._backends.object_.LongitudinalObjectZ(3),
-        vector._backends.object_.TemporalObjectT(-1.5),
+    vec = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(1, 2),
+        vector.backends.object.LongitudinalObjectZ(3),
+        vector.backends.object.TemporalObjectT(-1.5),
     )
     out = vec.scale(-1.75)
     assert type(out.azimuthal) == type(vec.azimuthal)  # noqa: E721
diff --git a/tests/compute/test_subtract.py b/tests/compute/test_subtract.py
index 2dbf3dd..f6be8bb 100644
--- a/tests/compute/test_subtract.py
+++ b/tests/compute/test_subtract.py
@@ -6,16 +6,16 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v1 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4)
+    v1 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(3, 4)
     )
-    v2 = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12)
+    v2 = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(5, 12)
     )
     out = v1.subtract(v2)
     assert out.x == pytest.approx(-2)
@@ -33,11 +33,11 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy2D(
+    v1 = vector.backends.numpy.VectorNumpy2D(
         [(3, 4)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy2D(
+    v2 = vector.backends.numpy.VectorNumpy2D(
         [(5, 12)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -57,13 +57,13 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v1 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(2),
+    v1 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(2),
     )
-    v2 = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12),
-        vector._backends.object_.LongitudinalObjectZ(4),
+    v2 = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(5, 12),
+        vector.backends.object.LongitudinalObjectZ(4),
     )
     out = v1.subtract(v2)
     assert out.x == pytest.approx(-2)
@@ -83,11 +83,11 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy3D(
+    v1 = vector.backends.numpy.VectorNumpy3D(
         [(3, 4, 2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
-    v2 = vector._backends.numpy_.VectorNumpy3D(
+    v2 = vector.backends.numpy.VectorNumpy3D(
         [(5, 12, 4)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -109,15 +109,15 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v1 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(3, 4),
-        vector._backends.object_.LongitudinalObjectZ(2),
-        vector._backends.object_.TemporalObjectT(20),
+    v1 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(3, 4),
+        vector.backends.object.LongitudinalObjectZ(2),
+        vector.backends.object.TemporalObjectT(20),
     )
-    v2 = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(5, 12),
-        vector._backends.object_.LongitudinalObjectZ(4),
-        vector._backends.object_.TemporalObjectT(15),
+    v2 = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(5, 12),
+        vector.backends.object.LongitudinalObjectZ(4),
+        vector.backends.object.TemporalObjectT(15),
     )
     out = v1.subtract(v2)
     assert out.x == pytest.approx(-2)
@@ -165,7 +165,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v1 = vector._backends.numpy_.VectorNumpy4D(
+    v1 = vector.backends.numpy.VectorNumpy4D(
         [(3, 4, 2, 20)],
         dtype=[
             ("x", numpy.float64),
@@ -174,7 +174,7 @@ def test_lorentz_numpy():
             ("t", numpy.float64),
         ],
     )
-    v2 = vector._backends.numpy_.VectorNumpy4D(
+    v2 = vector.backends.numpy.VectorNumpy4D(
         [(5, 12, 4, 15)],
         dtype=[
             ("x", numpy.float64),
diff --git a/tests/compute/test_unit.py b/tests/compute/test_unit.py
index 046ea9c..7fb90a3 100644
--- a/tests/compute/test_unit.py
+++ b/tests/compute/test_unit.py
@@ -6,13 +6,13 @@
 import numpy
 import pytest
 
-import vector._backends.numpy_
-import vector._backends.object_
+import vector.backends.numpy
+import vector.backends.object
 
 
 def test_planar_object():
-    v = vector._backends.object_.VectorObject2D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2)
+    v = vector.backends.object.VectorObject2D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2)
     )
     u = v.unit()
     assert type(u) is type(v)  # noqa: E721
@@ -28,7 +28,7 @@ def test_planar_object():
 
 
 def test_planar_numpy():
-    v = vector._backends.numpy_.VectorNumpy2D(
+    v = vector.backends.numpy.VectorNumpy2D(
         [(0.1, 0.2)],
         dtype=[("x", numpy.float64), ("y", numpy.float64)],
     )
@@ -46,9 +46,9 @@ def test_planar_numpy():
 
 
 def test_spatial_object():
-    v = vector._backends.object_.VectorObject3D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
+    v = vector.backends.object.VectorObject3D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
     )
     u = v.unit()
     assert type(u) is type(v)  # noqa: E721
@@ -66,7 +66,7 @@ def test_spatial_object():
 
 
 def test_spatial_numpy():
-    v = vector._backends.numpy_.VectorNumpy3D(
+    v = vector.backends.numpy.VectorNumpy3D(
         [(0.1, 0.2, 0.3)],
         dtype=[("x", numpy.float64), ("y", numpy.float64), ("z", numpy.float64)],
     )
@@ -86,10 +86,10 @@ def test_spatial_numpy():
 
 
 def test_lorentz_object():
-    v = vector._backends.object_.VectorObject4D(
-        vector._backends.object_.AzimuthalObjectXY(0.1, 0.2),
-        vector._backends.object_.LongitudinalObjectZ(0.3),
-        vector._backends.object_.TemporalObjectT(0.4),
+    v = vector.backends.object.VectorObject4D(
+        vector.backends.object.AzimuthalObjectXY(0.1, 0.2),
+        vector.backends.object.LongitudinalObjectZ(0.3),
+        vector.backends.object.TemporalObjectT(0.4),
     )
     u = v.unit()
     assert type(u) is type(v)  # noqa: E721
@@ -122,7 +122,7 @@ def test_lorentz_object():
 
 
 def test_lorentz_numpy():
-    v = vector._backends.numpy_.VectorNumpy4D(
+    v = vector.backends.numpy.VectorNumpy4D(
         [(0.1, 0.2, 0.3, 0.4)],
         dtype=[
             ("x", numpy.float64),