xbarray 0.0.1a13__py3-none-any.whl

xbarray/backends/_implementations/numpy/random.py

@@ -0,0 +1,105 @@
+from typing import Union, Optional, Tuple, Any
+from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
+import numpy as np
+
+__all__ = [
+    "random_number_generator",
+    "random_discrete_uniform",
+    "random_uniform",
+    "random_exponential",
+    "random_normal",
+    "random_geometric",
+    "random_permutation"
+]
+
+def random_number_generator(
+    seed : Optional[int] = None,
+    *,
+    device : Optional[DEVICE_TYPE] = None
+) -> RNG_TYPE:
+    return np.random.default_rng(seed)
+
+def random_discrete_uniform(
+    shape : Union[int, Tuple[int, ...]], 
+    /,
+    from_num : int, 
+    to_num : int, 
+    *,
+    rng : RNG_TYPE, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.integers(int(from_num), int(to_num), size=shape)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t
+
+def random_uniform(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    rng : RNG_TYPE, 
+    low : float = 0.0, high : float = 1.0,
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.uniform(float(low), float(high), size=shape)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t
+
+def random_exponential(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    rng : RNG_TYPE,  
+    lambd : float = 1.0, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.exponential(1.0 / float(lambd), size=shape)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t
+
+def random_normal(
+    shape: Union[int, Tuple[int, ...]],
+    /,
+    *, 
+    rng : RNG_TYPE,
+    mean : float = 0.0, std : float = 1.0, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[Any] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.normal(mean, std, size=shape)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t
+
+
+def random_geometric(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    p: float, 
+    rng: RNG_TYPE,
+    dtype: Optional[DTYPE_TYPE] = None, 
+    device: Optional[Any] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.geometric(p, size=shape)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t
+
+def random_permutation(
+    n : int,
+    /,
+    *,
+    rng: RNG_TYPE,
+    dtype: Optional[DTYPE_TYPE] = None,
+    device: Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = rng.permutation(n)
+    if dtype is not None:
+        t = t.astype(dtype)
+    return rng, t

xbarray/backends/_implementations/pytorch/__init__.py

@@ -0,0 +1,26 @@
+from array_api_compat.torch import *
+from array_api_compat.torch import __array_api_version__, __array_namespace_info__
+from array_api_compat.common._helpers import *
+
+simplified_name = "pytorch"
+
+from array_api_compat import torch as compat_module
+
+# Import and bind all functions from array_api_extra before exposing them
+import array_api_extra
+from functools import partial
+for api_name in dir(array_api_extra):
+    if api_name.startswith('_'):
+        continue
+
+    if api_name in ['at', 'broadcast_shapes']:
+        globals()[api_name] = getattr(array_api_extra, api_name)
+    else:
+        globals()[api_name] = partial(
+            getattr(array_api_extra, api_name),
+            xp=compat_module
+        )
+
+from ._typing import *
+from ._extra import *
+__import__(__package__ + ".random")

xbarray/backends/_implementations/pytorch/_extra.py

@@ -0,0 +1,135 @@
+from typing import Any, Union, Optional
+import numpy as np
+import torch
+from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
+from xbarray.backends.base import ComputeBackend, SupportsDLPack
+
+PYTORCH_DTYPE_CAST_MAP = {
+    torch.uint16: torch.int16,
+    torch.uint32: torch.int32,
+    torch.uint64: torch.int64,
+    torch.float8_e4m3fn: torch.float16,
+    torch.float8_e5m2: torch.float16,
+}
+
+__all__ = [
+    "default_integer_dtype",
+    "default_index_dtype",
+    "default_floating_dtype",
+    "default_boolean_dtype",
+    "serialize_device",
+    "deserialize_device",
+    "is_backendarray",
+    "from_numpy",
+    "from_other_backend",
+    "to_numpy",
+    "to_dlpack",
+    "dtype_is_real_integer",
+    "dtype_is_real_floating",
+    "dtype_is_boolean",
+    "abbreviate_array",
+    "map_fn_over_arrays",
+    "pad_dim",
+]
+
+default_integer_dtype = torch.int32
+default_index_dtype = torch.long
+default_floating_dtype = torch.float32
+default_boolean_dtype = torch.bool
+
+def serialize_device(device : Optional[DEVICE_TYPE]) -> Optional[str]:
+    if device is None:
+        return None
+    if isinstance(device, str):
+        return device
+    assert isinstance(device, torch.device)
+    return f"{device.type}:{device.index if device.index is not None else 0}"
+
+def deserialize_device(device_str : Optional[str]) -> Optional[DEVICE_TYPE]:
+    if device_str is None:
+        return None
+    if ":" in device_str:
+        device_type, index_str = device_str.split(":")
+        index = int(index_str)
+        return torch.device(device_type, index)
+    else:
+        return torch.device(device_str)
+
+def is_backendarray(data : Any) -> bool:
+    return isinstance(data, torch.Tensor)
+
+def from_numpy(
+    data : np.ndarray,
+    /,
+    *,
+    dtype : Optional[DTYPE_TYPE] = None,
+    device : Optional[DEVICE_TYPE] = None
+) -> ARRAY_TYPE:
+    t = torch.from_numpy(data)
+    target_dtype = dtype if dtype is not None else PYTORCH_DTYPE_CAST_MAP.get(t.dtype, t.dtype)
+    if target_dtype is not None or device is not None:
+        t = t.to(device=device, dtype=target_dtype)
+    return t
+
+def from_other_backend(
+    other_backend: ComputeBackend,
+    data: Any,
+    /,
+) -> ARRAY_TYPE:
+    dat_dlpack = other_backend.to_dlpack(data)
+    return torch.from_dlpack(dat_dlpack)
+
+def to_numpy(
+    data : ARRAY_TYPE
+) -> np.ndarray:
+    # Torch bfloat16 is not supported by numpy
+    if data.dtype == torch.bfloat16:
+        data = data.to(torch.float32)
+    return data.cpu().numpy()
+
+def to_dlpack(
+    data: ARRAY_TYPE,
+    /,
+) -> SupportsDLPack:
+    return data
+
+def dtype_is_real_integer(
+    dtype: DTYPE_TYPE
+) -> bool:
+    # https://pytorch.org/docs/stable/tensors.html#id12
+    return dtype in [
+        torch.int8, torch.int16, torch.int32, torch.int64,
+        torch.uint8, 
+        torch.int,
+        torch.long
+    ]
+
+def dtype_is_real_floating(
+    dtype: DTYPE_TYPE
+) -> bool:
+    return dtype in [
+        torch.float16, torch.float32, torch.float64, 
+        torch.float, torch.double, 
+        torch.bfloat16
+    ]
+
+def dtype_is_boolean(
+    dtype: DTYPE_TYPE
+) -> bool:
+    return dtype == torch.bool
+
+from .._common.implementations import *
+from array_api_compat import torch as compat_module
+abbreviate_array = get_abbreviate_array_function(
+    compat_module, 
+    default_integer_dtype=default_integer_dtype, 
+    func_dtype_is_real_floating=dtype_is_real_floating,
+    func_dtype_is_real_integer=dtype_is_real_integer,
+    func_dtype_is_boolean=dtype_is_boolean
+)
+map_fn_over_arrays = get_map_fn_over_arrays_function(
+    is_backendarray=is_backendarray,
+)
+pad_dim = get_pad_dim_function(
+    backend=compat_module,
+)

xbarray/backends/_implementations/pytorch/_typing.py

@@ -0,0 +1,13 @@
+import torch
+
+__all__ = [
+    'ARRAY_TYPE',
+    'DTYPE_TYPE',
+    'DEVICE_TYPE',
+    'RNG_TYPE',
+]
+
+ARRAY_TYPE = torch.Tensor
+DTYPE_TYPE = torch.dtype
+DEVICE_TYPE = torch.device
+RNG_TYPE = torch.Generator

xbarray/backends/_implementations/pytorch/random.py

@@ -0,0 +1,101 @@
+from typing import Union, Optional, Tuple, Any
+from ._typing import ARRAY_TYPE, DTYPE_TYPE, DEVICE_TYPE, RNG_TYPE
+import torch
+
+__all__ = [
+    "random_number_generator",
+    "random_discrete_uniform",
+    "random_uniform",
+    "random_exponential",
+    "random_normal",
+    "random_geometric",
+    "random_permutation"
+]
+
+def random_number_generator(
+    seed : Optional[int] = None,
+    *,
+    device : Optional[DEVICE_TYPE] = None
+) -> RNG_TYPE:
+    rng = torch.Generator(
+        device=device
+    )
+    if seed is not None:
+        rng = rng.manual_seed(seed)
+    return rng
+
+
+def random_discrete_uniform(
+    shape : Union[int, Tuple[int, ...]], 
+    /,
+    from_num : int, 
+    to_num : int, 
+    *,
+    rng : RNG_TYPE, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.randint(int(from_num), int(to_num), shape, generator=rng, dtype=dtype, device=device)
+    return rng, t
+
+def random_uniform(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    rng : RNG_TYPE, 
+    low : float = 0.0, high : float = 1.0,
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.rand(shape, generator=rng, dtype=dtype, device=device)
+    t = t * (high - low) + low
+    return rng, t
+
+def random_exponential(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    rng : RNG_TYPE,  
+    lambd : float = 1.0, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.empty(shape, dtype=dtype, device=device)
+    t = t.exponential_(lambd, generator=rng)
+    return rng, t
+
+def random_normal(
+    shape: Union[int, Tuple[int, ...]],
+    /,
+    *, 
+    rng : RNG_TYPE,
+    mean : float = 0.0, std : float = 1.0, 
+    dtype : Optional[DTYPE_TYPE] = None, 
+    device : Optional[Any] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.normal(mean, std, shape, generator=rng, dtype=dtype, device=device)
+    return rng, t
+
+def random_geometric(
+    shape: Union[int, Tuple[int, ...]], 
+    /,
+    *,
+    p: float, 
+    rng: RNG_TYPE,
+    dtype: Optional[DTYPE_TYPE] = None, 
+    device: Optional[Any] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.empty(shape, dtype=dtype, device=device)
+    t = t.geometric_(p, generator=rng)
+    return rng, t
+
+def random_permutation(
+    n : int,
+    /,
+    *,
+    rng: RNG_TYPE,
+    dtype: Optional[DTYPE_TYPE] = None,
+    device: Optional[DEVICE_TYPE] = None
+) -> Tuple[RNG_TYPE, ARRAY_TYPE]:
+    t = torch.randperm(n, generator=rng, dtype=dtype, device=device)
+    return rng, t

xbarray/backends/base.py

@@ -0,0 +1,218 @@
+from typing import Optional, Generic, TypeVar, Dict, Union, Any, Sequence, SupportsFloat, Tuple, Type, Callable, Mapping, Protocol, Literal
+import abc
+from array_api_typing.typing_extra import *
+import numpy as np
+
+ArrayAPISetIndex = SetIndex
+ArrayAPIGetIndex = GetIndex
+
+__all__ = [
+    "RNGBackend",
+    "ComputeBackend",
+    "BArrayType",
+    "BDeviceType",
+    "BDtypeType",
+    "BRNGType",
+    "SupportsDLPack",
+    "ArrayAPIArray",
+    "ArrayAPIDevice",
+    "ArrayAPIDType",
+    "ArrayAPINamespace",
+    "ArrayAPISetIndex",
+    "ArrayAPIGetIndex",
+]
+
+BArrayType = TypeVar("BArrayType", covariant=True, bound=ArrayAPIArray)
+BDeviceType = TypeVar("BDeviceType", covariant=True, bound=ArrayAPIDevice)
+BDtypeType = TypeVar("BDtypeType", covariant=True, bound=ArrayAPIDType)
+BRNGType = TypeVar("BRNGType", covariant=True)
+class RNGBackend(Protocol[BArrayType, BDeviceType, BDtypeType, BRNGType]):
+    @abc.abstractmethod
+    def random_number_generator(
+        self, 
+        seed : Optional[int] = None, 
+        *,
+        device : Optional[BDeviceType] = None
+    ) -> BRNGType:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def random_discrete_uniform(
+        self, 
+        shape : Union[int, Tuple[int, ...]], 
+        /,
+        from_num : int, 
+        to_num : int,
+        *,
+        rng : BRNGType, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None, 
+    ) -> Tuple[BRNGType, BArrayType]:
+        """
+        Sample from a discrete uniform distribution [from_num, to_num) with shape `shape`.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def random_uniform(
+        self, 
+        shape: Union[int, Tuple[int, ...]], 
+        /,
+        *,
+        rng : BRNGType, 
+        low : float = 0.0, high : float = 1.0, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None,
+    ) -> Tuple[BRNGType, BArrayType]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def random_exponential(
+        self, 
+        shape: Union[int, Tuple[int, ...]], 
+        /,
+        *,
+        rng : BRNGType, 
+        lambd : float = 1.0, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None, 
+    ) -> Tuple[BRNGType, BArrayType]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def random_normal(
+        self, 
+        shape: Union[int, Tuple[int, ...]], 
+        /,
+        *,
+        rng : BRNGType, 
+        mean : float = 0.0, std : float = 1.0, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None,
+    ) -> Tuple[BRNGType, BArrayType]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def random_geometric(
+        self, 
+        shape: Union[int, Tuple[int, ...]], 
+        /,
+        *, 
+        p : float, 
+        rng : BRNGType, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None,
+    ) -> Tuple[BRNGType, BArrayType]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def random_permutation(
+        self, 
+        n : int, 
+        /,
+        *, 
+        rng : BRNGType, 
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None
+    ) -> Tuple[BRNGType, BArrayType]:
+        raise NotImplementedError
+
+class ComputeBackend(ArrayAPINamespace[BArrayType, BDeviceType, BDtypeType], Protocol[BArrayType, BDeviceType, BDtypeType, BRNGType]):
+    simplified_name : Literal['numpy', 'jax', 'pytorch']
+    ARRAY_TYPE : Type[BArrayType]
+    DEVICE_TYPE : Type[BDeviceType]
+    DTYPE_TYPE : Type[BDtypeType]
+    RNG_TYPE : Type[BRNGType]
+    default_integer_dtype : BDtypeType
+    default_index_dtype : BDtypeType
+    default_floating_dtype : BDtypeType
+    default_boolean_dtype : BDtypeType
+    random : RNGBackend[BArrayType, BDeviceType, BDtypeType, BRNGType]
+
+    @abc.abstractmethod
+    def serialize_device(self, device : Optional[BDeviceType]) -> Optional[str]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def deserialize_device(self, device_str : Optional[str]) -> Optional[BDeviceType]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_backendarray(self, data : Any) -> bool:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def from_numpy(
+        self, 
+        data : np.ndarray, 
+        /,
+        *,
+        dtype : Optional[BDtypeType] = None, 
+        device : Optional[BDeviceType] = None
+    ) -> BArrayType:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def from_other_backend(
+        self,
+        other_backend : "ComputeBackend",
+        data : ArrayAPIArray,
+        /
+    ) -> BArrayType:
+        """
+        Convert an array from another backend to this backend.
+        The other backend must be compatible with the ArrayAPI.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def to_numpy(
+        self, 
+        data : BArrayType
+    ) -> np.ndarray:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def to_dlpack(
+        self, 
+        data : BArrayType, 
+        /,
+    ) -> SupportsDLPack:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def dtype_is_real_integer(self, dtype : BDtypeType) -> bool:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def dtype_is_real_floating(self, dtype : BDtypeType) -> bool:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def dtype_is_boolean(self, dtype : BDtypeType) -> bool:
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def abbreviate_array(self, x : BArrayType, try_cast_scalar: bool = True) -> Union[float, int, BArrayType]:
+        """
+        Abbreviates an array to a single element if possible.
+        Or, if some dimensions are the same, abbreviates to a smaller array (but with the same number of dimensions).
+        """
+        raise NotImplementedError
+    
+    @abc.abstractmethod
+    def map_fn_over_arrays(self, data : Any, func : Callable[[BArrayType], BArrayType]) -> Any:
+        """
+        Map a function over arrays in a data structure and produce a new data structure with the same shape.
+        This is useful for applying a function to all arrays in a nested structure.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def pad_dim(self, x : BArrayType, dim : int, target_size : int, value : Union[float, int] = 0) -> BArrayType:
+        """
+        Pad a dimension of an array to a target size with a given value.
+        If the dimension is already the target size, return the original array.
+        If the dimension is larger than the target size, raise an error.
+        """
+        raise NotImplementedError

xbarray/backends/jax.py

@@ -0,0 +1,19 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import jax as jax_impl
+
+class JaxComputeBackend(metaclass=ComputeBackendImplCls[jax_impl.ARRAY_TYPE, jax_impl.DEVICE_TYPE, jax_impl.DTYPE_TYPE, jax_impl.RNG_TYPE]):
+    ARRAY_TYPE = jax_impl.ARRAY_TYPE
+    DTYPE_TYPE = jax_impl.DTYPE_TYPE
+    DEVICE_TYPE = jax_impl.DEVICE_TYPE
+    RNG_TYPE = jax_impl.RNG_TYPE
+
+for name in dir(jax_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        setattr(JaxComputeBackend, name, getattr(jax_impl, name))
+
+__all__ = [
+    'JaxComputeBackend',
+]

xbarray/backends/numpy.py

@@ -0,0 +1,19 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import numpy as numpy_impl
+
+class NumpyComputeBackend(metaclass=ComputeBackendImplCls[numpy_impl.ARRAY_TYPE, numpy_impl.DEVICE_TYPE, numpy_impl.DTYPE_TYPE, numpy_impl.RNG_TYPE]):
+    ARRAY_TYPE = numpy_impl.ARRAY_TYPE
+    DTYPE_TYPE = numpy_impl.DTYPE_TYPE
+    DEVICE_TYPE = numpy_impl.DEVICE_TYPE
+    RNG_TYPE = numpy_impl.RNG_TYPE
+
+for name in dir(numpy_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        setattr(NumpyComputeBackend, name, getattr(numpy_impl, name))
+
+__all__ = [
+    'NumpyComputeBackend',
+]

xbarray/backends/pytorch.py

@@ -0,0 +1,22 @@
+from ._cls_base import ComputeBackendImplCls
+from ._implementations import pytorch as pytorch_impl
+
+class PytorchComputeBackend(metaclass=ComputeBackendImplCls[pytorch_impl.ARRAY_TYPE, pytorch_impl.DEVICE_TYPE, pytorch_impl.DTYPE_TYPE, pytorch_impl.RNG_TYPE]):
+    ARRAY_TYPE = pytorch_impl.ARRAY_TYPE
+    DTYPE_TYPE = pytorch_impl.DTYPE_TYPE
+    DEVICE_TYPE = pytorch_impl.DEVICE_TYPE
+    RNG_TYPE = pytorch_impl.RNG_TYPE
+
+for name in dir(pytorch_impl):
+    if not name.startswith('_') or name in [
+        '__array_namespace_info__',
+        '__array_api_version__',
+    ]:
+        try:
+            setattr(PytorchComputeBackend, name, getattr(pytorch_impl, name))
+        except AttributeError:
+            pass
+
+__all__ = [
+    'PytorchComputeBackend',
+]

xbarray/jax.py

@@ -0,0 +1,4 @@
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.jax` instead.
+"""
+from .backends.jax import *

xbarray/numpy.py

@@ -0,0 +1,4 @@
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.numpy` instead.
+"""
+from .backends.numpy import *

xbarray/pytorch.py

@@ -0,0 +1,4 @@
+""" This file is generated for backward compatibility.
+If you are using xbarray >= 0.0.1a9, please import from `xbarray.backends.pytorch` instead.
+"""
+from .backends.pytorch import *

xbarray/transformations/pointcloud/__init__.py

@@ -0,0 +1 @@
+from .base import *