dropped dependency on attrs

Author: tclose

fileformats/core/converter.py

@@ -1,7 +1,6 @@
 from abc import ABCMeta
 import typing as ty
 import logging
-import attrs
 from .utils import describe_task, matching_source
 from .exceptions import FileFormatsError
 
@@ -11,15 +10,22 @@
 logger = logging.getLogger("fileformats")
 
 
-@attrs.define
 class ConverterWrapper:
     """Wraps a converter task in a workflow so that the in_file and out_file names can
     be mapped onto their standardised names, "in_file" and "out_file" if necessary
     """
 
     task_spec: ty.Callable
-    in_file: ty.Optional[str] = None
-    out_file: ty.Optional[str] = None
+    in_file: ty.Optional[str]
+    out_file: ty.Optional[str]
+
+    def __init__(self, task_spec, in_file, out_file):
+        self.task_spec = task_spec
+        self.in_file = in_file
+        self.out_file = out_file
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.task_spec}, {self.in_file}, {self.out_file})"
 
     def __call__(self, name=None, **kwargs):
         from pydra.engine import Workflow

fileformats/core/field.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import typing as ty
-import attrs
 from .utils import (
     classproperty,
 )
@@ -10,25 +9,36 @@
 from .datatype import DataType
 
 
-@attrs.define(repr=False)
 class Field(DataType):
-    value = attrs.field()
+    """Base class for all field formats"""
 
     type = None
     is_field = True
     primitive = None
+    metadata = None  # Empty metadata dict for duck-typing with file-sets
 
-    def __str__(self):
+    def __init__(self, value):
+        self.value = value
+
+    def __eq__(self, field) -> bool:
+        return (
+            isinstance(field, Field)
+            and self.mime_like == field.mime_like
+            and self.value == field.value
+        )
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __hash__(self) -> int:
+        return hash((self.mime_like, self.value))
+
+    def __str__(self) -> str:
         return str(self.value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.type_name}({str(self)})"
 
-    @property
-    def metadata(self):
-        """Empty metadata dict for duck-typing with file-sets"""
-        return {}
-
     @classproperty
     def all_fields(cls) -> ty.List[ty.Type[Field]]:  # pylint: disable=no-self-argument
         """Iterate over all field formats in fileformats.* namespaces"""

fileformats/core/fileset.py

@@ -13,7 +13,6 @@
 from pathlib import Path
 import hashlib
 import logging
-import attrs
 from .utils import (
     classproperty,
     fspaths_converter,
@@ -50,7 +49,6 @@
 logger = logging.getLogger("fileformats")
 
 
-@attrs.define(repr=False)
 class FileSet(DataType):
     """
     The base class for all format types within the fileformats package. A generic
@@ -67,55 +65,45 @@ class FileSet(DataType):
         extras hook
     """
 
-    fspaths: ty.FrozenSet[Path] = attrs.field(default=None, converter=fspaths_converter)
-    _metadata: ty.Optional[ty.Dict[str, ty.Any]] = attrs.field(
-        default=False,
-        eq=False,
-        order=False,
-    )
-
-    @_metadata.validator
-    def metadata_validator(self, _, val):
-        if val and not isinstance(val, dict):
-            raise TypeError(
-                f"Fileset metadata value needs to be None or dict, not {val} ({self.fspaths})"
-            )
-
-    # Explicitly set the Internet Assigned Numbers Authority (https://iana_mime.org) MIME
-    # type to None for any base classes that should not correspond to a MIME or MIME-like
-    # type.
-    iana_mime = None
-    ext = None
-    alternate_exts = ()
+    # Class attributes
 
     # Store converters registered by @converter decorator that convert to FileSet
     # NB: each class will have its own version of this dictionary
     converters = {}
 
+    # differentiate between Field and other DataType classes
     is_fileset = True
 
-    def __hash__(self):
-        return hash(self.fspaths)
+    # File extensions associated with file format
+    ext = None
+    alternate_exts = ()
 
-    def __repr__(self):
-        return f"{self.type_name}('" + "', '".join(str(p) for p in self.fspaths) + "')"
+    # to be overridden in subclasses
+    # Explicitly set the Internet Assigned Numbers Authority (https://iana_mime.org) MIME
+    # type to None for any base classes that should not correspond to a MIME or MIME-like
+    # type.
+    iana_mime = None
 
-    def __getitem__(self, name):
-        return self.metadata[name]
+    # Member attributes
+    fspaths: ty.FrozenSet[Path]
+    _metadata: ty.Union[ty.Dict[str, ty.Any], bool, None]
 
-    def __attrs_post_init__(self):
-        # Check required properties don't raise errors
-        for prop_name in self.required_properties():
-            getattr(self, prop_name)
-        # Loop through all attributes and find methods marked by CHECK_ANNOTATION
-        for check in self.checks():
-            getattr(self, check)()
+    def __init__(self, fspaths, metadata=False):
+        self._validate_class()
+        self.fspaths = fspaths_converter(fspaths)
+        self._validate_fspaths()
+        self._additional_fspaths()
+        if metadata and not isinstance(metadata, dict):
+            raise TypeError(
+                f"Fileset metadata value needs to be None or dict, not {metadata} ({self})"
+            )
+        self._metadata = metadata
+        self._validate_properties()
 
-    @fspaths.validator
-    def validate_fspaths(self, _, fspaths):
-        if not fspaths:
+    def _validate_fspaths(self):
+        if not self.fspaths:
             raise FileFormatsError(f"No file-system paths provided to {self}")
-        missing = [p for p in fspaths if not p or not p.exists()]
+        missing = [p for p in self.fspaths if not p or not p.exists()]
         if missing:
             missing_str = "\n".join(str(p) for p in missing)
             msg = (
@@ -134,6 +122,36 @@ def validate_fspaths(self, _, fspaths):
                 msg += "\n".join(str(p) for p in parent.iterdir())
             raise FileNotFoundError(msg)
 
+    def _validate_class(self):
+        """Check that the class has been correctly defined"""
+
+    def _additional_fspaths(self):
+        """Additional checks to be performed on the file-system paths provided to the"""
+
+    def _validate_properties(self):
+        # Check required properties don't raise errors
+        for prop_name in self.required_properties():
+            getattr(self, prop_name)
+        # Loop through all attributes and find methods marked by CHECK_ANNOTATION
+        for check in self.checks():
+            getattr(self, check)()
+
+    def __eq__(self, other) -> bool:
+        return (
+            isinstance(other, FileSet)
+            and self.mime_like == other.mime_like
+            and self.fspaths == other.fspaths
+        )
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.mime_like, self.fspaths))
+
+    def __repr__(self) -> str:
+        return f"{self.type_name}('" + "', '".join(str(p) for p in self.fspaths) + "')"
+
     @property
     def parent(self) -> Path:
         "A common parent directory for all the top-level paths in the file-set"
@@ -1558,20 +1576,21 @@ def copy_to(self, *args, **kwargs):
     _formats_by_name = None
 
 
-@attrs.define(slots=False, repr=False)
 class MockMixin:
     """Strips out validation methods of a class, allowing it to be mocked in a way that
     still satisfies type-checking"""
 
     # Mirror fspaths here so we can unset its validator
-    fspaths: ty.FrozenSet[Path] = attrs.field(default=None, converter=fspaths_converter)
+    fspaths: ty.FrozenSet[Path]
+
+    def _additional_fspaths(self):
+        pass  # disable implicit addition of related fspaths
 
-    def __attrs_post_init__(self):
-        pass
+    def _validate_fspaths(self):
+        pass  # disable validation of fspaths
 
-    @fspaths.validator
-    def validate_fspaths(self, _, fspaths):
-        pass
+    def _validate_properties(self):
+        pass  # disable validation of properties
 
     @classproperty
     def type_name(cls):

fileformats/core/hook.py

@@ -3,12 +3,11 @@
 import inspect
 from itertools import zip_longest
 import functools
-import attrs
 import urllib.error
 from .datatype import DataType
 from .converter import ConverterWrapper
 from .exceptions import FormatConversionError, FileFormatsExtrasError
-from .utils import import_extras_module, check_package_exists_on_pypi
+from .utils import import_extras_module, check_package_exists_on_pypi, add_exc_note
 
 
 __all__ = ["required", "check", "converter"]
@@ -79,6 +78,16 @@ def converter(
     # "out"
     from pydra.engine.helpers import make_klass
 
+    try:
+        import attrs
+    except ImportError as e:
+        add_exc_note(
+            e,
+            "To use the 'converter' decorator you need to have the 'attrs' package "
+            "installed, this should be installed with Pydra by default",
+        )
+        raise e
+
     def decorator(task_spec):
         out_file_local = out_file
         if source_format is None or target_format is None:

fileformats/core/mixin.py

@@ -110,31 +110,21 @@ class WithAdjacentFiles:
     different extensions
 
     Note that WithAdjacentFiles must come before the primary type in the method-resolution
-    order of the class so it can override the '__attrs_post_init__' method in
-    post_init_super class (typically FileSet), e.g.
+    order of the class so it can override the '_additional_paths' method in
 
         class MyFileFormatWithSeparateHeader(WithSeparateHeader, MyFileFormat):
 
             header_type = MyHeaderType
-
-    Class Attrs
-    -----------
-    post_init_super : type
-        the format class the WithAdjacentFiles mixin is mixed with that defines the
-        __attrs_post_init__ method that should be called once the adjacent files
-        are added to the self.fspaths attribute to run checks.
     """
 
-    post_init_super = FileSet
     fspaths: ty.FrozenSet[Path]
 
-    def __attrs_post_init__(self):
+    def _additional_fspaths(self):
         if len(self.fspaths) == 1:
             self.fspaths |= self.get_adjacent_files()
             trim = True
         else:
             trim = False
-        self.post_init_super.__attrs_post_init__(self)
         if trim:
             self.trim_paths()
 
@@ -285,7 +275,7 @@ def my_func(file: MyFormatWithClassifiers[Integer]):
     ordered_classifiers = False
     generically_classifies = False
 
-    def __attrs_pre_init__(self):
+    def _validate_class(self):
         if self.wildcard_classifiers():
             raise FileFormatsError(
                 f"Can instantiate {type(self)} class as it has wildcard classifiers "

pyproject.toml

@@ -8,7 +8,6 @@ description = "Classes for representing different file formats in Python classes
 readme = "README.rst"
 requires-python = ">=3.8"
 dependencies = [
-    "attrs>=22.1.0",
     "typing_extensions >=4.6.3; python_version < '3.11'"
 ]
 license = {file = "LICENSE"}