• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• TypeScript
• C++
• Scala
• Blog

• nata-master
  • examples
    • general_workflow.ipynb
  • .pre-commit-config.yaml
  • LICENSE
  • .readthedocs.yml
  • nata
    • utils
      • env.py
      • cached_property.py
      • exceptions.py
      • formatting.py
      • attrs.py
      • backends.py
      • array.py
      • container_tools.py
      • __init__.py
      • zdf.py
    • axes.py
    • plots
      • data.py
      • axes.py
      • plans.py
      • types
        • line.py
        • color.py
        • scatter.py
        • __init__.py
        • base.py
      • __init__.py
      • styles
        • dark.rc
        • light.rc
      • helpers.py
      • figure.py
    • backends
      • osiris
        • __init__.py
        • zdf.py
        • hdf5.py
      • __init__.py
    • plugins
      • plot
        • grid.py
        • __init__.py
        • collection.py
        • particle.py
      • grids
        • fft.py
        • lineout.py
        • __init__.py
      • register.py
      • __init__.py
      • particles
        • filter.py
        • __init__.py
    • containers.py
    • __init__.py
    • types.py
    • comfort.py
  • .flake8
  • README.md
  • tests
    • utils
      • test_formatting.py
      • test_array.py
      • test_backends.py
      • test_attrs.py
      • test_container_tools.py
    • backends
      • test_osiris_backends.py
    • test_types.py
    • test_containers.py
    • strategies.py
    • __init__.py
    • test_comfort.py
    • test_axes.py
    • conftest.py
  • pytest.ini
  • pyproject.toml
  • .gitignore
  • docs
    • intro
      • contribution.rst
      • basic_concepts
        • datasets.rst
        • backends.rst
        • plugins.rst
        • axes.rst
        • array_interface.rst
      • installing.rst
      • basic_concepts.rst
    • Makefile
    • plots
      • intro.rst
      • api
        • types
          • color.rst
          • base.rst
          • line.rst
          • index.rst
          • scatter.rst
        • figure.rst
        • index.rst
        • axes.rst
    • make.bat
    • grids
      • intro.rst
      • api.rst
      • plugins
        • fft.rst
        • lineout.rst
        • index.rst
        • plot.rst
    • particles
      • intro.rst
      • plugins
        • index.rst
        • plot.rst
        • filter.rst
    • index.rst
    • conf.py
    • _static
  • tox.ini

# -*- coding: utf-8 -*-
from typing import Any
from typing import Optional
from typing import TypeVar
from typing import Union

import attr
import numpy as np

T = TypeVar("T")


@attr.s
class _SubDtypeValidator:
    type_: type = attr.ib()

    def __call__(self, instance, attribute, value):
        if not np.issubdtype(type(value), self.type_):
            raise TypeError(
                f"Attribute '{attribute.name}' of {instance.__class__} "
                + f"must be of type {self.type_} not {type(value)}"
            )


def subdtype_of(type_):
    return _SubDtypeValidator(type_)


@attr.s
class _ArrayValidator:
    dtype: Optional[type] = attr.ib(default=None)
    subclass: Optional[type] = attr.ib(default=None)

    def __call__(self, instance, attribute, value):
        if isinstance(value, np.ndarray):
            value_type = value.dtype
        else:
            value_type = type(value)

        if self.dtype is not None and not np.issubdtype(value_type, self.dtype):
            # TODO: add better error message
            raise TypeError(
                f"Attribute '{attribute.name}' of {instance.__class__} "
                + f"must have dtype {self.dtype}"
            )

        if self.subclass is not None and not np.issubclass_(
            type(value), self.subclass
        ):
            # TODO: add better error message
            raise TypeError(
                f"Attribute '{attribute.name}' of {instance.__class__} "
                + f"must be of subclass {self.subclass}"
            )


def array_validator(dtype=None, subclass=None):
    return _ArrayValidator(dtype, subclass)


def have_attr(*args):
    if len(args) == 0:
        return False

    for a in args:
        if not attr.has(a.__class__):
            return False

    return True


def attrib_equality(
    some: T, other: Union[T, Any], props_to_check: Union[str, tuple] = None
):
    # if props_to_check is None, inspect attributes based on attrs and only for
    # some. attributes in other and their equality check is discarded
    # TODO: deep check
    if props_to_check is None:
        for key, attrib in attr.fields_dict(some.__class__).items():
            if attrib.eq:
                if not hasattr(other, attrib.name):
                    return False

                some_attrib = getattr(some, attrib.name)
                other_attrib = getattr(other, attrib.name)
                # check if attributes have attrs themselves and use
                # attrib_equality recursively else use equality
                if have_attr(some_attrib, other_attrib):
                    if not attrib_equality(some_attrib, other_attrib):
                        return False
                else:
                    if some_attrib != other_attrib:
                        return False

        return True
    else:
        if isinstance(props_to_check, str):
            props_to_check = props_to_check.replace(" ", "").split(",")

        for prop in props_to_check:
            if getattr(some, prop) != getattr(other, prop):
                return False
        return True


def is_identifier(instance, attribute, value):
    if not value.isidentifier():
        raise ValueError(
            f"attribute {attribute.name} has an invalid string '{value}'"
        )


def location_exists(instance, attribute, value):
    if not value.exists():
        raise ValueError(f"Path '{value}' does not exist!")