diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 2bcce81..ba45b2c 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -12,12 +12,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.9, '3.10', 3.11, 3.12]
+        python-version: [3.9, '3.10', 3.11, 3.12, 3.13, 3.14]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install dependencies
diff --git a/CHANGES.md b/CHANGES.md
index 69991d6..b0abf22 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,17 @@
 # Changes
 
+## 4.0
+
+- Removed dependence on `attrs` and `python-dateutil`.
+- Removed deprecated functionality.
+
+
+### Breaking changes
+
+Due to removing dependence on `attrs`, some previously `attr.s` decorated classes are now simple
+dataclasses. Thus, subclassing them may break or behave differently than before.
+
+
 ## 3.24.4
 
 - Fixed bug introduced by supporting escaped brackets in markdown link labels ...
diff --git a/RELEASING.md b/RELEASING.md
index 546f8df..20b39da 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -13,6 +13,11 @@ tox -r
 ```shell
 flake8 src/clldutils
 ```
+- 
+- Make sure pylint passes with a score of 10:
+```shell
+pylint src/clldutils
+```
 
 - Make sure the docs render:
   ```shell
diff --git a/docs/attrlib.rst b/docs/attrlib.rst
deleted file mode 100644
index 87f8da5..0000000
--- a/docs/attrlib.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Tools to use with the `attrs` package
--------------------------------------
-
-.. automodule:: clldutils.attrlib
-    :members:
-
diff --git a/docs/index.rst b/docs/index.rst
index cbe721a..5db91dc 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -21,7 +21,6 @@ Follow the links below for documentation of the clldutils Python API.
    :caption: Contents:
 
    apilib
-   attrlib
    clilib
    color
    coordinates
diff --git a/pylintrc b/pylintrc
new file mode 100644
index 0000000..2465270
--- /dev/null
+++ b/pylintrc
@@ -0,0 +1,657 @@
+[MAIN]
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Clear in-memory caches upon conclusion of linting. Useful if running pylint
+# in a server-like mode.
+clear-cache-post-run=no
+
+# Load and enable all available extensions. Use --list-extensions to see a list
+# all available extensions.
+#enable-all-extensions=
+
+# In error mode, messages with a category besides ERROR or FATAL are
+# suppressed, and no reports are done by default. Error mode is compatible with
+# disabling specific errors.
+#errors-only=
+
+# Always return a 0 (non-error) status code, even if lint errors are found.
+# This is primarily useful in continuous integration scripts.
+#exit-zero=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=lxml
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Return non-zero exit code if any of these messages/categories are detected,
+# even if score is above --fail-under value. Syntax same as enable. Messages
+# specified are enabled, while categories only check already-enabled messages.
+fail-on=
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=8
+
+# Interpret the stdin as a python script, whose filename needs to be passed as
+# the module_or_package argument.
+#from-stdin=
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=CVS
+
+# Add files or directories matching the regular expressions patterns to the
+# ignore-list. The regex matches against paths and can be in Posix or Windows
+# format. Because '\\' represents the directory delimiter on Windows systems,
+# it can't be used as an escape character.
+ignore-paths=
+
+# Files or directories matching the regular expression patterns are skipped.
+# The regex matches against base names, not paths. The default value ignores
+# Emacs file locks
+ignore-patterns=^\.#
+
+# List of module names for which member attributes should not be checked and
+# will not be imported (useful for modules/projects where namespaces are
+# manipulated during runtime and thus existing member attributes cannot be
+# deduced by static analysis). It supports qualified module names, as well as
+# Unix pattern matching.
+ignored-modules=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use, and will cap the count on Windows to
+# avoid hangs.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Resolve imports to .pyi stubs if available. May reduce no-member messages and
+# increase not-an-iterable messages.
+prefer-stubs=no
+
+# Minimum Python version to use for version dependent checks. Will default to
+# the version used to run pylint.
+py-version=3.12
+
+# Discover python modules and packages in the file system subtree.
+recursive=no
+
+# Add paths to the list of the source roots. Supports globbing patterns. The
+# source root is an absolute path or a path relative to the current working
+# directory used to determine a package namespace for modules located under the
+# source root.
+source-roots=
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# In verbose mode, extra non-checker-related info will be displayed.
+#verbose=
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style. If left empty, argument names will be checked with the set
+# naming style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style. If left empty, attribute names will be checked with the set naming
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style. If left empty, class attribute names will be checked
+# with the set naming style.
+#class-attribute-rgx=
+
+# Naming style matching correct class constant names.
+class-const-naming-style=UPPER_CASE
+
+# Regular expression matching correct class constant names. Overrides class-
+# const-naming-style. If left empty, class constant names will be checked with
+# the set naming style.
+#class-const-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style. If left empty, class names will be checked with the set naming style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style. If left empty, constant names will be checked with the set naming
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style. If left empty, function names will be checked with the set
+# naming style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+           j,
+           k,
+           ex,
+           Run,
+           _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style. If left empty, inline iteration names will be checked
+# with the set naming style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style. If left empty, method names will be checked with the set naming style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style. If left empty, module names will be checked with the set naming style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# Regular expression matching correct parameter specification variable names.
+# If left empty, parameter specification variable names will be checked with
+# the set naming style.
+#paramspec-rgx=
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct type alias names. If left empty, type
+# alias names will be checked with the set naming style.
+#typealias-rgx=
+
+# Regular expression matching correct type variable names. If left empty, type
+# variable names will be checked with the set naming style.
+#typevar-rgx=
+
+# Regular expression matching correct type variable tuple names. If left empty,
+# type variable tuple names will be checked with the set naming style.
+#typevartuple-rgx=
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style. If left empty, variable names will be checked with the set
+# naming style.
+#variable-rgx=
+
+
+[CLASSES]
+
+# Warn about protected attribute access inside special methods
+check-protected-access-in-special-methods=no
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp,
+                      asyncSetUp,
+                      __post_init__
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[DESIGN]
+
+# List of regular expressions of class ancestor names to ignore when counting
+# public methods (see R0903)
+exclude-too-few-public-methods=
+
+# List of qualified class names to ignore when counting class parents (see
+# R0901)
+ignored-parents=
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of positional arguments for function / method.
+max-positional-arguments=5
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when caught.
+overgeneral-exceptions=builtins.BaseException,builtins.Exception
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Maximum number of characters on a single line. Pylint's default of 100 is
+# based on PEP 8's guidance that teams may choose line lengths up to 99
+# characters.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow explicit reexports by alias from a package __init__.
+allow-reexport-from-package=no
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=
+
+# Output a graph (.gv or any supported image format) of external dependencies
+# to the given file (report RP0402 must not be disabled).
+ext-import-graph=
+
+# Output a graph (.gv or any supported image format) of all (i.e. internal and
+# external) dependencies to the given file (report RP0402 must not be
+# disabled).
+import-graph=
+
+# Output a graph (.gv or any supported image format) of internal dependencies
+# to the given file (report RP0402 must not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[LOGGING]
+
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
+# UNDEFINED.
+confidence=HIGH,
+           CONTROL_FLOW,
+           INFERENCE,
+           INFERENCE_FAILURE,
+           UNDEFINED
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then re-enable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+        use-implicit-booleaness-not-comparison-to-string,
+        use-implicit-booleaness-not-comparison-to-zero
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=
+
+
+[METHOD_ARGS]
+
+# List of qualified names (i.e., library.method) which require a timeout
+# parameter e.g. 'requests.api.get,requests.api.post'
+timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
+
+
+[MISCELLANEOUS]
+
+# Whether or not to search for fixme's in docstrings.
+check-fixme-in-docstring=no
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+# Regular expression of note tags to take in consideration.
+notes-rgx=
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit,argparse.parse_error
+
+# Let 'consider-using-join' be raised when the separator to join on would be
+# non-empty (resulting in expected fixes of the type: ``"- " + " -
+# ".join(items)``)
+suggest-join-with-non-empty-separator=yes
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'fatal', 'error', 'warning', 'refactor',
+# 'convention', and 'info' which contain the number of messages in each
+# category, as well as 'statement' which is the total number of statements
+# analyzed. This score is used by the global evaluation report (RP0004).
+evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+msg-template=
+
+# Set the output format. Available formats are: 'text', 'parseable',
+# 'colorized', 'json2' (improved json format), 'json' (old json format), msvs
+# (visual studio) and 'github' (GitHub actions). You can also give a reporter
+# class, e.g. mypackage.mymodule.MyReporterClass.
+#output-format=
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[SIMILARITIES]
+
+# Comments are removed from the similarity computation
+ignore-comments=yes
+
+# Docstrings are removed from the similarity computation
+ignore-docstrings=yes
+
+# Imports are removed from the similarity computation
+ignore-imports=yes
+
+# Signatures are removed from the similarity computation
+ignore-signatures=yes
+
+# Minimum lines number of a similarity.
+min-similarity-lines=6
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. No available dictionaries : You need to install
+# both the python package and the system dependency for enchant to work.
+spelling-dict=
+
+# List of comma separated words that should be considered directives if they
+# appear at the beginning of a comment and should not be checked.
+spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of symbolic message names to ignore for Mixin members.
+ignored-checks-for-mixins=no-member,
+                          not-async-context-manager,
+                          not-context-manager,
+                          attribute-defined-outside-init
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The maximum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# Regex pattern to define which classes are considered mixins.
+mixin-class-rgx=.*[Mm]ixin
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of names allowed to shadow builtins
+allowed-redefined-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
diff --git a/setup.cfg b/setup.cfg
index 273740f..4ecd253 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -19,12 +19,12 @@ classifiers =
     Natural Language :: English
     Operating System :: OS Independent
     Programming Language :: Python :: 3
-    Programming Language :: Python :: 3.8
     Programming Language :: Python :: 3.9
     Programming Language :: Python :: 3.10
     Programming Language :: Python :: 3.11
     Programming Language :: Python :: 3.12
     Programming Language :: Python :: 3.13
+    Programming Language :: Python :: 3.14
     Programming Language :: Python :: Implementation :: CPython
     Programming Language :: Python :: Implementation :: PyPy
     License :: OSI Approved :: Apache Software License
@@ -34,12 +34,10 @@ zip_safe = False
 packages = find:
 package_dir =
     = src
-python_requires = >=3.8
+python_requires = >=3.9
 install_requires =
-    python-dateutil
-    tabulate>=0.7.7
+    prettytable
     colorlog
-    attrs>=18.1.0
     bibtexparser>=2.0.0b4
     pylatexenc
     markdown
@@ -100,7 +98,7 @@ show_missing = true
 skip_covered = True
 
 [tox:tox]
-envlist = py3.8, py39, py310, py311, py312, py313
+envlist = py39, py310, py311, py312, py313, py314
 isolated_build = true
 skip_missing_interpreter = true
 
diff --git a/src/clldutils/__init__.py b/src/clldutils/__init__.py
index eebc3ef..d1d2384 100644
--- a/src/clldutils/__init__.py
+++ b/src/clldutils/__init__.py
@@ -1 +1,4 @@
+"""
+Utilities useful for managing/publishing research data.
+"""
 __version__ = '3.24.5.dev0'
diff --git a/src/clldutils/_compat.py b/src/clldutils/_compat.py
new file mode 100644
index 0000000..c161e75
--- /dev/null
+++ b/src/clldutils/_compat.py
@@ -0,0 +1,26 @@
+"""
+This module collects functionality required to support older python versions.
+"""
+import re
+import sys
+import datetime
+
+
+if (sys.version_info.major, sys.version_info.minor) >= (3, 11):  # pragma: no cover
+    fromisoformat = datetime.datetime.fromisoformat
+else:
+    def fromisoformat(s: str) -> datetime.datetime:  # pragma: no cover
+        """Somewhat hacky backport of the more full-fledged date parsing support in py3.11."""
+        s = s.replace('Z', '+00:00')
+        s = re.sub(r'\.[0-9]+', '', s)
+        return datetime.datetime.fromisoformat(s)
+
+if (sys.version_info.major, sys.version_info.minor) >= (3, 10):  # pragma: no cover
+    def entry_points_select(eps, group):
+        """
+        Staring with Python 3.10, `importlib.metadata.entry_points` returns `EntryPoints`."""
+        return eps.select(group=group)
+else:
+    def entry_points_select(eps, group):  # pragma: no cover
+        """In Python 3.9, `importlib.metadata.entry_points` returns a `dict`."""
+        return eps.get(group, [])
diff --git a/src/clldutils/apilib.py b/src/clldutils/apilib.py
index 62636f8..64be524 100644
--- a/src/clldutils/apilib.py
+++ b/src/clldutils/apilib.py
@@ -2,16 +2,11 @@
 Support for accessing data in a repository with some "known locations" via an `API` object.
 """
 import re
-import json
 import pathlib
 import functools
 import webbrowser
 
-import attr
-
-from clldutils.misc import lazyproperty
 from clldutils.path import git_describe
-from clldutils.attrlib import valid_range
 from clldutils.metadata import Metadata
 from clldutils.jsonlib import load
 
@@ -19,54 +14,14 @@
     r'v(?P<number>(?P<major>[0-9]+)\.(?P<minor>[0-9]+)(\.(?P<patch>[0-9]+))?)$')
 
 
-#
-# Common attributes of data objects
-#
-def latitude():
-    return attr.ib(
-        converter=lambda s: None if s is None or s == '' else float(s),
-        validator=valid_range(-90, 90, nullable=True))
-
-
-def longitude():
-    return attr.ib(
-        converter=lambda s: None if s is None or s == '' else float(s),
-        validator=valid_range(-180, 180, nullable=True))
-
-
-def value_ascsv(v):
-    if v is None:
-        return ''
-    elif isinstance(v, float):
-        return "{0:.5f}".format(v)
-    elif isinstance(v, dict):
-        return json.dumps(v)
-    elif isinstance(v, list):
-        return ';'.join(v)
-    return "{0}".format(v)
-
-
-@attr.s
-class DataObject(object):
-
-    @classmethod
-    def fieldnames(cls):
-        return [f.name for f in attr.fields(cls)]
-
-    def ascsv(self):
-        res = []
-        for f, v in zip(attr.fields(self.__class__), attr.astuple(self)):
-            res.append((f.metadata.get('ascsv') or value_ascsv)(v))
-        return res
-
-
-def assert_release(repos):
+def assert_release(repos) -> str:
+    """Make sure a git repository is checked out to a release tag."""
     match = VERSION_NUMBER_PATTERN.match(git_describe(repos))
     assert match, 'Repository is not checked out to a valid release tag'
     return match.group('number')  # pragma: no cover
 
 
-class API(object):
+class API:
     """
     An API base class to provide programmatic access to data in a git repository.
 
@@ -102,8 +57,7 @@ def __init__(self, repos=None):
 
     def __str__(self):
         name = self.repos.resolve().name if self.repos.exists() else self.repos.name
-        return '<{0} repository {1} at {2}>'.format(
-            name, git_describe(self.repos), self.repos)
+        return f'<{name} repository {git_describe(self.repos)} at {self.repos}>'
 
     def path(self, *comps: str) -> pathlib.Path:
         """
@@ -113,7 +67,7 @@ def path(self, *comps: str) -> pathlib.Path:
         """
         return self.repos.joinpath(*comps)
 
-    @lazyproperty
+    @functools.cached_property
     def dataset_metadata(self) -> Metadata:
         """
         If a repository provides metadata about the dataset curated there as JSON-LD file called
@@ -124,19 +78,20 @@ def dataset_metadata(self) -> Metadata:
         return Metadata.from_jsonld(
             load(mdp) if mdp.exists() else {}, defaults=self.__default_metadata__)
 
-    def assert_release(self):
+    def assert_release(self):  # pylint: disable=C0116
         return assert_release(self.repos)
 
     @property
-    def appdir(self) -> pathlib.Path:
+    def appdir(self) -> pathlib.Path:  # pylint: disable=C0116
         return self.path('app')
 
     @property
-    def appdatadir(self) -> pathlib.Path:
+    def appdatadir(self) -> pathlib.Path:  # pylint: disable=C0116
         return self.appdir.joinpath('data')
 
     @classmethod
     def app_wrapper(cls, func):
+        """Recreate appdata if requested, open app index.html in browser."""
         @functools.wraps(func)
         def wrapper(args):
             if isinstance(args.repos, cls):
diff --git a/src/clldutils/attrlib.py b/src/clldutils/attrlib.py
deleted file mode 100644
index 232a656..0000000
--- a/src/clldutils/attrlib.py
+++ /dev/null
@@ -1,118 +0,0 @@
-"""
-Data curation can profit a lot from a transparent data model and documented structure. This can be
-achieved using the `attrs` library,
-
-- defining core objects of the data as `@attr.s` decorated classes
-- using `attrs` validation and conversion functionality, to observe the principle of locality - \
-  i.e. have data cleanup defined close to the objects, while accessing clean data through the \
-  objects elsewhere in the code base.
-"""
-import re
-import functools
-import collections
-
-import attr
-
-from clldutils.text import PATTERN_TYPE
-from clldutils.misc import deprecated
-
-__all__ = ['asdict', 'valid_range', 'valid_re', 'valid_enum_member', 'cmp_off']
-
-# Avoid deprecation warnings for "cmp=False"
-# See https://www.attrs.org/en/stable/api.html#deprecated-apis
-if getattr(attr, "__version_info__", (0,)) >= (19, 2):
-    cmp_off = {"eq": False}
-else:  # pragma: no cover
-    cmp_off = {"cmp": False}
-
-
-def defaults(cls):
-    res = collections.OrderedDict()
-    for field in attr.fields(cls):
-        default = field.default
-        if isinstance(default, attr.Factory):
-            default = default.factory()
-        res[field.name] = default
-    return res
-
-
-def asdict(obj, omit_defaults=True, omit_private=True):
-    """
-    Enhanced version of `attr.asdict`.
-
-    :param omit_defaults: If `True`, only attribute values which differ from the default will be \
-    added.
-    :param omit_private: If `True`, values of private attributes (i.e. attributes with names \
-    starting with `_`) will not be added.
-
-    .. code-block:: python
-
-        >>> @attr.s
-        ... class Bag:
-        ...     _private = attr.ib()
-        ...     with_default = attr.ib(default=7)
-        ...
-        >>> asdict(Bag('x'))
-        OrderedDict()
-        >>> asdict(Bag('x'), omit_defaults=False, omit_private=False)
-        OrderedDict([('_private', 'x'), ('with_default', 7)])
-        >>> attr.asdict(Bag('x'))
-        {'_private': 'x', 'with_default': 7}
-
-    """
-    defs = defaults(obj.__class__)
-    res = collections.OrderedDict()
-    for field in attr.fields(obj.__class__):
-        if not (omit_private and field.name.startswith('_')):
-            value = getattr(obj, field.name)
-            if not (omit_defaults and value == defs[field.name]):
-                if hasattr(value, 'asdict'):
-                    value = value.asdict(omit_defaults=True)
-                res[field.name] = value
-    return res
-
-
-def _valid_enum_member(choices, instance, attribute, value, nullable=False):
-    if not (nullable and value is None) and value not in choices:
-        raise ValueError('{0} is not a valid {1}'.format(value, attribute.name))
-
-
-def valid_enum_member(choices, nullable=False):
-    """
-    .. deprecated:: 3.9
-        Use `attr.validators.in_` instead.
-    """
-    deprecated('Use `attr.validators.in_` instead.')
-    return functools.partial(_valid_enum_member, choices, nullable=nullable)
-
-
-def _valid_range(min_, max_, instance, attribute, value, nullable=False):
-    if not (nullable and value is None) and (
-            (min_ is not None and value < min_) or (max_ is not None and value > max_)):
-        raise ValueError('{0} is not a valid {1}'.format(value, attribute.name))
-
-
-def valid_range(min_, max_, nullable=False):
-    """
-    A validator that raises a `ValueError` if the provided value that is not in the range defined
-    by `min_` and `max_`.
-    """
-    return functools.partial(_valid_range, min_, max_, nullable=nullable)
-
-
-def _valid_re(regex, instance, attribute, value, nullable=False):
-    if nullable and value is None:
-        return
-    if not isinstance(regex, PATTERN_TYPE):
-        regex = re.compile(regex)
-    if not regex.match(value):
-        raise ValueError('{0} is not a valid {1}'.format(value, attribute.name))
-
-
-def valid_re(regex, nullable=False):
-    """
-    .. deprecated:: 3.9
-        Use `attr.validators.matches_re` instead.
-    """
-    deprecated('Use `attr.validators.matches_re` instead.')
-    return functools.partial(_valid_re, regex, nullable=nullable)
diff --git a/src/clldutils/badge.py b/src/clldutils/badge.py
deleted file mode 100644
index d23f0e1..0000000
--- a/src/clldutils/badge.py
+++ /dev/null
@@ -1,38 +0,0 @@
-"""Badges for inclusion in markdown docs, etc.
-
-.. seealso:: http://shields.io/
-"""
-from urllib.parse import urlencode, quote
-
-__all__ = ['Colors', 'badge']
-
-
-class Colors(object):
-    """
-    Colors available for shields.io badges.
-    """
-    brightgreen = 'brightgreen'
-    green = 'green'
-    yellowgreen = 'yellowgreen'
-    yellow = 'yellow'
-    orange = 'orange'
-    red = 'red'
-    lightgrey = 'lightgrey'
-    blue = 'blue'
-
-
-def badge(subject, status, color, fmt='svg', markdown=True, label=None, **kw) -> str:
-    """
-    URL for (or markdown markup to include) a badge from shields.io
-
-    :param str subject: Text for the left side of the badge
-    :param str status: Text for the right side of the badge
-    :param str color: Color for the right side of the badge
-    :param str fmt: `'svg'` or `'json'`
-    :param bool markdown: If `True`, return a markdown image link, else return a URL
-    :param str|None label: Link label, if `markdown==True`
-    """
-    label = label or ': '.join([subject, status])
-    url = 'https://img.shields.io/badge/{0}-{1}-{2}.{3}{4}'.format(
-        quote(subject), quote(status), color, fmt, '?' + urlencode(kw) if kw else '')
-    return '![{0}]({1} "{0}")'.format(label, url) if markdown else url
diff --git a/src/clldutils/clilib.py b/src/clldutils/clilib.py
index 7d202ea..00e3935 100644
--- a/src/clldutils/clilib.py
+++ b/src/clldutils/clilib.py
@@ -68,133 +68,35 @@ def run(args):
 """
 import csv
 import random
-import typing
+from typing import Optional, Any
 import logging
 import pkgutil
 import pathlib
 import argparse
 import warnings
 import importlib
-import collections
 import importlib.metadata
+import collections
 
-import tabulate
-
-from clldutils.loglib import Logging, get_colorlog
-from clldutils.misc import deprecated
+from clldutils.loglib import get_colorlog
 from clldutils import markup
+from ._compat import entry_points_select
 
 __all__ = [
-    'ParserError', 'Command', 'command', 'ArgumentParser', 'ArgumentParserWithLogging',
+    'ParserError',
     'get_parser_and_subparsers', 'register_subcommands', 'PathType', 'add_format', 'Table',
     'add_csv_field_size_limit', 'add_random_seed', 'confirm',
 ]
 
 
-def get_entrypoints(group):
+def get_entrypoints(group: str) -> list[importlib.metadata.EntryPoint]:
+    """Returns entry points for a group."""
     eps = importlib.metadata.entry_points()
-    return eps.select(group=group) if hasattr(eps, 'select') else eps.get(group, [])
+    return entry_points_select(eps, group=group)
 
 
 class ParserError(Exception):
-    pass
-
-
-# Global registry for commands.
-# Note: This registry is global so it can only be used for one ArgumentParser instance.
-# Otherwise, different ArgumentParsers will share the same sub-commands which will rarely
-# be intended.
-_COMMANDS = []
-
-
-class Command(object):
-    def __init__(self, func, name=None, usage=None):
-        self.func = func
-        self.name = name or func.__name__
-        self.usage = usage
-
-    @property
-    def doc(self):
-        return self.usage or self.func.__doc__
-
-    def __call__(self, args):
-        return self.func(args)
-
-
-def command(name=None, usage=None):
-    def wrap(f):
-        _COMMANDS.append(Command(f, name=name, usage=usage))
-        return f
-    return wrap
-
-
-def _attr(obj, attr):
-    return getattr(obj, attr, getattr(obj, '__{0}__'.format(attr), None))
-
-
-class ArgumentParser(argparse.ArgumentParser):
-    def __init_subclass__(cls, **kwargs):
-        if cls.__name__ != 'ArgumentParserWithLogging':
-            deprecated(
-                '{} inherits from clldutils.clilib.ArgumentParser which is deprecated.'.format(
-                    cls.__name__
-                ))
-        super().__init_subclass__(**kwargs)
-
-    def __init__(self, pkg_name, *commands, **kw):
-        commands = commands or _COMMANDS
-        kw.setdefault(
-            'description', "Main command line interface of the %s package." % pkg_name)
-        kw.setdefault(
-            'epilog', "Use '%(prog)s help <cmd>' to get help about individual commands.")
-        super(ArgumentParser, self).__init__(**kw)
-        self.commands = collections.OrderedDict((_attr(cmd, 'name'), cmd) for cmd in commands)
-        self.pkg_name = pkg_name
-        self.add_argument("--verbosity", help="increase output verbosity")
-        self.add_argument('command', help=' | '.join(self.commands))
-        self.add_argument('args', nargs=argparse.REMAINDER)
-
-    def main(self, args=None, catch_all=False, parsed_args=None):
-        args = parsed_args or self.parse_args(args=args)
-        if args.command == 'help' and len(args.args):
-            # As help text for individual commands we simply re-use the docstrings of the
-            # callables registered for the command:
-            print(_attr(self.commands[args.args[0]], 'doc'))
-        else:
-            if args.command not in self.commands:
-                print('invalid command')
-                self.print_help()
-                return 64
-            try:
-                self.commands[args.command](args)
-            except ParserError as e:
-                print(e)
-                print(_attr(self.commands[args.command], 'doc'))
-                return 64
-            except Exception as e:
-                if catch_all:
-                    print(e)
-                    return 1
-                raise
-        return 0
-
-
-class ArgumentParserWithLogging(ArgumentParser):
-
-    def __init__(self, pkg_name, *commands, **kw):
-        super(ArgumentParserWithLogging, self).__init__(pkg_name, *commands, **kw)
-        self.add_argument('--log', default=get_colorlog(pkg_name), help=argparse.SUPPRESS)
-        self.add_argument(
-            '--log-level',
-            default=logging.INFO,
-            help='log level [ERROR|WARN|INFO|DEBUG]',
-            type=lambda x: getattr(logging, x))
-
-    def main(self, args=None, catch_all=False, parsed_args=None):
-        args = parsed_args or self.parse_args(args=args)
-        with Logging(args.log, level=args.log_level):
-            return super(ArgumentParserWithLogging, self).main(
-                catch_all=catch_all, parsed_args=args)
+    """Exception to signal errors during cli input validation."""
 
 
 def confirm(question: str, default=True) -> bool:
@@ -212,11 +114,11 @@ def confirm(question: str, default=True) -> bool:
 
 
 class Formatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptionHelpFormatter):
-    pass
+    """Help formatter."""
 
 
 def get_parser_and_subparsers(prog: str, with_defaults_help: bool = True, with_log: bool = True)\
-        -> typing.Tuple[argparse.ArgumentParser, typing.Any]:
+        -> tuple[argparse.ArgumentParser, Any]:
     """
     Get an `argparse.ArgumentParser` instance and associated subparsers.
 
@@ -226,7 +128,7 @@ def get_parser_and_subparsers(prog: str, with_defaults_help: bool = True, with_l
     :param with_defaults_help: Whether defaults should be displayed in the help message.
     :param with_log: Whether a global option to select log levels should be available.
     """
-    kw = dict(prog=prog)
+    kw = {'prog': prog}
     if with_defaults_help:
         kw.update(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     parser = argparse.ArgumentParser(**kw)
@@ -258,14 +160,14 @@ def iter_modules(pkg):
                 modname = ".".join([pkg.__name__, name])
                 try:
                     yield name, importlib.import_module(modname)
-                except Exception as e:  # pragma: no cover
-                    warnings.warn('{0} {1}'.format(e, modname))
+                except Exception as e:  # pragma: no cover  # pylint: disable=W0718
+                    warnings.warn(f'{e} {modname}')
 
 
 def register_subcommands(
         subparsers,
         pkg: str,
-        entry_point: typing.Optional[str] = None,
+        entry_point: Optional[str] = None,
         formatter_class: argparse.ArgumentDefaultsHelpFormatter = Formatter,
         skip_invalid: bool = False):
     """
@@ -288,7 +190,7 @@ def register_subcommands(
             try:
                 pkg = ep.load()
             except ImportError:
-                warnings.warn('ImportError loading entry point {0.name}'.format(ep))
+                warnings.warn(f'ImportError loading entry point {ep.name}')
                 continue
             _cmds.update(
                 [('.'.join([ep.name, name]), mod) for name, mod in iter_modules(pkg)])
@@ -298,11 +200,11 @@ def register_subcommands(
         if not mod.__doc__:
             if skip_invalid:
                 continue
-            raise ValueError('Command \"{0}\" is missing a docstring.'.format(name))
+            raise ValueError(f'Command \"{name}\" is missing a docstring.')
         if not getattr(mod, 'run', None):  # pragma: no cover
             if skip_invalid:
                 continue
-            raise ValueError('Command \"{0}\" is missing a run function.'.format(name))
+            raise ValueError(f'Command \"{name}\" is missing a run function.')
 
         valid[name] = mod
         subparser = subparsers.add_parser(
@@ -339,7 +241,7 @@ def register(parser):
     )
 
 
-def add_random_seed(parser, default: typing.Optional[int] = None):
+def add_random_seed(parser, default: Optional[int] = None):
     """
     Command line tools may want to fix Python's `random.seed` to ensure reproducible results.
 
@@ -362,8 +264,12 @@ def add_format(parser, default: str = 'pipe'):
     """
     parser.add_argument(
         "--format",
-        default=default,
-        choices=tabulate.tabulate_formats,
+        default=markup.TableFormat.get(default),
+        type=markup.TableFormat.get,
+        # We can only use choices for validation. For the help message we must "abuse" metavar.
+        # See https://docs.python.org/3/library/argparse.html#choices
+        metavar=f'{{{",".join(e.name for e in markup.TableFormat)}}}',
+        choices=markup.TableFormat,
         help="Format of tabular output.")
 
 
@@ -393,7 +299,7 @@ def __init__(self, args: argparse.Namespace, *cols, **kw):
         super().__init__(*cols, **kw)
 
 
-class PathType(object):
+class PathType:  # pylint: disable=R0903
     """
     A type to parse `pathlib.Path` instances from the command line.
 
@@ -409,15 +315,18 @@ def register(parser):
             def run(args):
                 assert args.input.exists()
     """
-    def __init__(self, must_exist: bool = True, type: typing.Optional[str] = None):
+    def __init__(
+            self,
+            must_exist: bool = True,
+            type: Optional[str] = None):  # pylint: disable=W0622
         assert type in (None, 'dir', 'file')
         self._must_exist = must_exist
         self._type = type
 
-    def __call__(self, string):
+    def __call__(self, string: str):
         p = pathlib.Path(string)
         if self._must_exist and not p.exists():
-            raise argparse.ArgumentTypeError('Path {0} does not exist!'.format(string))
+            raise argparse.ArgumentTypeError(f'Path {string} does not exist!')
         if p.exists() and self._type and not getattr(p, 'is_' + self._type)():
-            raise argparse.ArgumentTypeError('Path {0} is not a {1}!'.format(string, self._type))
+            raise argparse.ArgumentTypeError(f'Path {string} is not a {self._type}!')
         return p
diff --git a/src/clldutils/color.py b/src/clldutils/color.py
index e3750da..87c686d 100644
--- a/src/clldutils/color.py
+++ b/src/clldutils/color.py
@@ -13,10 +13,11 @@
 values - but will use different ways to create the scheme depending on the number of values.
 """
 import math
-import typing
+from typing import Union, Optional
 import colorsys
 import fractions
 import itertools
+from collections.abc import Sequence
 
 __all__ = [
     'diverging_colors',
@@ -27,8 +28,10 @@
     'rgb_as_hex',
 ]
 
+ColorType = Union[str, Sequence[float]]
 
-def _to_rgb(s: typing.Union[str, list, tuple]) -> tuple:
+
+def _to_rgb(s: ColorType) -> tuple:
     def f2i(d):
         assert 0 <= d <= 1
         res = int(math.floor(d * 256))
@@ -41,6 +44,7 @@ def f2i(d):
         if isinstance(s[0], (float, fractions.Fraction)):
             s = [f2i(d) for d in s]
         return s
+
     assert isinstance(s, str)
     if s.startswith('#'):
         s = s[1:]
@@ -50,24 +54,24 @@ def f2i(d):
     return tuple(int(c, 16) for c in [s[i:i + 2] for i in range(0, 6, 2)])
 
 
-def rgb_as_hex(s: typing.Union[str, list, tuple]) -> str:
+def rgb_as_hex(s: ColorType) -> str:
     """
     Convert a RGB triple to a `HEX triplet <https://en.wikipedia.org/wiki/Web_colors#Hex_triplet>`_
     """
-    return '#{0:02X}{1:02X}{2:02X}'.format(*_to_rgb(s))
+    return '#{0:02X}{1:02X}{2:02X}'.format(*_to_rgb(s))  # pylint: disable=C0209
 
 
-def brightness(color: typing.Union[str, list, tuple]) -> float:
+def brightness(color: ColorType) -> float:
     """
     Compute the brightness of a color specified as RGB triple (or Hex triplet).
 
     .. seealso:: `<https://www.w3.org/TR/AERT/#color-contrast>`_
     """
-    R, G, B = _to_rgb(color)
+    R, G, B = _to_rgb(color)  # pylint: disable=invalid-name
     return 0.299 * R + 0.587 * G + 0.114 * B
 
 
-def is_bright(color: typing.Union[str, list, tuple]) -> bool:
+def is_bright(color: ColorType) -> bool:
     """
     Compute whether a color is considered bright or not.
 
@@ -79,7 +83,7 @@ def is_bright(color: typing.Union[str, list, tuple]) -> bool:
     return brightness(color) > 125
 
 
-def qualitative_colors(n: int, set: str = typing.Optional[str]) -> typing.List[str]:
+def qualitative_colors(n: int, set: str = Optional[str]) -> list[str]:  # pylint: disable=W0622
     """
     Choses `n` distinct colors suitable for visualizing categorical variables.
 
@@ -204,7 +208,7 @@ def gethsvs():
         itertools.islice((colorsys.hsv_to_rgb(*x) for x in gethsvs()), n)]
 
 
-def sequential_colors(n):
+def sequential_colors(n: int) -> list[str]:
     """
     Between 3 and 9 sequential colors.
 
@@ -226,7 +230,7 @@ def sequential_colors(n):
     return [cols[ix] for ix in indices[n - 3]]
 
 
-def diverging_colors(n):
+def diverging_colors(n: int) -> list[str]:
     """
     Between 3 and 11 diverging colors
 
diff --git a/src/clldutils/coordinates.py b/src/clldutils/coordinates.py
index a02cf06..4eab950 100644
--- a/src/clldutils/coordinates.py
+++ b/src/clldutils/coordinates.py
@@ -5,50 +5,123 @@
 Language Structures, e.g. (12d10N, 92d49E), to floating point latitude and longitude values.
 """
 import re
+import enum
 import math
+from typing import Union, Optional
+import dataclasses
 
 __all__ = ['Coordinates', 'dec2degminsec', 'degminsec2dec', 'degminsec']
 
-import typing
-
 DEGREES = "°"
 MINUTES = "\u2032"
 SECONDS = "\u2033"
+DimensionType = Union[str, int, float]
+DEGMINSEC_FMT = (r'(?P<deg>\d+)\s*' + DEGREES + r'\s*'
+                 r'((?P<min>\d+)\s*' + MINUTES + r'\s*)?'
+                 r'((?P<sec>[\d.]+)\s*' + SECONDS + r'\s*)?')
 
 PATTERNS = {
     'lat_alnum': re.compile(r"(?P<deg>\d+)d(?P<min>[0-9]+)?(?P<sec>'\d+'')?(?P<hem>S|N)"),
     'lon_alnum': re.compile(r"(?P<deg>\d+)d(?P<min>\d+)?(?P<sec>'\d+'')?(?P<hem>E|W)"),
-    'lat_degminsec': re.compile(
-        r'(?P<deg>\d+)\s*%s\s*((?P<min>\d+)\s*%s\s*)?((?P<sec>[\d.]+)\s*%s\s*)?(?P<hem>S|N)' % (
-            DEGREES, MINUTES, SECONDS)),
-    'lon_degminsec': re.compile(
-        r'(?P<deg>\d+)\s*%s\s*((?P<min>\d+)\s*%s\s*)?((?P<sec>[\d.]+)\s*%s\s*)?(?P<hem>E|W)' % (
-            DEGREES, MINUTES, SECONDS)),
+    'lat_degminsec': re.compile(DEGMINSEC_FMT + r'(?P<hem>S|N)'),
+    'lon_degminsec': re.compile(DEGMINSEC_FMT + r'(?P<hem>E|W)'),
 }
 
 
+class CoordinateFormat(enum.Enum):
+    """Formatting options for coordinates."""
+    alnum = enum.auto()  # pylint: disable=invalid-name
+    ascii = enum.auto()  # pylint: disable=invalid-name
+    degminsec = enum.auto()  # pylint: disable=invalid-name
+
+
+def get_format(what: [str, CoordinateFormat]) -> CoordinateFormat:
+    """Allow retrieving a CoordinateFormat by name."""
+    if isinstance(what, str):
+        return getattr(CoordinateFormat, what)
+    return what
+
+
+CoordinateFormatType = Union[CoordinateFormat, str]
+
+
+@dataclasses.dataclass
+class DegMinSec:
+    """A coordinate datum as triple."""
+    degrees: int
+    minutes: int
+    seconds: float
+
+    @classmethod
+    def from_match(cls, m: re.Match) -> 'DegMinSec':
+        """Use the groups of a pattern as defined in PATTERNS to create an instance."""
+        return cls(int(m.group('deg') or 0), int(m.group('min') or 0), float(m.group('sec') or 0.0))
+
+    def as_string(
+            self,
+            hemisphere: str,
+            format: CoordinateFormatType,  # pylint: disable=redefined-builtin
+    ) -> str:
+        """Format as string."""
+        degrees, minutes, seconds = self.degrees, self.minutes, self.seconds
+        seconds = int(round(seconds))
+        if seconds == 60:
+            minutes += 1
+            seconds = 0
+
+        if 120 > minutes >= 60:  # pragma: no cover
+            # This case cannot really happen, because we only ever feed the results of
+            # dec2degminsec into this method.
+            degrees += 1
+            minutes -= 60
+
+        format = get_format(format)
+        if format == CoordinateFormat.alnum:
+            res = f"{degrees}d"
+            if minutes:
+                res += f"{minutes:02}"
+            res += hemisphere
+            return res
+
+        if format == CoordinateFormat.ascii:
+            res = f"{degrees}°"
+            if minutes:
+                res += f"{minutes:0>2d}'"
+            if seconds:
+                res += f'{seconds:0>2f}"'
+            res += hemisphere
+            return res
+
+        res = f"{degrees}{DEGREES}"
+
+        if minutes:
+            res += f" {minutes}{MINUTES}"
+
+        if seconds:
+            res += f" {seconds}{SECONDS}"
+        res += f" {hemisphere}"
+        return res
+
+
 def degminsec(dec, hemispheres: str, no_seconds: bool = False) -> str:
     """
     .. code-block:: python
 
         >>> degminsec(2.4, 'NS')
         "2°24'N"
+        >>> degminsec(2.43, 'NS')
+        '2°25\'48.000000"N'
         >>> degminsec(1.249, 'NS', no_seconds=True)
         "1°15'N"
     """
     if 'N' in hemispheres:
-        return Coordinates(dec, 0).lat_to_string(format='ascii', no_seconds=no_seconds)
-    return Coordinates(0, dec).lon_to_string(format='ascii', no_seconds=no_seconds)
-
+        return Coordinates(dec, 0).lat_to_string(
+            format=CoordinateFormat.ascii, no_seconds=no_seconds)
+    return Coordinates(0, dec).lon_to_string(
+        format=CoordinateFormat.ascii, no_seconds=no_seconds)
 
-def dec2degminsec(dec, no_seconds: bool = False) -> typing.Tuple[float, float, float]:
-    """
-    convert a floating point number of degrees to a triple (int degrees, int minutes, float seconds)
 
-    .. code-block:: python
-
-        >>> assert dec2degminsec(30.50) == (30, 30, 0.0)
-    """
+def _dec2degminsec(dec: float, no_seconds: bool = False) -> DegMinSec:
     degrees = int(math.floor(dec))
     dec = (dec - int(math.floor(dec))) * 60
     minutes = int(math.floor(dec))
@@ -62,10 +135,30 @@ def dec2degminsec(dec, no_seconds: bool = False) -> typing.Tuple[float, float, f
                 minutes = 0
                 degrees += 1
         seconds = 0
-    return degrees, minutes, seconds
+    return DegMinSec(degrees, minutes, seconds)
 
 
-def degminsec2dec(degrees, minutes, seconds) -> float:
+def dec2degminsec(dec: float, no_seconds: bool = False) -> tuple[int, int, float]:
+    """
+    convert a floating point number of degrees to a triple (int degrees, int minutes, float seconds)
+
+    .. code-block:: python
+
+        >>> assert dec2degminsec(30.50) == (30, 30, 0.0)
+    """
+    return dataclasses.astuple(_dec2degminsec(dec, no_seconds=no_seconds))
+
+
+def _degminsec2dec(d: DegMinSec) -> float:
+    dec = float(d.degrees)
+    if d.minutes:
+        dec += float(d.minutes) / 60
+    if d.seconds:
+        dec += float(d.seconds) / 3600
+    return dec
+
+
+def degminsec2dec(degrees: int, minutes: int, seconds: float) -> float:
     """
     convert a triple (int degrees, int minutes, float seconds) to a floating point number of degrees
 
@@ -73,15 +166,10 @@ def degminsec2dec(degrees, minutes, seconds) -> float:
 
         >>> assert dec2degminsec(degminsec2dec(30,30,0.0)) == (30,30,0.0)
     """
-    dec = float(degrees)
-    if minutes:
-        dec += float(minutes) / 60
-    if seconds:
-        dec += float(seconds) / 3600
-    return dec
+    return _degminsec2dec(DegMinSec(degrees, minutes, seconds))
 
 
-class Coordinates(object):
+class Coordinates:
     """
     A (lat, lon) pair, that can be represented in various formats.
 
@@ -100,7 +188,7 @@ class Coordinates(object):
         >>> assert c.lat_to_string() == '12d10S'
         >>> c.lat_to_string(format=None)
         '12° 10′ 12″ S'
-        >>> c.lat_to_string(format='ascii')
+        >>> c.lat_to_string(format=CoordinateFormat.ascii)
         '12°10\'12.000000"S'
         >>> assert c.lon_to_string() == '92d49W'
         >>> lat, lon = '12d30N', '60d30E'
@@ -109,7 +197,13 @@ class Coordinates(object):
         >>> assert c.lon_to_string() == lon
     """
 
-    def __init__(self, lat, lon, format='alnum'):
+    def __init__(
+            self,
+            lat: DimensionType,
+            lon: DimensionType,
+            format: CoordinateFormatType = CoordinateFormat.alnum):  # pylint: disable=W0622
+        format = get_format(format or CoordinateFormat.alnum)
+
         if isinstance(lat, float):
             self.latitude = lat
         elif isinstance(lat, int):
@@ -124,86 +218,70 @@ def __init__(self, lat, lon, format='alnum'):
         else:
             self.longitude = self.lon_from_string(lon, format)
 
-    def _match(self, string, type, format):
+    def _match(
+            self, string: Union[str, bytes],
+            type: str,  # pylint: disable=W0622
+            format: CoordinateFormat,  # pylint: disable=W0622
+    ) -> re.Match:
         if isinstance(string, bytes):
             string = string.decode('utf8')
 
-        if type + '_' + format in PATTERNS:
-            p = PATTERNS[type + '_' + format]
+        if type + '_' + format.name in PATTERNS:
+            p = PATTERNS[type + '_' + format.name]
         else:
-            p = PATTERNS[type + '_alnum']
+            p = PATTERNS[type + '_alnum']  # pragma: no cover
 
         m = p.match(string)
         if not m:
             raise ValueError(string)
         return m
 
-    def lat_from_string(self, lat, format='alnum'):
+    def lat_from_string(
+            self,
+            lat: str,
+            format: CoordinateFormat = CoordinateFormat.alnum,  # pylint: disable=W0622
+    ) -> float:
+        """Parse a latitude value."""
         m = self._match(lat, 'lat', format)
-        dec = degminsec2dec(m.group('deg'), m.group('min'), m.group('sec'))
+        dec = _degminsec2dec(DegMinSec.from_match(m))
         if m.group('hem') == 'S':
             dec = -dec
         return dec
 
-    def lon_from_string(self, lon, format='alnum'):
+    def lon_from_string(
+            self,
+            lon: str,
+            format: CoordinateFormat = CoordinateFormat.alnum,  # pylint: disable=W0622
+    ) -> float:
+        """Parse a longitude value."""
         m = self._match(lon, 'lon', format)
-        dec = degminsec2dec(m.group('deg'), m.group('min'), m.group('sec'))
+        dec = _degminsec2dec(DegMinSec.from_match(m))
         if m.group('hem') == 'W':
             dec = -dec
         return dec
 
-    def _format(self, degrees, minutes, seconds, hemisphere, format):
-        seconds = int(round(seconds))
-        if seconds == 60:
-            minutes += 1
-            seconds = 0
-
-        if 120 > minutes >= 60:  # pragma: no cover
-            # This case cannot really happen, because we only ever feed the results of
-            # dec2degminsec into this method.
-            degrees += 1
-            minutes -= 60
-
-        if format == 'alnum':
-            res = "%sd" % degrees
-            if minutes:
-                res += "%02d" % minutes
-            res += hemisphere
-            return res
-
-        if format == 'ascii':
-            res = "%s°" % degrees
-            if minutes:
-                res += "{0:0>2d}'".format(minutes)
-            if seconds:
-                res += '{0:0>2f}"'.format(seconds)
-            res += hemisphere
-            return res
-
-        res = "%s%s" % (degrees, DEGREES)
-
-        if minutes:
-            res += " %s%s" % (minutes, MINUTES)
-
-        if seconds:
-            res += " %s%s" % (seconds, SECONDS)
-        res += " %s" % hemisphere
-        return res
-
     def lat_to_string(
-            self, format: typing.Union[str, None] = 'alnum', no_seconds: bool = False) -> str:
+            self,
+            format: Optional[CoordinateFormat] = CoordinateFormat.alnum,  # pylint: disable=W0622
+            no_seconds: bool = False,
+    ) -> str:
+        """A latitude value represented as string."""
         if self.latitude < 0:
             hemisphere = 'S'
         else:
             hemisphere = 'N'
-        degrees, minutes, seconds = dec2degminsec(abs(self.latitude), no_seconds=no_seconds)
-        return self._format(degrees, minutes, seconds, hemisphere, format)
+        d = _dec2degminsec(abs(self.latitude), no_seconds=no_seconds)
+        return d.as_string(hemisphere, format)
 
     def lon_to_string(
-            self, format: typing.Union[str, None] = 'alnum', no_seconds: bool = False) -> str:
+            self,
+            format: Optional[CoordinateFormat] = CoordinateFormat.alnum,  # pylint: disable=W0622
+            no_seconds: bool = False,
+    ) -> str:
+        """A longitude value represented as string."""
         if self.longitude < 0:
             hemisphere = 'W'
         else:
             hemisphere = 'E'
-        degrees, minutes, seconds = dec2degminsec(abs(self.longitude), no_seconds=no_seconds)
-        return self._format(degrees, minutes, seconds, hemisphere, format)
+        d = _dec2degminsec(abs(self.longitude), no_seconds=no_seconds)
+        return d.as_string(hemisphere, format)
diff --git a/src/clldutils/db.py b/src/clldutils/db.py
index 6525996..30baf2d 100644
--- a/src/clldutils/db.py
+++ b/src/clldutils/db.py
@@ -2,10 +2,11 @@
 This module provides tools to create/drop and use databases specified by DB URL. This module only
 handles SQLite and PostgreSQL, but abstracts the differences between the two.
 """
-import typing
+from typing import Optional
 import logging
 import pathlib
 import sqlite3
+import contextlib
 import subprocess
 import urllib.parse
 
@@ -28,7 +29,7 @@ class DB:
     """
     settings_key = 'sqlalchemy.url'
 
-    def __init__(self, url: str, log: typing.Optional[logging.Logger] = None):
+    def __init__(self, url: str, log: Optional[logging.Logger] = None):
         self.log = log
         self.components = urllib.parse.urlparse(url)
         if self.dialect not in ['sqlite', 'postgresql']:
@@ -50,10 +51,12 @@ def from_settings(cls, settings: dict, log=None):
 
     @property
     def dialect(self) -> str:
+        """The database dialect"""
         return str(self.components.scheme.split('+')[0])
 
     @property
-    def name(self):
+    def name(self) -> str:
+        """The database name."""
         assert self.components.path.startswith('/')
         return self.components.path[1:].split('?')[0]
 
@@ -75,13 +78,14 @@ def create(self):
         :raises ValueError: If the database already exists.
         """
         if self.log:
-            self.log.info('creating {0}'.format(self))
+            self.log.info(f'creating {self}')
         if self.dialect == 'postgresql':
             subprocess.check_call([CREATEDB, self.name])
         else:  # self.dialect == 'sqlite'
             if self.exists():
                 raise ValueError('db exists!')
-            sqlite3.connect(self.name)
+            with contextlib.closing(sqlite3.connect(self.name)):
+                pass
 
     def drop(self):
         """
@@ -89,7 +93,7 @@ def drop(self):
         """
         if self.exists():
             if self.log:
-                self.log.info('dropping {0}'.format(self))
+                self.log.info(f'dropping {self}')
             if self.dialect == 'postgresql':
                 subprocess.check_call([DROPDB, self.name])
             else:
diff --git a/src/clldutils/declenum.py b/src/clldutils/declenum.py
index 6c0437e..524353e 100644
--- a/src/clldutils/declenum.py
+++ b/src/clldutils/declenum.py
@@ -8,7 +8,7 @@
 
 
 @functools.total_ordering
-class EnumSymbol(object):
+class EnumSymbol:
     """Define a fixed symbol tied to a parent class."""
 
     def __init__(self, cls_, name, value, description, *args):
@@ -26,18 +26,18 @@ def __iter__(self):
         return iter([self.value, self.description])
 
     def __repr__(self):
-        return "<%s>" % self.name
+        return f"<{self.name}>"
 
     def __hash__(self):
         return self.value
 
     def __str__(self):
-        return '{0}'.format(self.value)
+        return f'{self.value}'
 
     def __lt__(self, other):
         return self.value < getattr(other, 'value', None)
 
-    def __json__(self, *args, **kw):
+    def __json__(self, *args, **kw):  # pylint: disable=W0613
         return self.value
 
 
@@ -64,20 +64,23 @@ class DeclEnum(metaclass=EnumMeta):
 
     @classmethod
     def from_string(cls, value):
+        """Look up a symbol by name."""
         try:
             return cls._reg[value]
-        except KeyError:
-            raise ValueError("Invalid value for %r: %r" % (cls.__name__, value))
+        except KeyError as e:
+            raise ValueError(f"Invalid value for {cls.__name__}: {repr(value)}") from e
 
     @classmethod
     def get(cls, item):
+        """Flexible getter for a symbol."""
         if item in iter(cls):
             return item
         for li in cls:
-            if li.name == item or li.value == item:
+            if item in (li.name, li.value):
                 return li
         raise ValueError(item)
 
     @classmethod
     def values(cls):
+        """All values."""
         return list(cls._reg)
diff --git a/src/clldutils/fonts.py b/src/clldutils/fonts.py
index 8767c4d..1076b46 100644
--- a/src/clldutils/fonts.py
+++ b/src/clldutils/fonts.py
@@ -11,7 +11,7 @@
 """
 import pathlib
 
-from clldutils.html import HTML, literal
+from clldutils.html import HTML, literal, HTMLBuilder
 
 __all__ = ['FONTS_DIR', 'charis_font_spec_css', 'charis_font_spec_html']
 
@@ -29,31 +29,32 @@ def charis_font_spec_css() -> str:
     `link_callback <https://xhtml2pdf.readthedocs.io/en/latest/reference.html#link-callback>`_
     with `pisa.CreatePDF`, make sure to return unhandled `src_attr` arguments as is.
     """
-    return """
+    fdir = FONTS_DIR.resolve()
+    return f"""
     @font-face {{
         font-family: 'charissil';
-        src: url('{0}/CharisSIL-Regular.ttf');
+        src: url('{fdir}/CharisSIL-Regular.ttf');
     }}
     @font-face {{
         font-family: 'charissil';
         font-style: italic;
-        src: url('{0}/CharisSIL-Italic.ttf');
+        src: url('{fdir}/CharisSIL-Italic.ttf');
     }}
     @font-face {{
         font-family: 'charissil';
         font-weight: bold;
-        src: url('{0}/CharisSIL-Bold.ttf');
+        src: url('{fdir}/CharisSIL-Bold.ttf');
     }}
     @font-face {{
         font-family: 'charissil';
         font-weight: bold;
         font-style: italic;
-        src: url('{0}/CharisSIL-BoldItalic.ttf');
+        src: url('{fdir}/CharisSIL-BoldItalic.ttf');
     }}
-""".format(FONTS_DIR.resolve())
+"""
 
 
-def charis_font_spec_html() -> HTML:
+def charis_font_spec_html() -> HTMLBuilder:
     """
     Charis SIL font specification inside an HTML style tag.
     """
diff --git a/src/clldutils/html.py b/src/clldutils/html.py
index 9d659cf..0226cd9 100644
--- a/src/clldutils/html.py
+++ b/src/clldutils/html.py
@@ -48,7 +48,7 @@
 __all__ = ["HTML", "escape", "literal"]
 
 
-class literal(markupsafe.Markup):
+class literal(markupsafe.Markup):  # pylint: disable=invalid-name
     """An HTML literal string, which will not be further escaped.
 
     I'm a subclass of ``markupsafe.Markup``, which itself is a subclass
@@ -98,7 +98,7 @@ def __new__(cls, base="", encoding=None, errors="strict"):
         return super(literal, cls).__new__(cls, base, encoding, errors)
 
     @classmethod
-    def escape(cls, s):
+    def escape(cls, s: str) -> 'literal':  # pylint: disable=W0221
         """Escape the argument and return a literal.
 
         This is a *class* method. The result depends on the argument type:
@@ -132,7 +132,7 @@ def escape(cls, s):
         """
         if s is None:
             return EMPTY
-        return super(literal, cls).escape(s)
+        return super().escape(s)
 
     def lit_join(self, iterable):
         """Like the ``.join`` string method but don't escape elements in the iterable."""
@@ -146,7 +146,7 @@ def lit_join(self, iterable):
 EMPTY = literal("")
 
 
-class HTMLBuilder(object):
+class HTMLBuilder:
     """An HTML tag generator."""
 
     literal = literal
@@ -230,8 +230,8 @@ class HTMLBuilder(object):
     _comment_tag = literal("<!-- "), literal(" -->")
 
     def __call__(self, *args, **kw):
-
-        """Escape the string args, concatenate them, and return a literal.
+        """
+        Escape the string args, concatenate them, and return a literal.
 
         This is the same as ``literal.escape(s)`` but accepts multiple
         strings.  Multiple arguments are useful when mixing child tags
@@ -247,11 +247,10 @@ def __call__(self, *args, **kw):
         ``lit``
             If true, don't escape the arguments. (Default False.)
         """
-
         nl = kw.pop("nl", False)
         lit = kw.pop("lit", False)
         if kw:
-            raise TypeError("unknown keyword args: {0}".format(sorted(kw)))
+            raise TypeError(f"unknown keyword args: {sorted(kw)}")
         if not lit:
             args = map(escape, args)
         if nl:
@@ -261,8 +260,8 @@ def __call__(self, *args, **kw):
         return ret
 
     def tag(self, tag, *args, **kw):
-
-        """Create an HTML tag.
+        """
+        Create an HTML tag.
 
         ``tag`` is the tag name. The other positional arguments become the
         content for the tag, and are escaped and concatenated.
@@ -358,7 +357,6 @@ def tag(self, tag, *args, **kw):
         >>> HTML.tag("/div", _closed=False)
         literal(u'</div>')
         """
-
         if "c" in kw:
             assert not args, "The special 'c' keyword argument cannot be used " \
                              "in conjunction with non-keyword arguments"
@@ -466,7 +464,7 @@ def render_attrs(self, attrs):
         return EMPTY.join(strings)
 
     # Private methods
-    def optimize_attrs(self, attrs, boolean_attrs=None):
+    def optimize_attrs(self, attrs, boolean_attrs=None):  # pylint: disable=R0912
 
         """Perform various transformations on an HTML attributes dict.
 
diff --git a/src/clldutils/inifile.py b/src/clldutils/inifile.py
index 3e24cda..b663bda 100644
--- a/src/clldutils/inifile.py
+++ b/src/clldutils/inifile.py
@@ -6,7 +6,11 @@
 import io
 import re
 import pathlib
+from typing import Union, Any
 import configparser
+from collections.abc import Iterable
+
+DOT = '.'
 
 
 class INI(configparser.ConfigParser):
@@ -14,22 +18,27 @@ class INI(configparser.ConfigParser):
     An enhanced `ConfigParser` with better support for list-valued options and multiline text.
     """
     @staticmethod
-    def format_list(items):
+    def format_list(items: Iterable[str]) -> str:
+        """Concatenate items as INI style list."""
         return ''.join('\n' + item for item in items)
 
     @classmethod
-    def from_file(cls, fname, encoding='utf-8', **kw) -> 'INI':
+    def from_file(cls, fname: Union[str, pathlib.Path], encoding='utf-8', **kw) -> 'INI':
+        """
+        `kw` are passed through to `ConfigParser.__init__`.
+        """
         obj = cls(**kw)
         obj.read(str(fname), encoding=encoding)
         return obj
 
     def write_string(self, **kw) -> str:
+        """Write the INI prefixed with an encoding comment suitable for emacs."""
         res = io.StringIO()
         res.write('# -*- coding: utf-8 -*-\n')
-        super(INI, self).write(res, **kw)
+        super().write(res, **kw)
         return res.getvalue()
 
-    def set(self, section, option, value=None):
+    def set(self, section: str, option: str, value: Union[None, list, tuple, Any] = None):
         """
         Enhances `ConfigParser.set` by
 
@@ -44,13 +53,14 @@ def set(self, section, option, value=None):
         if isinstance(value, (list, tuple)):
             value = self.format_list(value)
         elif not isinstance(value, str):
-            value = '%s' % value
-        super(INI, self).set(section, option, value)
+            value = f'{value}'
+        super().set(section, option, value)
 
-    def getlist(self, section, option) -> list:
+    def getlist(self, section: str, option: str) -> list:
+        """Get section content as list."""
         return self.get(section, option, fallback='').strip().splitlines()
 
-    def gettext(self, section, option, whitespace_preserving_prefix='.'):
+    def gettext(self, section, option, whitespace_preserving_prefix=DOT) -> str:
         """
         While configparser supports multiline values, it does this at the expense of
         stripping leading whitespace for each line in such a value. Sometimes we want
@@ -66,15 +76,20 @@ def gettext(self, section, option, whitespace_preserving_prefix='.'):
             lines.append(line)
         return '\n'.join(lines)
 
-    def settext(self, section, option, value, whitespace_preserving_prefix='.'):
+    def settext(self, section: str, option: str, value: str, whitespace_preserving_prefix=DOT):
+        """
+        Set a text option, preserving newlines.
+        """
         lines = []
         for line in value.splitlines():
             if re.match(r'\s+', line):
+                # The line starts with whitespace, so we have to add a non-whitespace char to
+                # preserve it.
                 line = whitespace_preserving_prefix + line
             lines.append(line)
         self.set(section, option, '\n'.join(lines))
 
-    def write(self, fname, **kw):
+    def write(self, fname, **kw):  # pylint: disable=arguments-differ
         """
         Write an INI file.
         """
diff --git a/src/clldutils/iso_639_3.py b/src/clldutils/iso_639_3.py
index bf10ab8..8e6b7cd 100644
--- a/src/clldutils/iso_639_3.py
+++ b/src/clldutils/iso_639_3.py
@@ -9,12 +9,13 @@
 import re
 import csv
 import string
-import typing
+from typing import Union, Protocol, Optional
 import pathlib
 import datetime
 import functools
 import collections
 import urllib.request
+from collections.abc import Generator, Iterable
 
 from clldutils.path import TemporaryDirectory
 from clldutils.ziparchive import ZipArchive
@@ -36,12 +37,18 @@
 }
 
 
+class HasSplitlines(Protocol):  # pylint: disable=too-few-public-methods,missing-class-docstring
+    def splitlines(self) -> Iterable[str]:  # pylint: disable=C0116
+        ...  # pragma: no cover
+
+
 def _open(path):
     return urllib.request.urlopen(
         urllib.request.Request(BASE_URL + path, headers={'User-Agent': USER_AGENT}))
 
 
-def iterrows(lines):
+def iterrows(lines: Iterable[str]) -> Generator[collections.OrderedDict[str, str], None, None]:
+    """Parse CSV lines into row dicts."""
     header = None
     for i, row in enumerate(csv.reader(io.StringIO('\n'.join(lines)), delimiter='\t')):
         if i == 0:
@@ -51,8 +58,8 @@ def iterrows(lines):
 
 
 class Table(list):
-
-    def __init__(self, name_and_date, date, fp):
+    """A code table."""
+    def __init__(self, name_and_date: str, date: str, fp: HasSplitlines):
         parts = name_and_date.split('_')
         # The ISO 639-3 code tables from 2020-05-15 contain a table with a
         # malformed name - having an excess "0" in the date stamp.
@@ -66,12 +73,10 @@ def __init__(self, name_and_date, date, fp):
         if not name:
             name = 'Codes'
         self.name = name
-        super(Table, self).__init__(list(iterrows(
-            [line for line in fp.splitlines() if line.strip()],  # strip malformed lines.
-        )))
+        super().__init__(list(iterrows(line for line in fp.splitlines() if line.strip())))
 
 
-def download_tables(outdir=None) -> pathlib.Path:
+def download_tables(outdir: Optional[Union[str, pathlib.Path]] = None) -> pathlib.Path:
     """
     Download the zipped ISO tables to `outdir` or cwd.
     """
@@ -84,7 +89,8 @@ def download_tables(outdir=None) -> pathlib.Path:
     return target
 
 
-def iter_tables(zippath=None):
+def iter_tables(zippath: Optional[str] = None) -> Generator[Table, None, None]:
+    """Yield tables from a code tables zip archive."""
     with TemporaryDirectory() as tmp:
         if not zippath:
             zippath = download_tables(tmp)
@@ -99,7 +105,7 @@ def iter_tables(zippath=None):
 
 
 @functools.total_ordering
-class Code(object):
+class Code:
     """
     Represents one ISO 639-3 code and its associated metadata.
 
@@ -107,7 +113,7 @@ class Code(object):
     :ivar str name: The language name
     """
     _code_pattern = re.compile(r'\[([a-z]{3})]')
-    _scope_map = {
+    _scope_map = {  # Scopes for items from table Codes.
         'I': 'Individual',
         'M': 'Macrolanguage',
         'S': 'Special',
@@ -128,10 +134,10 @@ class Code(object):
         'M': 'merge',
     }
 
-    def __init__(self, item, tablename, registry):
+    def __init__(self, item: dict[str, str], tablename: str, registry: 'ISO'):
         code = item['Id']
         self._change_to = []
-        self.retired = False
+        self.retired: Union[bool, datetime.date] = False
         if tablename == 'Codes':
             self._scope = self._scope_map[item['Scope']]
             self._type = self._type_map[item['Language_Type']]
@@ -155,8 +161,8 @@ def __init__(self, item, tablename, registry):
         else:
             raise ValueError(tablename)  # pragma: no cover
 
-        self.code = code
-        self.name = item['Ref_Name']
+        self.code: str = code
+        self.name: str = item['Ref_Name']
         self._registry = registry
 
     @property
@@ -164,7 +170,7 @@ def type(self) -> str:
         """
         The type of the code formatted as pair "scope/type"
         """
-        return '{}/{}'.format(self._scope, self._type)
+        return f'{self._scope}/{self._type}'
 
     @property
     def is_retired(self) -> bool:
@@ -174,7 +180,7 @@ def is_retired(self) -> bool:
         return bool(self.retired)
 
     @property
-    def change_to(self) -> typing.List['Code']:
+    def change_to(self) -> list['Code']:
         """
         List of codes that supersede a retired code.
         """
@@ -195,17 +201,19 @@ def is_local(self) -> bool:
         return self._scope == 'Local'
 
     @property
-    def is_macrolanguage(self) -> bool:
+    def is_macrolanguage(self) -> bool:  # pylint: disable=C0116
         return self._scope == 'Macrolanguage'
 
     @property
-    def extension(self) -> typing.List['Code']:
+    def extension(self) -> list['Code']:
         """
         The codes subsumed by a macrolanguage code.
         """
-        if self.is_macrolanguage:
-            return [self._registry[c] for c in self._registry._macrolanguage[self.code]]
-        return []
+        if not self.is_macrolanguage:
+            return []
+        return [
+            self._registry[c]  # pylint: disable=W0212
+            for c in self._registry._macrolanguage[self.code]]  # pylint: disable=W0212
 
     def __hash__(self):
         return hash(self.code)
@@ -217,10 +225,10 @@ def __lt__(self, other):
         return self.code < other.code
 
     def __repr__(self):
-        return '<ISO-639-3 [{0}] {1}>'.format(self.code, self.type)
+        return f'<ISO-639-3 [{self.code}] {self.type}>'
 
     def __str__(self):
-        return '{0} [{1}]'.format(self.name, self.code)
+        return f'{self.name} [{self.code}]'
 
 
 class ISO(collections.OrderedDict):
@@ -241,7 +249,7 @@ class ISO(collections.OrderedDict):
             >>> iso.retirements[0].change_to
             [<ISO-639-3 [fry] Individual/Living>]
     """
-    def __init__(self, zippath: typing.Optional[typing.Union[str, pathlib.Path]] = None):
+    def __init__(self, zippath: Optional[Union[str, pathlib.Path]] = None):
         """
         :param zippath: Path to a local copy of the "Complete Set of Tables" (UTF-8). If `None`, \
         the tables will be retrieved from the web.
@@ -250,13 +258,13 @@ def __init__(self, zippath: typing.Optional[typing.Union[str, pathlib.Path]] = N
         self._tables = {t.name: t for t in iter_tables(zippath=zippath)}
         if zippath and DATESTAMP_PATTERN.search(zippath.name):
             digits = map(int, DATESTAMP_PATTERN.search(zippath.name).groups())
-            self.date = datetime.date(*digits)
+            self.date: datetime.date = datetime.date(*digits)
         else:
-            self.date = max(t.date for t in self._tables.values())
+            self.date: datetime.date = max(t.date for t in self._tables.values())
         self._macrolanguage = collections.defaultdict(list)
         for item in self._tables['macrolanguages']:
             self._macrolanguage[item['M_Id']].append(item['I_Id'])
-        super(ISO, self).__init__()
+        super().__init__()
         for tablename in ['Codes', 'Retirements']:
             for item in self._tables[tablename]:
                 if item['Id'] not in self:
@@ -267,72 +275,74 @@ def __init__(self, zippath: typing.Optional[typing.Union[str, pathlib.Path]] = N
         for code in ['q' + x + y
                      for x in string.ascii_lowercase[:string.ascii_lowercase.index('t') + 1]
                      for y in string.ascii_lowercase]:
-            self[code] = Code(dict(Id=code, Ref_Name=None), 'Local', self)
+            # Codes in the local use area.
+            self[code] = Code({'Id': code, 'Ref_Name': None}, 'Local', self)
 
     def __str__(self):
-        return 'ISO 639-3 code tables from {0}'.format(self.date)
+        return f'ISO 639-3 code tables from {self.date}'
 
-    def by_type(self, type_) -> typing.List[Code]:
-        return [c for c in self.values() if c._type == type_]
+    def by_type(self, type_) -> list[Code]:
+        """Return codes by type."""
+        return [c for c in self.values() if c._type == type_]  # pylint: disable=protected-access
 
     @property
-    def living(self) -> typing.List[Code]:
+    def living(self) -> list[Code]:
         """
         All codes categorized as "Living"
         """
         return self.by_type('Living')
 
     @property
-    def extinct(self) -> typing.List[Code]:
+    def extinct(self) -> list[Code]:
         """
         All codes categorized as "Extinct"
         """
         return self.by_type('Extinct')
 
     @property
-    def ancient(self) -> typing.List[Code]:
+    def ancient(self) -> list[Code]:
         """
         All codes categorized as "Ancient"
         """
         return self.by_type('Ancient')
 
     @property
-    def historical(self) -> typing.List[Code]:
+    def historical(self) -> list[Code]:
         """
         All codes categorized as "Historical"
         """
         return self.by_type('Historical')
 
     @property
-    def constructed(self) -> typing.List[Code]:
+    def constructed(self) -> list[Code]:
         """
         All codes categorized as "Constructed"
         """
         return self.by_type('Constructed')
 
     @property
-    def special(self) -> typing.List[Code]:
+    def special(self) -> list[Code]:
         """
         All codes categorized as "Special"
         """
         return self.by_type('Special')
 
     @property
-    def retirements(self) -> typing.List[Code]:
+    def retirements(self) -> list[Code]:
         """
         All retired codes
         """
         return [c for c in self.values() if c.is_retired]
 
     @property
-    def macrolanguages(self) -> typing.List[Code]:
+    def macrolanguages(self) -> list[Code]:
         """
         All macrolanguage codes
         """
         return [c for c in self.values() if c.is_macrolanguage]
 
     @property
-    def languages(self) -> typing.List[Code]:
+    def languages(self) -> list[Code]:
         """
         All active language codes
         """
diff --git a/src/clldutils/jsonlib.py b/src/clldutils/jsonlib.py
index 2d33357..2c4638c 100644
--- a/src/clldutils/jsonlib.py
+++ b/src/clldutils/jsonlib.py
@@ -25,9 +25,9 @@
 import datetime
 import contextlib
 import collections
-import typing
+from typing import Union, TextIO
 
-import dateutil.parser
+from ._compat import fromisoformat
 
 __all__ = ['parse', 'format', 'dump', 'load', 'update', 'update_ordered']
 
@@ -52,19 +52,19 @@ def parse(d: dict) -> dict:
     res = {}
     for k, v in d.items():
         if isinstance(v, str) and DATETIME_ISO_FORMAT.match(v):
-            v = dateutil.parser.parse(v)
+            v = fromisoformat(v)
         elif isinstance(v, dict):
             v = parse(v)
         elif isinstance(v, list):
             v = [
-                dateutil.parser.parse(vv)
+                fromisoformat(vv)
                 if isinstance(vv, str) and DATETIME_ISO_FORMAT.match(vv) else vv
                 for vv in v]
         res[k] = v
     return res
 
 
-def format(value):
+def format(value):  # pylint: disable=redefined-builtin
     """
     Format a value as ISO timestamp if it is a datetime.date(time) instance, otherwise return it
     unchanged.
@@ -74,7 +74,7 @@ def format(value):
     return value
 
 
-def dump(obj, path: typing.Union[typing.TextIO, str, pathlib.Path], **kw):
+def dump(obj, path: Union[TextIO, str, pathlib.Path], **kw):
     """`json.dump` which understands filenames.
 
     :param obj: The object to be dumped.
@@ -87,7 +87,7 @@ def dump(obj, path: typing.Union[typing.TextIO, str, pathlib.Path], **kw):
     return json.dump(obj, path, **kw)
 
 
-def load(path: typing.Union[typing.TextIO, str, pathlib.Path], **kw):
+def load(path: Union[TextIO, str, pathlib.Path], **kw):
     """`json.load` which understands filenames.
 
     :param kw: Keyword parameters are passed to json.load
@@ -124,8 +124,9 @@ def update(path, default=None, load_kw=None, **kw):
 
 
 def update_ordered(path, **kw):
+    """The update functionality with ordered dicts."""
     return update(
         path,
         default=collections.OrderedDict(),
-        load_kw=dict(object_pairs_hook=collections.OrderedDict),
+        load_kw=dict(object_pairs_hook=collections.OrderedDict),  # pylint: disable=R1735
         **kw)
diff --git a/src/clldutils/lgr.py b/src/clldutils/lgr.py
index 469040d..922e6dc 100644
--- a/src/clldutils/lgr.py
+++ b/src/clldutils/lgr.py
@@ -397,7 +397,9 @@
 """
 
 import re
+from typing import Optional, Callable
 import itertools
+from collections.abc import Iterable, Mapping
 
 PERSONS = {
     "1": "first person",
@@ -490,14 +492,36 @@
 }
 
 
-def pattern(custom=None):
+def pattern(custom: Optional[Iterable[str]] = None) -> re.Pattern:
+    """
+    A regex pattern to search for LGR categories.
+
+    .. code-block:: python
+
+        >>> pattern().search('a.1SG.b').groupdict()
+        {'pre': '.', 'person': '1', 'abbr': 'SG'}
+    """
     return re.compile(
-        '(?P<pre>^|[^A-Z1-3])(?P<person>{0})?(?P<abbr>{1})(?=$|[^A-Z1-3])'.format(
+        '(?P<pre>^|[^A-Z1-3])'  # pylint: disable=C0209
+        '(?P<person>{0})?'
+        '(?P<abbr>{1})(?=$|[^A-Z1-3])'.format(
             '|'.join(re.escape(k) for k in PERSONS),
             '|'.join(re.escape(k) for k in itertools.chain(ABBRS, custom or {}))))
 
 
-def replace(string, repl=None, custom=None):
+def replace(
+        string: str,
+        repl: Optional[Callable[[re.Match], str]] = None,
+        custom: Optional[Mapping[str, str]] = None,
+) -> str:
+    """
+    .. code-block:: python
+
+        >>> replace('a-1SG-b', custom={'SG': 'OTHER'})
+        'a-<first person OTHER>-b'
+        >>> replace('a-1SG-b', repl=lambda m: f'.{m.group('abbr')}.')
+        'a.SG.-b'
+    """
     custom = custom or {}
     if repl is None:
         def repl(m):
@@ -505,6 +529,6 @@ def repl(m):
             if m.group('person'):
                 res += PERSONS[m.group('person')] + ' '
             res += custom.get(m.group('abbr'), ABBRS.get(m.group('abbr')))
-            return '{0}<{1}>'.format(m.group('pre'), res)
+            return f"{m.group('pre')}<{res}>"
 
     return pattern(custom).sub(repl, string)
diff --git a/src/clldutils/licenses.py b/src/clldutils/licenses.py
index 58971cc..7bb5977 100644
--- a/src/clldutils/licenses.py
+++ b/src/clldutils/licenses.py
@@ -1,6 +1,10 @@
+# pylint: disable=C0302
+"""
+Licenses suitable for data licensing.
+"""
+from typing import Optional
 import pathlib
-
-import attr
+import dataclasses
 
 _LICENSES = {
     "Glide": {
@@ -1086,23 +1090,27 @@
 }
 
 
-@attr.s
-class License(object):
-    id = attr.ib()
-    name = attr.ib()
-    url = attr.ib()
+@dataclasses.dataclass
+class License:
+    """A license."""
+    id: str
+    name: str
+    url: str
 
     @property
-    def legalcode(self):
+    def legalcode(self) -> Optional[str]:
+        """Return the license text."""
         p = pathlib.Path(__file__).parent / 'legalcode' / self.id
         if p.exists():
             return p.read_text(encoding='utf8')
+        return None
 
 
 _LICENSES = [License(id_, l['name'], l['url']) for id_, l in _LICENSES.items()]
 
 
-def find(q):
+def find(q: str) -> Optional[License]:
+    """Flexibly retrieve a license."""
     for license_ in _LICENSES:
         if q.lower() == license_.id.lower() or q == license_.name or q == license_.url:
             return license_
@@ -1111,3 +1119,4 @@ def find(q):
             u2 = q.split('://')[1]
             if u1.startswith(u2) or u2.startswith(u1):
                 return license_
+    return None
diff --git a/src/clldutils/loglib.py b/src/clldutils/loglib.py
index 77e040e..1e14321 100644
--- a/src/clldutils/loglib.py
+++ b/src/clldutils/loglib.py
@@ -22,7 +22,7 @@
 __all__ = ['get_colorlog', 'Logging']
 
 
-def get_colorlog(name, stream=None, level=logging.INFO) -> logging.Logger:
+def get_colorlog(name: str, stream=None, level=logging.INFO) -> logging.Logger:
     """
     Get a logger set up with `colorlog`'s formatter.
     """
@@ -37,7 +37,7 @@ def get_colorlog(name, stream=None, level=logging.INFO) -> logging.Logger:
     return log
 
 
-class Logging(object):
+class Logging:
     """
     A context manager to execute a block of code at a specific logging level.
     """
diff --git a/src/clldutils/markup.py b/src/clldutils/markup.py
index 787a739..dd21c96 100644
--- a/src/clldutils/markup.py
+++ b/src/clldutils/markup.py
@@ -1,12 +1,17 @@
+"""
+Functionality for marking up text, mostly using Markdown.
+"""
 import io
 import re
 import csv
 import sys
-import typing
+import enum
+from typing import Union, Optional, Callable, Any, IO
+import dataclasses
 import urllib.parse
+from collections.abc import Generator, Sequence, Iterable
 
-import attr
-from tabulate import tabulate
+from prettytable import PrettyTable, TableStyle
 from markdown import markdown
 from lxml import etree
 
@@ -14,11 +19,48 @@
 from clldutils.text import replace_pattern
 
 __all__ = [
-    'Table',
+    'Table', 'TableFormat',
     'iter_markdown_tables', 'iter_markdown_sections', 'add_markdown_text',
     'MarkdownLink', 'MarkdownImageLink']
 
 
+class TableFormat(enum.Enum):
+    """Available formatting options for tables."""
+    pipe = enum.auto()  # pylint: disable=invalid-name
+    simple = enum.auto()  # pylint: disable=invalid-name
+    tsv = enum.auto()  # pylint: disable=invalid-name
+    csv = enum.auto()  # pylint: disable=invalid-name
+    ascii = enum.auto()  # pylint: disable=invalid-name
+
+    @classmethod
+    def get(cls, s: Union[None, str, 'TableFormat']):
+        """Factory method, allowing selection of a format by name."""
+        if s is None:
+            return cls.pipe
+        if isinstance(s, str):
+            return getattr(cls, s)
+        assert isinstance(s, cls), s
+        return s
+
+
+def _padded_row(row, num_rows: int, fill: str = '') -> list[Any]:
+    row = list(row)
+    while len(row) < num_rows:
+        row.append(fill)
+    return row
+
+
+def _dedup_cols(ocols: Sequence[str]) -> list[str]:
+    cols = []
+    for col in ocols:
+        i = 1
+        while col in cols:
+            i += 1
+            col = f'{col}_{i}'
+        cols.append(col)
+    return cols
+
+
 class Table(list):
     """
     A context manager to
@@ -31,9 +73,9 @@ class Table(list):
         >>> with Table('col1', 'col2', tablefmt='simple') as t:
         ...     t.append(['v1', 'v2'])
         ...
-        col1    col2
-        ------  ------
-        v1      v2
+         col1   col2
+        ------ ------
+         v1     v2
 
     For more control of the table rendering, a `Table` can be used without a `with` statement,
     calling :meth:`Table.render` instead:
@@ -43,37 +85,55 @@ class Table(list):
         >>> t = Table('col1', 'col2')
         >>> t.extend([['z', 1], ['a', 2]])
         >>> print(t.render(sortkey=lambda r: r[0], tablefmt='simple'))
-        col1      col2
-        ------  ------
-        a            2
-        z            1
+         col1   col2
+        ------ ------
+         a      2
+         z      1
     """
-    def __init__(self, *cols: str, **kw):
+    def __init__(
+            self,
+            *cols: str,
+            rows: Optional[Sequence[Sequence[Any]]] = None,
+            file: Optional[IO] = None,
+            tablefmt: Optional[Union[str, TableFormat]] = None,
+            floatfmt: Optional[str] = '.2',
+    ):
+        """
+
+        """
         self.columns = list(cols)
-        super(Table, self).__init__(kw.pop('rows', []))
-        self._file = kw.pop('file', sys.stdout)
-        self._kw = kw
-
-    def render(self,
-               sortkey=None,
-               condensed=True,
-               verbose=False,
-               reverse=False,
-               **kw):
+        super().__init__(rows or [])
+        self._file = file or sys.stdout
+        self._tablefmt = TableFormat.get(tablefmt)
+        self._floatfmt = floatfmt
+
+    def render(  # pylint: disable=R0913,R0917
+            self,
+            sortkey: Callable[[Any], Any] = None,
+            condensed: bool = True,
+            verbose: bool = False,
+            reverse: bool = False,
+            tablefmt: Optional[Union[str, TableFormat]] = None,
+            floatfmt: Optional[str] = None,
+    ) -> str:
         """
         :param sortkey: A callable which can be used as key when sorting the rows.
         :param condensed: Flag signalling whether whitespace padding should be collapsed.
         :param verbose: Flag signalling whether to output additional info.
         :param reverse: Flag signalling whether we should sort in reverse order.
-        :param kw: Additional keyword arguments are passed to the `tabulate` function.
         :return: String representation of the table in the chosen format.
         """
-        tab_kw = dict(tablefmt='pipe', headers=self.columns, floatfmt='.2f')
-        tab_kw.update(self._kw)
-        tab_kw.update(kw)
-        if tab_kw['tablefmt'] == 'tsv':
+        if not self.columns and not self:
+            return ''
+
+        tablefmt = self._tablefmt if tablefmt is None else TableFormat.get(tablefmt)
+
+        if floatfmt is None:
+            floatfmt = self._floatfmt
+
+        if tablefmt in (TableFormat.tsv, TableFormat.csv):
             res = io.StringIO()
-            w = csv.writer(res, delimiter='\t')
+            w = csv.writer(res, delimiter='\t' if tablefmt == TableFormat.tsv else ',')
             w.writerow(self.columns)
             for row in (sorted(self, key=sortkey, reverse=reverse) if sortkey else self):
                 w.writerow(row)
@@ -82,15 +142,37 @@ def render(self,
             if res.endswith('\r\n'):
                 res = res[:-2]
             return res
-        res = tabulate(
-            sorted(self, key=sortkey, reverse=reverse) if sortkey else self, **tab_kw)
-        if tab_kw['tablefmt'] == 'pipe':
+
+        table = PrettyTable()
+        table.field_names = _dedup_cols(self.columns)
+        rows = sorted(self, key=sortkey, reverse=reverse) if sortkey else self
+        if self.columns:
+            rows = [_padded_row(row, len(self.columns)) for row in rows]
+        if not rows:
+            # Force backwards compatible behaviour:
+            # tabulate also displayed headers for empty tables.
+            rows = [_padded_row([], len(self.columns))]
+        table.add_rows(rows)
+
+        if tablefmt == TableFormat.pipe:
+            table.set_style(TableStyle.MARKDOWN)
+        elif tablefmt == TableFormat.simple:
+            table.border = False
+            table.preserve_internal_border = True
+            table.align = 'l'
+            table.vertical_char = ' '
+            table.junction_char = ' '
+
+        table.float_format = floatfmt
+        res = str(table)
+
+        if tablefmt == TableFormat.pipe:
             if condensed:
                 # remove whitespace padding around column content:
                 res = re.sub(r'\|[ ]+', '| ', res)
                 res = re.sub(r'[ ]+\|', ' |', res)
             if verbose:
-                res += '\n\n(%s rows)\n\n' % len(self)
+                res += f'\n\n({len(self)} rows)\n\n'
         return res
 
     def __enter__(self):
@@ -100,8 +182,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         print(self.render(), file=self._file)
 
 
-def iter_markdown_tables(text) -> \
-        typing.Generator[typing.Tuple[typing.List[str], typing.List[typing.List[str]]], None, None]:
+def iter_markdown_tables(text: str) -> Generator[tuple[list[str], list[list[str]]], None, None]:
     """
     Parse tables from a markdown formatted text.
 
@@ -109,7 +190,7 @@ def iter_markdown_tables(text) -> \
     :return: generator of (header, rows) pairs, where "header" is a `list` of column names and \
     rows is a list of lists of row values.
     """
-    def split_row(line, outer_pipes):
+    def split_row(line: str, outer_pipes: bool) -> list[str]:
         line = line.strip()
         if outer_pipes:
             assert line.startswith('|') and line.endswith('|'), 'inconsistent table formatting'
@@ -120,11 +201,11 @@ def split_row(line, outer_pipes):
         yield split_row(header, outer_pipes), [split_row(row, outer_pipes) for row in rows]
 
 
-def _iter_table_blocks(lines):
+def _iter_table_blocks(lines: Iterable[str]) -> Generator[tuple[str, list[str], bool], None, None]:
     # Tables are detected by
     # 1. A header line, i.e. a line with at least one `|`
     # 2. A line separating header and body of the form below
-    SEP = re.compile(r'\s*\|?\s*:?--(-)+:?\s*(\|\s*:?--(-)+:?\s*)+\|?\s*')
+    sep = re.compile(r'\s*\|?\s*:?-(-)*:?\s*(\|\s*:?-(-)*:?\s*)+\|?\s*')
 
     lines = list(lines)
     header, table, outer_pipes = None, [], False
@@ -135,17 +216,17 @@ def _iter_table_blocks(lines):
                     yield header, table, outer_pipes
                 header, table, outer_pipes = None, [], False
             else:
-                if not SEP.fullmatch(line):
+                if not sep.fullmatch(line):
                     table.append(line)
         else:
-            if '|' in line and len(lines) > i + 1 and SEP.fullmatch(lines[i + 1]):
+            if '|' in line and len(lines) > i + 1 and sep.fullmatch(lines[i + 1]):
                 header = line
                 outer_pipes = lines[i + 1].strip().startswith('|')
     if table:
         yield header, table, outer_pipes
 
 
-def iter_markdown_sections(text) -> typing.Generator[typing.Tuple[int, str, str], None, None]:
+def iter_markdown_sections(text) -> Generator[tuple[int, str, str], None, None]:
     """
     Parse sections from a markdown formatted text.
 
@@ -170,9 +251,11 @@ def iter_markdown_sections(text) -> typing.Generator[typing.Tuple[int, str, str]
         yield level, header, ''.join(lines)
 
 
-def add_markdown_text(text: str,
-                      new: str,
-                      section: typing.Optional[typing.Union[typing.Callable, str]] = None) -> str:
+def add_markdown_text(
+        text: str,
+        new: str,
+        section: Optional[Union[Callable[[str], bool], str]] = None,
+) -> str:
     """
     Append markdown text to a (specific section of a) markdown document.
 
@@ -187,7 +270,7 @@ def add_markdown_text(text: str,
     :raises ValueError: The specified section was not encountered.
     """
     res = []
-    for level, header, content in iter_markdown_sections(text):
+    for _, header, content in iter_markdown_sections(text):
         if header:
             res.append(header)
         res.append(content)
@@ -206,7 +289,7 @@ def add_markdown_text(text: str,
     return res
 
 
-@attr.s
+@dataclasses.dataclass
 class MarkdownLink:
     """
     Functionality to detect and manipulate links in markdown text.
@@ -224,36 +307,40 @@ class MarkdownLink:
         >>> MarkdownLink.replace('[](http://example.com)', lambda ml: ml.update_url(scheme='https'))
         '[l](https://example.com)'
     """
-    label = attr.ib()
-    url = attr.ib()
+    label: str
+    url: str
     # Link starts with "[" if not preceeded by "!" or escaped with "\".
     # We match up to the next unescaped "]" and only optionally match the href enclosed in "()".
     # This is we don't force parsing up to the next "]("!
-    pattern = re.compile(r'(?<!!)(?<!\\)\[(?P<label>.*?)(?<!\\)](\((?P<url>[^)]+)\))?')
-    html_link = ('a', 'href')
+    pattern: re.Pattern = re.compile(r'(?<!!)(?<!\\)\[(?P<label>.*?)(?<!\\)](\((?P<url>[^)]+)\))?')
+    html_link: tuple[str, str] = ('a', 'href')
 
     @classmethod
-    def from_string(cls, s):
+    def from_string(cls, s) -> 'MarkdownLink':
+        """Create an instance from a Markdown formatted string, i.e. [...](...)."""
         try:
             return cls.from_match(cls.pattern.search(s))
-        except AttributeError:
-            raise ValueError('No markdown link found')
+        except AttributeError as e:
+            raise ValueError('No markdown link found') from e
 
     @classmethod
-    def from_match(cls, match):
+    def from_match(cls, match) -> 'MarkdownLink':
+        """Create an instance from a match object as returned e.g. by .pattern.search."""
         if match.groupdict()['url'] is None:
             raise AttributeError
         return cls(**match.groupdict())
 
     @property
-    def parsed_url(self):
+    def parsed_url(self) -> urllib.parse.ParseResult:
+        """Parsed components of the link's HREF value."""
         return urllib.parse.urlparse(self.url)
 
     @property
-    def parsed_url_query(self):
+    def parsed_url_query(self) -> dict[str, list[str]]:
+        """The query of the link's HREF value."""
         return urllib.parse.parse_qs(self.parsed_url.query, keep_blank_values=True)
 
-    def update_url(self, **comps):
+    def update_url(self, **comps) -> 'MarkdownLink':
         """
         Updates the `MarkdownLink.url` according to `comps`.
 
@@ -272,14 +359,16 @@ def update_url(self, **comps):
         return self
 
     def __str__(self):
-        return '[{0.label}]({0.url})'.format(self)
+        return f'[{self.label}]({self.url})'
 
     @classmethod
-    def replace(cls,
-                md: str,
-                repl: typing.Callable,
-                simple: bool = True,
-                markdown_kw: typing.Optional[dict] = None) -> str:
+    def replace(
+            cls,
+            md: str,
+            repl: Callable[['MarkdownLink'], Any],
+            simple: bool = True,
+            markdown_kw: Optional[dict] = None,
+    ) -> str:
         """
         Replace links in a markdown document.
 
@@ -363,7 +452,7 @@ def replace(cls,
                     [label](xyz)
 
                 [label](url)
-       """
+        """
         links = []
         if not simple:
             # We convert the markdown text to HTML and extract the links:
@@ -373,7 +462,7 @@ def replace(cls,
                 links.append((slug(''.join(node.itertext())), node.get(attrib)))
             links = list(reversed(links))
 
-        def repl_wrapper(m):
+        def repl_wrapper(m: re.Match) -> Generator[str, None, None]:
             if m.groupdict()['url'] is None:
                 yield m.string[m.start():m.end()]
                 return
@@ -398,10 +487,11 @@ def repl_wrapper(m):
         return replace_pattern(cls.pattern, repl_wrapper, md)
 
 
-@attr.s
+@dataclasses.dataclass
 class MarkdownImageLink(MarkdownLink):
-    pattern = re.compile(r'!\[(?P<label>.*?)(?<!\\)]\((?P<url>[^)]+)\)')
-    html_link = ('img', 'src')
+    """Image links have a slightly different pattern."""
+    pattern: re.Pattern = re.compile(r'!\[(?P<label>[^]]*)]\((?P<url>[^)]+)\)')
+    html_link: tuple[str, str] = ('img', 'src')
 
     def __str__(self):
-        return '![{0.label}]({0.url})'.format(self)
+        return f'![{self.label}]({self.url})'
diff --git a/src/clldutils/metadata.py b/src/clldutils/metadata.py
index 5d5e2e7..37d5d15 100644
--- a/src/clldutils/metadata.py
+++ b/src/clldutils/metadata.py
@@ -19,17 +19,17 @@
     >>> Metadata.from_jsonld(md.to_jsonld()).publisher.place
     'anywhere'
 """
+from typing import Optional
 import collections
+import dataclasses
 import urllib.parse
 
-import attr
-
 from clldutils import licenses
 
 __all__ = ['Publisher', 'License', 'Metadata']
 
 
-@attr.s
+@dataclasses.dataclass
 class Publisher:
     """
     The entity publishing a dataset.
@@ -39,40 +39,37 @@ class Publisher:
     :ivar url: URL linking to the "homepage" of the publisher.
     :ivar contact: An email address under which to contact the publisher of a dataset.
     """
-    name = attr.ib(
-        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/name"),
+    name: Optional[str] = dataclasses.field(
+        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/name"),  # pylint: disable=R1735
         default=None)
-    place = attr.ib(
-        metadata=dict(ldkey="dc:Location"),
+    place: Optional[str] = dataclasses.field(
+        metadata=dict(ldkey="dc:Location"),  # pylint: disable=R1735
         default=None)
-    url = attr.ib(
-        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/homepage"),
+    url: Optional[str] = dataclasses.field(
+        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/homepage"),  # pylint: disable=R1735
         default=None)
-    contact = attr.ib(
-        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/mbox"),
+    contact: Optional[str] = dataclasses.field(
+        metadata=dict(ldkey="http://xmlns.com/foaf/0.1/mbox"),  # pylint: disable=R1735
         default=None)
 
 
-@attr.s
+@dataclasses.dataclass
 class License:
     """
     The license under which a dataset is published, characterized with name, URL and an icon.
     """
-    name = attr.ib(
-        default="Creative Commons Attribution 4.0 International License")
-    url = attr.ib(
-        default="https://creativecommons.org/licenses/by/4.0/")
-    icon = attr.ib(
-        default="cc-by.png")
-
-    def __attrs_post_init__(self):
+    name: Optional[str] = "Creative Commons Attribution 4.0 International License"
+    url: Optional[str] = "https://creativecommons.org/licenses/by/4.0/"
+    icon: Optional[str] = "cc-by.png"
+
+    def __post_init__(self):
         lic = licenses.find(self.name)
         if lic:
             self.name = lic.name
             self.url = lic.url
 
 
-@attr.s
+@dataclasses.dataclass
 class Metadata:
     """
     Metadata about the published version(s) of a dataset.
@@ -83,14 +80,15 @@ class Metadata:
     :ivar str title: The title of the dataset.
     :ivar str description:
     """
-    publisher = attr.ib(default=Publisher(), validator=attr.validators.instance_of(Publisher))
-    license = attr.ib(default=License(), validator=attr.validators.instance_of(License))
-    url = attr.ib(default=None)
-    title = attr.ib(default=None)
-    description = attr.ib(default=None)
+    publisher: Publisher = dataclasses.field(default_factory=Publisher)
+    license: License = dataclasses.field(default_factory=License)
+    url: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
 
     @classmethod
     def from_jsonld(cls, d, defaults=None):
+        """Create a Metadata instance from JSON-LD."""
         defaults = defaults or {}
         kw = {}
         for k, v in [
@@ -104,9 +102,9 @@ def from_jsonld(cls, d, defaults=None):
         for ldkey, cls_ in [('dc:publisher', Publisher), ('dc:license', License)]:
             ckw = {}
             dd = d.get(ldkey, {})
-            for f in attr.fields(cls_):
-                ckw[f.name] = dd.get(f.metadata.get('ldkey', f.name)) \
-                    or defaults.get('{0}.{1}'.format(ldkey.split(':')[1], f.name))
+            for f in dataclasses.fields(cls_):
+                val = dd.get(f.metadata.get('ldkey', f.name))
+                ckw[f.name] = val or defaults.get(f"{ldkey.split(':')[1]}.{f.name}")
             kw[cls_.__name__.lower()] = cls_(**{k: v for k, v in ckw.items() if v})
         return cls(**kw)
 
@@ -126,7 +124,7 @@ def to_jsonld(self) -> collections.OrderedDict:
         for ldkey, cls_ in [('dc:publisher', Publisher), ('dc:license', License)]:
             obj = getattr(self, ldkey.split(':')[1])
             json = collections.OrderedDict()
-            for f in attr.fields(cls_):
+            for f in dataclasses.fields(cls_):
                 if getattr(obj, f.name):
                     json[f.metadata.get('ldkey', f.name)] = getattr(obj, f.name)
             items.append((ldkey, json))
@@ -134,4 +132,5 @@ def to_jsonld(self) -> collections.OrderedDict:
 
     @property
     def domain(self):
+        """The host part of the url attribute."""
         return urllib.parse.urlparse(self.url).netloc
diff --git a/src/clldutils/misc.py b/src/clldutils/misc.py
index 363d6be..4b7b8d6 100644
--- a/src/clldutils/misc.py
+++ b/src/clldutils/misc.py
@@ -6,25 +6,27 @@
 import re
 import base64
 import string
-import typing
+from typing import Union, Any
 import pathlib
 import warnings
 import mimetypes
 import unicodedata
+from collections.abc import Iterable
 
 __all__ = [
     'data_url', 'log_or_raise', 'nfilter', 'to_binary', 'dict_merged', 'NoDefault', 'NO_DEFAULT',
-    'xmlchars', 'format_size', 'UnicodeMixin', 'slug', 'encoded', 'lazyproperty',
+    'xmlchars', 'format_size', 'slug', 'encoded',
 ]
 
 
-def deprecated(msg):
+def deprecated(msg):  # pragma: no cover
+    """Mark deprecated functionality."""
     warnings.simplefilter('always', DeprecationWarning)
     warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
     warnings.simplefilter('default', DeprecationWarning)
 
 
-def data_url(content: typing.Union[bytes, str, pathlib.Path], mimetype: str = None) -> str:
+def data_url(content: Union[bytes, str, pathlib.Path], mimetype: str = None) -> str:
     """
     Returns content encoded as base64 Data URI. Useful to include (smallish) media resources
     in HTML pages.
@@ -43,8 +45,8 @@ def data_url(content: typing.Union[bytes, str, pathlib.Path], mimetype: str = No
     else:
         if isinstance(content, str):
             content = content.encode('utf8')
-    return "data:{0};base64,{1}".format(
-        mimetype or 'application/octet-stream', base64.b64encode(content).decode())
+    mimetype = mimetype or 'application/octet-stream'
+    return f"data:{mimetype};base64,{base64.b64encode(content).decode()}"
 
 
 def log_or_raise(msg: str, log=None, level='warning', exception_cls=ValueError):
@@ -69,7 +71,7 @@ def log_or_raise(msg: str, log=None, level='warning', exception_cls=ValueError):
         raise exception_cls(msg)
 
 
-def nfilter(seq: typing.Iterable) -> list:
+def nfilter(seq: Iterable[Any]) -> list[Any]:
     """Replacement for python 2's filter(None, seq).
 
     :return: a list filtered from seq containing only truthy items.
@@ -77,7 +79,7 @@ def nfilter(seq: typing.Iterable) -> list:
     return [e for e in seq if e]
 
 
-def to_binary(s: typing.Union[str, bytes], encoding='utf8') -> bytes:
+def to_binary(s: Union[str, bytes], encoding='utf8') -> bytes:
     """Cast function.
 
     :param s: object to be converted to bytes.
@@ -106,8 +108,8 @@ def f(s):
     return d
 
 
-class NoDefault(object):
-
+class NoDefault:  # pylint: disable=too-few-public-methods
+    """A default object for cases, where `None` is considered a regular value."""
     def __repr__(self):
         return '<NoDefault>'
 
@@ -127,7 +129,8 @@ def xmlchars(text: str) -> str:
     invalid = list(range(0x9))
     invalid.extend([0xb, 0xc])
     invalid.extend(range(0xe, 0x20))
-    return re.sub('|'.join('\\x%0.2X' % i for i in invalid), '', text)
+    return re.sub(
+        '|'.join('\\x%0.2X' % i for i in invalid), '', text)  # pylint: disable=C0209
 
 
 def format_size(num: int) -> str:
@@ -141,24 +144,11 @@ def format_size(num: int) -> str:
 
     .. seealso:: `<http://stackoverflow.com/a/1094933>`_
     """
-    for x in ['bytes', 'KB', 'MB', 'GB']:
-        if num < 1024.0 and num > -1024.0:
-            return "%3.1f%s" % (num, x)
+    for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
+        if -1024.0 < num < 1024.0:
+            return f"{num:3.1f}{x}"
         num /= 1024.0
-    return "%3.1f%s" % (num, 'TB')
-
-
-class UnicodeMixin(object):
-    """Portable label mixin."""
-
-    def __unicode__(self):
-        """a human readable label for the object."""
-        return '%s' % self  # pragma: no cover
-
-    def __str__(self):
-        """a human readable label for the object, appropriately encoded (or not)."""
-        deprecated("Use of deprecated class UnicodeMixin! Use object instead.")
-        return self.__unicode__()
+    return f"{num:3.1f}PB"
 
 
 def slug(s: str, remove_whitespace: bool = True, lowercase: bool = True) -> str:
@@ -187,56 +177,19 @@ def slug(s: str, remove_whitespace: bool = True, lowercase: bool = True) -> str:
     return res
 
 
-def encoded(string: typing.Union[str, bytes], encoding='utf-8') -> bytes:
+def encoded(string_: Union[str, bytes], encoding='utf-8') -> bytes:
     """Cast string to bytes in a specific encoding - with some guessing about the encoding.
 
     :param encoding: encoding which the object is forced to
     """
-    assert isinstance(string, (str, bytes))
-    if isinstance(string, str):
-        return string.encode(encoding)
+    assert isinstance(string_, (str, bytes))
+    if isinstance(string_, str):
+        return string_.encode(encoding)
     try:
         # make sure the string can be decoded in the specified encoding ...
-        string.decode(encoding)
-        return string
+        string_.decode(encoding)
+        return string_
     except UnicodeDecodeError:
         # ... if not use latin1 as best guess to decode the string before encoding as
         # specified.
-        return string.decode('latin1').encode(encoding)
-
-
-class lazyproperty(object):
-    """Non-data descriptor caching the computed result as instance attribute.
-
-    .. code-block:: python
-
-        >>> class Spam(object):
-        ...     @lazyproperty
-        ...     def eggs(self):
-        ...         return 'spamspamspam'
-        >>> spam=Spam(); spam.eggs
-        'spamspamspam'
-        >>> spam.eggs='eggseggseggs'; spam.eggs
-        'eggseggseggs'
-        >>> Spam().eggs
-        'spamspamspam'
-        >>> Spam.eggs  # doctest: +ELLIPSIS
-        <...lazyproperty object at 0x...>
-
-    .. note::
-
-        Since Python 3.8 added the `functools.cached_property` decorator
-        (see `<https://docs.python.org/3/library/functools.html#functools.cached_property>`_),
-        this function will be deprecated once Python 3.7 is no longer supported.
-    """
-
-    def __init__(self, fget):
-        self.fget = fget
-        for attr in ('__module__', '__name__', '__doc__'):
-            setattr(self, attr, getattr(fget, attr))
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        result = instance.__dict__[self.__name__] = self.fget(instance)
-        return result
+        return string_.decode('latin1').encode(encoding)
diff --git a/src/clldutils/oaipmh.py b/src/clldutils/oaipmh.py
index 30a6bae..9c60e6e 100644
--- a/src/clldutils/oaipmh.py
+++ b/src/clldutils/oaipmh.py
@@ -1,15 +1,17 @@
 """
 A minimalistic implementation of an OAI-PMH harvester.
 """
-import typing
+from typing import Union, Optional
 import datetime
 import collections
+from collections.abc import Generator
+import dataclasses
 import urllib.parse
 import urllib.request
 from xml.etree import ElementTree
 
-from dateutil.parser import isoparse
-import attr
+from ._compat import fromisoformat
+
 
 __all__ = ['NAMESPACES', 'qname', 'Record', 'iter_records']
 
@@ -25,32 +27,30 @@ def qname(lname: str, prefix: str = 'oai') -> str:
     Returns a qualified name suitable for use with ElementTree's namespace-aware functionality,
     see https://docs.python.org/3/library/xml.etree.elementtree.html#parsing-xml-with-namespaces
     """
-    return '{%s}%s' % (NAMESPACES[prefix], lname)
+    return f'{{{NAMESPACES[prefix]}}}{lname}'
 
 
-@attr.s
+@dataclasses.dataclass
 class Record:
     """
     :ivar identifier: the unique identifier of an item in a repository.
     :ivar oai_dc_metadata: `None` if no `oai_dc` metadata is available, otherwise a `dict` mapping \
     Dublin Core terms (specified as local names) to lists of values.
     """
-    identifier = attr.ib()
-    datestamp = attr.ib(converter=isoparse)
-    metadata = attr.ib(
-        default=None,
-        validator=attr.validators.optional(attr.validators.instance_of(ElementTree.Element)))
-    about = attr.ib(default=attr.Factory(list))
-    sets = attr.ib(default=attr.Factory(list))
-    status = attr.ib(
-        default=None,
-        validator=attr.validators.optional(attr.validators.instance_of(str)))
-    oai_dc_metadata = attr.ib(
-        default=None,
-        validator=attr.validators.optional(attr.validators.instance_of(dict)))
+    identifier: str
+    datestamp: Union[datetime.datetime, str]
+    metadata: Optional[ElementTree.Element] = None
+    about: list = dataclasses.field(default_factory=list)
+    sets: list = dataclasses.field(default_factory=list)
+    status: Optional[str] = None
+    oai_dc_metadata: Optional[dict] = None
+
+    def __post_init__(self):
+        self.datestamp = fromisoformat(self.datestamp)
 
     @classmethod
-    def from_element(cls, e):
+    def from_element(cls, e) -> 'Record':
+        """Parse Record data from xml element."""
         header = e.find(qname('header'))
         md = e.find(qname('metadata'))
         status = header.attrib.get('status')
@@ -75,28 +75,32 @@ def from_element(cls, e):
         )
 
 
-class Response:
+class Response:  # pylint: disable=too-few-public-methods
+    """An OAI-PMH response."""
     def __init__(self, xml):
-        self.xml = ElementTree.fromstring(xml)
-        rt = self.xml.find('.//{}'.format(qname('resumptionToken')))
+        self.xml: ElementTree.Element = ElementTree.fromstring(xml)
+        rt = self.xml.find(f".//{qname('resumptionToken')}")
         if isinstance(rt, ElementTree.Element):
-            self.resumption_token = rt.text
+            self.resumption_token: Optional[str] = rt.text
         else:
             self.resumption_token = None
 
 
-def request(url, params):
+def request(url: str, params: dict) -> Response:
+    """Add params as query to url and request it."""
     parsed_url = list(urllib.parse.urlparse(url))
     parsed_url[4] = urllib.parse.urlencode(params)
     with urllib.request.urlopen(urllib.parse.urlunparse(parsed_url)) as req:
         return Response(req.read().decode('utf8'))
 
 
-def iter_records(baseURL: str,
-                 metadataPrefix: str = 'oai_dc',
-                 from_: typing.Optional[typing.Union[str, datetime.date, datetime.datetime]] = None,
-                 until: typing.Optional[typing.Union[str, datetime.date, datetime.datetime]] = None,
-                 set_: typing.Optional[str] = None) -> typing.Generator[Record, None, None]:
+def iter_records(
+        baseURL: str,  # pylint: disable=invalid-name
+        metadataPrefix: str = 'oai_dc',  # pylint: disable=invalid-name
+        from_: Optional[Union[str, datetime.date, datetime.datetime]] = None,
+        until: Optional[Union[str, datetime.date, datetime.datetime]] = None,
+        set_: Optional[str] = None,
+) -> Generator[Record, None, None]:
     """
     Runs a `ListRecords` request on the specified OAI-PMH repository (using resumption tokens as
     necessary).
@@ -127,7 +131,7 @@ def format_date(d):
             return d
         return d.isoformat()
 
-    params = dict(verb='ListRecords', metadataPrefix=metadataPrefix)
+    params = {'verb': 'ListRecords', 'metadataPrefix': metadataPrefix}
     if from_:
         params['from'] = format_date(from_)
     if until:
@@ -136,7 +140,7 @@ def format_date(d):
         params['set'] = set_
     res = request(baseURL, params)
     while res:
-        for e in res.xml.findall('.//{}'.format(qname('record'))):
+        for e in res.xml.findall(f".//{qname('record')}"):
             yield Record.from_element(e)
-        res = request(baseURL, dict(verb='ListRecords', resumptionToken=res.resumption_token)) \
+        res = request(baseURL, {'verb': 'ListRecords', 'resumptionToken': res.resumption_token}) \
             if res.resumption_token else None
diff --git a/src/clldutils/paginate.py b/src/clldutils/paginate.py
index 54dfce7..e1227cb 100644
--- a/src/clldutils/paginate.py
+++ b/src/clldutils/paginate.py
@@ -1,3 +1,4 @@
+# pylint: skip-file
 """
 Page class based on the `paginate` package.
 
@@ -225,8 +226,8 @@ def __init__(self, collection, page=1, items_per_page=20, item_count=None,
             last = first + items_per_page
             self.items = list(self.collection[first:last])
         except (TypeError, KeyError):
-            raise TypeError("Your collection of type {} cannot be handled "
-                            "by paginate.".format(type(self.collection)))
+            raise TypeError(f"Your collection of type {type(self.collection)} cannot be "
+                            f"handled by paginate.")
 
         # Unless the user tells us how many items the collections has
         # we calculate that ourselves.
diff --git a/src/clldutils/path.py b/src/clldutils/path.py
index 450b107..e5c97ff 100644
--- a/src/clldutils/path.py
+++ b/src/clldutils/path.py
@@ -9,6 +9,7 @@
 import os
 import sys
 import mmap
+import types
 import shutil
 import hashlib
 import pathlib
@@ -16,20 +17,20 @@
 import importlib
 import contextlib
 import subprocess
-import typing
 import unicodedata
-
-from clldutils.misc import deprecated
+from typing import Union, Optional, Literal
+from collections.abc import Generator, Iterable
 
 __all__ = [
     'ensure_cmd', 'sys_path', 'memorymapped', 'import_module',
-    'readlines', 'move', 'walk', 'md5', 'Manifest', 'git_describe', 'TemporaryDirectory',
+    'readlines', 'walk', 'md5', 'Manifest', 'git_describe', 'TemporaryDirectory',
 ]
 
 Path = pathlib.Path  # keep for backwards compatibility.
+PathType = Union[str, pathlib.Path]
 
 
-def ensure_cmd(cmd, **kw) -> str:
+def ensure_cmd(cmd: str, **kw) -> str:
     """
     Make sure an executable is installed and return its full path.
 
@@ -38,12 +39,12 @@ def ensure_cmd(cmd, **kw) -> str:
     """
     cmd_ = shutil.which(cmd, **kw)
     if not cmd_:
-        raise ValueError('The command {} must be installed!'.format(cmd))
+        raise ValueError(f'The command {cmd} must be installed!')
     return cmd_
 
 
 @contextlib.contextmanager
-def sys_path(p):
+def sys_path(p: PathType):
     """
     Context manager providing a context with path `p` appended to `sys.path`.
 
@@ -55,7 +56,7 @@ def sys_path(p):
 
 
 @contextlib.contextmanager
-def memorymapped(filename: typing.Union[str, pathlib.Path], access=mmap.ACCESS_READ) -> mmap.mmap:
+def memorymapped(filename: PathType, access=mmap.ACCESS_READ) -> Generator[mmap.mmap, None, None]:
     """
     Context manager to access a memory mapped file.
 
@@ -72,10 +73,11 @@ def memorymapped(filename: typing.Union[str, pathlib.Path], access=mmap.ACCESS_R
         f.close()
 
 
-def import_module(p: pathlib.Path) -> type(os):
+def import_module(p: PathType) -> types.ModuleType:
     """
     Import a python module from anywhere in the filesystem.
     """
+    p = Path(p)
     with sys_path(p.parent):
         m = importlib.import_module(p.stem)
         if Path(m.__file__).parent not in [p.parent, p]:
@@ -84,50 +86,23 @@ def import_module(p: pathlib.Path) -> type(os):
         return m
 
 
-def path_component(s, encoding='utf-8'):
-    deprecated('With PY3 path components are always `str`')
-    if isinstance(s, bytes):
-        s = s.decode(encoding)
-    return s
-
-
-def as_unicode(p, encoding='utf-8'):
-    deprecated("Use of deprecated function as_unicode! Use str() instead.")
-    return '%s' % p
-
-
-def as_posix(p):
+def as_posix(p) -> str:
+    """Used as one way to get a string representation of a Path."""
     if hasattr(p, 'as_posix'):
         return p.as_posix()
-    elif isinstance(p, str):
+    if isinstance(p, str):
         return Path(p).as_posix()
     raise ValueError(p)
 
 
-def remove(p):
-    deprecated('Use of deprecated function remove! Use Path.unlink instead.')
-    Path(p).unlink()
-
-
-def read_text(p, encoding='utf8', **kw):
-    deprecated("Use of deprecated function read_text! Use Path.read_text instead.")
-    with Path(p).open(encoding=encoding, **kw) as fp:
-        return fp.read()
-
-
-def write_text(p, text, encoding='utf8', **kw):
-    deprecated("Use of deprecated function write_text! Use Path.write_text instead.")
-    with Path(p).open('w', encoding=encoding, **kw) as fp:
-        return fp.write(text)
-
-
-def readlines(p: typing.Union[pathlib.Path, str, list, tuple],
-              encoding: typing.Optional[str] = None,
-              strip: bool = False,
-              comment: typing.Optional[str] = None,
-              normalize: typing.Optional[str] = None,
-              linenumbers: bool = False) \
-        -> typing.List[typing.Union[typing.Tuple[int, str], str]]:
+def readlines(  # pylint: disable=R0917,R0913
+        p: Union[PathType, Iterable[str]],
+        encoding: Optional[str] = None,
+        strip: bool = False,
+        comment: Optional[str] = None,
+        normalize: Optional[Literal["NFC", "NFD", "NFKC", "NFKD"]] = None,
+        linenumbers: bool = False,
+) -> list[Union[tuple[int, str], str]]:
     """
     Read a `list` of lines from a text file (or iterable of lines).
 
@@ -142,11 +117,13 @@ def readlines(p: typing.Union[pathlib.Path, str, list, tuple],
     """
     if comment:
         strip = True
-    if isinstance(p, (list, tuple)):
-        res = [line.decode(encoding) if encoding else line for line in p]
-    else:
+    res = []
+    try:
         with Path(p).open(encoding=encoding or 'utf-8') as fp:
             res = fp.readlines()
+    except TypeError:
+        res = [line.decode(encoding) if encoding else line for line in p]
+
     if strip:
         res = [line.strip() or None for line in res]
     if comment:
@@ -154,35 +131,15 @@ def readlines(p: typing.Union[pathlib.Path, str, list, tuple],
     if normalize:
         res = [unicodedata.normalize(normalize, line) if line else line for line in res]
     if linenumbers:
-        return [(n, line) for n, line in enumerate(res, start=1)]
+        return list(enumerate(res, start=1))
     return [line for line in res if line is not None]
 
 
-def rmtree(p, **kw):
-    deprecated("Use of deprecated function rmtree! Use shutil.rmtree instead.")
-    return shutil.rmtree(p, **kw)
-
-
-def move(src, dst):
-    """
-    Functionality of `shutil.move` accepting `pathlib.Path` as input.
-
-    .. seealso:: `<https://bugs.python.org/issue39140>`_
-    """
-    return shutil.move(str(src), str(dst))
-
-
-def copy(src, dst):
-    deprecated("Use of deprecated function copy! Use shutil.copy instead.")
-    return shutil.copy(src, dst)
-
-
-def copytree(src, dst, **kw):
-    deprecated("Use of deprecated function copytree! Use shutil.copytree instead.")
-    return shutil.copytree(src, dst, **kw)
-
-
-def walk(p, mode='all', **kw) -> typing.Generator[pathlib.Path, None, None]:
+def walk(
+        p: PathType,
+        mode: Literal["all", "files", "dirs"] = 'all',
+        **kw
+) -> Generator[pathlib.Path, None, None]:
     """Wrapper for `os.walk`, yielding `Path` objects.
 
     :param p: root of the directory tree to walk.
@@ -199,7 +156,7 @@ def walk(p, mode='all', **kw) -> typing.Generator[pathlib.Path, None, None]:
                 yield Path(dirpath).joinpath(fname)
 
 
-def md5(p: typing.Union[pathlib.Path, str], bufsize: int = 32768) -> str:
+def md5(p: PathType, bufsize: int = 32768) -> str:
     """
     Compute md5 sum of the content of a file.
     """
@@ -220,20 +177,21 @@ class Manifest(dict):
     """
 
     @classmethod
-    def from_dir(cls, d, relative_to=None):
+    def from_dir(cls, d: PathType, relative_to: PathType = None) -> 'Manifest':
+        """Creates Manifest for all files in d."""
         d = Path(d)
         assert d.is_dir()
         return cls((str(p.relative_to(relative_to or d)), md5(p)) for p in walk(d, mode='files'))
 
     def __str__(self):
-        return '\n'.join('{0}  {1}'.format(v, k) for k, v in sorted(self.items()))
+        return '\n'.join(f'{v}  {k}' for k, v in sorted(self.items()))
 
-    def write(self, outdir=None):
-        Path(outdir or '.').joinpath('manifest-md5.txt').write_text(
-            '{0}'.format(self), encoding='utf8')
+    def write(self, outdir: Optional[PathType] = None):
+        """Write manifest to a directory."""
+        Path(outdir or '.').joinpath('manifest-md5.txt').write_text(f'{self}', encoding='utf8')
 
 
-def git_describe(dir_, git_command='git'):
+def git_describe(dir_: PathType, git_command='git') -> str:
     """
     Run `git describe --always --tags` on a directory.
 
@@ -245,14 +203,13 @@ def git_describe(dir_, git_command='git'):
     dir_ = dir_.resolve()
     cmd = [
         ensure_cmd(git_command),
-        '--git-dir=%s' % dir_.joinpath('.git'), 'describe', '--always', '--tags']
+        f"--git-dir={dir_.joinpath('.git')}", 'describe', '--always', '--tags']
     try:
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = p.communicate()
-        if p.returncode == 0:
+        with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+            stdout, stderr = p.communicate()
+            if p.returncode != 0:
+                raise ValueError(stderr)
             res = stdout.strip()  # pragma: no cover
-        else:
-            raise ValueError(stderr)
     except (ValueError, FileNotFoundError):
         res = dir_.name
     if not isinstance(res, str):
diff --git a/src/clldutils/sfm.py b/src/clldutils/sfm.py
index 0ed8541..b7ada45 100644
--- a/src/clldutils/sfm.py
+++ b/src/clldutils/sfm.py
@@ -25,9 +25,12 @@
 """
 
 import re
-import typing
+from typing import Optional, Callable, Union
 import pathlib
 import collections
+from collections.abc import Generator
+
+from .path import PathType
 
 __all__ = ['Entry', 'SFM']
 
@@ -36,7 +39,7 @@
 FIELD_SPLITTER_PATTERN = re.compile(r';\s+')
 
 
-def marker_split(block: str) -> typing.Generator[typing.Tuple[str, str], None, None]:
+def marker_split(block: str) -> Generator[tuple[str, str], None, None]:
     """
     Yield marker, value pairs from a text block (i.e. a list of lines).
 
@@ -67,7 +70,8 @@ class Entry(list):
     """We store entries in SFM files as lists of (marker, value) pairs."""
 
     @classmethod
-    def from_string(cls, block, keep_empty=False):
+    def from_string(cls, block: str, keep_empty: bool = False):
+        """Create an entry from a block of text."""
         entry = cls()
         for marker, value in marker_split(block.strip()):
             value = value.strip()
@@ -88,26 +92,26 @@ def get(self, key, default=None) -> str:
                 return v
         return default
 
-    def getall(self, key) -> typing.List[str]:
+    def getall(self, key) -> list[str]:
         """Retrieve all values for a marker."""
         return [v for k, v in self if k == key]
 
     def __str__(self):
-        lines = []
-        for key, value in self:
-            lines.append('%s %s' % (key, value))
-        return '\n'.join('\\' + line for line in lines)
+        return '\n'.join('\\' + line for line in (f'{key} {value}' for key, value in self))
 
 
-def parse(content,
-          encoding: str = 'utf-8',
-          entry_sep: str = '\n\n',
-          entry_prefix: typing.Optional[str] = None,
-          keep_empty=False):
+def parse(
+        content: Union[str, pathlib.Path],
+        encoding: str = 'utf-8',
+        entry_sep: str = '\n\n',
+        entry_prefix: Optional[str] = None,
+        keep_empty=False,
+) -> Generator[list[tuple[str, str]], None, None]:
+    """Parse lists of (marker, value) pairs from content."""
     entry_prefix = entry_prefix or entry_sep
 
     if isinstance(content, pathlib.Path):
-        with pathlib.Path(content).open('r', encoding=encoding, newline=None) as fp:
+        with content.open('r', encoding=encoding, newline=None) as fp:
             content = fp.read()
 
     assert isinstance(content, str)
@@ -132,7 +136,7 @@ class SFM(list):
     """
 
     @classmethod
-    def from_file(cls, filename, **kw):
+    def from_file(cls, filename: PathType, **kw):
         """
         Initialize a `SFM` object from the contents of a file.
         """
@@ -141,11 +145,12 @@ def from_file(cls, filename, **kw):
         return sfm
 
     @classmethod
-    def from_string(cls,
-                    text: str,
-                    marker_map: typing.Optional[typing.Dict[str, str]] = None,
-                    entry_impl=Entry,
-                    **kw):
+    def from_string(
+            cls,
+            text: str,
+            marker_map: Optional[dict[str, str]] = None,
+            entry_impl: type = Entry,
+            **kw):
         """
         Initialize a `SFM` object from a SFM formatted string.
         """
@@ -156,14 +161,15 @@ def from_string(cls,
                 sfm.append(entry_impl([(marker_map.get(k, k), v) for k, v in entry]))
         return sfm
 
-    def read(self,
-             filename,
-             encoding='utf-8',
-             marker_map: typing.Optional[typing.Dict[str, str]] = None,
-             entry_impl=Entry,
-             entry_sep: str = '\n\n',
-             entry_prefix: typing.Optional[str] = None,
-             keep_empty: bool = False):
+    def read(  # pylint: disable=R0913,R0917
+            self,
+            filename: PathType,
+            encoding='utf-8',
+            marker_map: Optional[dict[str, str]] = None,
+            entry_impl=Entry,
+            entry_sep: str = '\n\n',
+            entry_prefix: Optional[str] = None,
+            keep_empty: bool = False):
         """Extend the entry list by parsing new entries from a file.
 
         :param filename:
@@ -183,14 +189,14 @@ def read(self,
             if entry:
                 self.append(entry_impl([(marker_map.get(k, k), v) for k, v in entry]))
 
-    def visit(self, visitor: typing.Callable):
+    def visit(self, visitor: Callable[[Entry], Entry]):
         """
         Run `visitor` on each entry.
         """
         for i, entry in enumerate(self):
             self[i] = visitor(entry) or entry
 
-    def write(self, filename, encoding='utf-8'):
+    def write(self, filename: PathType, encoding='utf-8'):
         """Write the list of entries to a file.
 
         :param filename:
diff --git a/src/clldutils/source.py b/src/clldutils/source.py
index 4b0615b..5d2600a 100644
--- a/src/clldutils/source.py
+++ b/src/clldutils/source.py
@@ -3,9 +3,10 @@
 describing sources of data/research.
 """
 import re
-import typing
+from typing import Optional
 import itertools
 import collections
+from collections.abc import Iterable
 
 from pylatexenc.latex2text import LatexNodes2Text
 from bibtexparser.middlewares import names
@@ -52,7 +53,7 @@ def __init__(self,
                  *args,
                  _check_id: bool = True,
                  _lowercase: bool = False,
-                 _strip_tex: typing.Optional[typing.Iterable[str]] = None,
+                 _strip_tex: Optional[Iterable[str]] = None,
                  **kw):
         """
         :param kw: Fields of the bibliographical record as key-value pairs.
@@ -70,8 +71,7 @@ def __init__(self,
                 k: LatexNodes2Text().latex_to_text(v) if k.lower() in _strip_tex else v
                 for k, v in kw.items()}
         self.id = id_
-        super(Source, self).__init__(
-            *args, **{k.lower() if _lowercase else k: v for k, v in kw.items()})
+        super().__init__(*args, **{k.lower() if _lowercase else k: v for k, v in kw.items()})
 
     def __bool__(self):  # pragma: no cover
         return True
@@ -82,7 +82,7 @@ def __str__(self):
         return self.text()
 
     def __repr__(self):
-        return '<%s %s>' % (self.__class__.__name__, self.id)
+        return f'<{self.__class__.__name__} {self.id}>'
 
     @classmethod
     def from_entry(cls, key: str, entry, **_kw) -> 'Source':
@@ -93,15 +93,19 @@ def from_entry(cls, key: str, entry, **_kw) -> 'Source':
         :param entry: `pybtex.database.Entry`
         :param _kw: Keyword arguments passed through to `cls.__init__`
         """
-        _kw.update({k: v for k, v in entry.fields.items()})
+        _kw.update(entry.fields.items())
         for role in (entry.persons or []):
             if entry.persons[role]:
-                _kw[role] = ' and '.join('%s' % p for p in entry.persons[role])
+                _kw[role] = ' and '.join(str(p) for p in entry.persons[role])
         return cls(entry.type, key, **_kw)
 
     @classmethod
-    def from_bibtex(cls, bibtexString: str, lowercase: bool = False, _check_id: bool = True) \
-            -> 'Source':
+    def from_bibtex(
+            cls,
+            bibtex_string: str,
+            lowercase: bool = False,
+            _check_id: bool = True,
+    ) -> 'Source':
         """
         Initialize a `Source` object from the data in a BibTeX record.
 
@@ -114,28 +118,28 @@ def from_bibtex(cls, bibtexString: str, lowercase: bool = False, _check_id: bool
             and feed `pybtex.database.Entry` objects to :meth:`Source.from_entry`.
         """
         source = None
-        lines = bibtexString.strip().split('\n')
+        lines = bibtex_string.strip().split('\n')
 
         # genre and key are parsed from the @-line:
-        atLine = re.compile(r"^@(?P<genre>[a-zA-Z_]+)\s*{\s*(?P<key>[^,]*)\s*,\s*")
+        at_line = re.compile(r"^@(?P<genre>[a-zA-Z_]+)\s*{\s*(?P<key>[^,]*)\s*,\s*")
 
         # since all key-value pairs fit on one line, it's easy to determine the
         # end of the value: right before the last closing brace!
-        fieldLine = re.compile(r'\s*(?P<field>[a-zA-Z_]+)\s*=\s*({|")(?P<value>.+)')
+        field_line = re.compile(r'\s*(?P<field>[a-zA-Z_]+)\s*=\s*({|")(?P<value>.+)')
 
-        endLine = re.compile(r"}\s*")
+        end_line = re.compile(r"}\s*")
 
         while lines:
             line = lines.pop(0)
             if not source:
-                m = atLine.match(line)
+                m = at_line.match(line)
                 if m:
                     source = cls(
                         m.group('genre').strip().lower(),
                         m.group('key').strip(),
                         _check_id=_check_id)
             else:
-                m = fieldLine.match(line)
+                m = field_line.match(line)
                 if m:
                     value = m.group('value').strip()
                     if value.endswith(','):
@@ -146,7 +150,7 @@ def from_bibtex(cls, bibtexString: str, lowercase: bool = False, _check_id: bool
                             field = field.lower()
                         source[field] = value[:-1].strip()
                 else:
-                    m = endLine.match(line)
+                    m = end_line.match(line)
                     if m:
                         break
                     # Note: fields with names not matching the expected pattern are simply
@@ -155,7 +159,8 @@ def from_bibtex(cls, bibtexString: str, lowercase: bool = False, _check_id: bool
         return source
 
     @staticmethod
-    def split_names(s: str) -> typing.List[names.NameParts]:
+    def split_names(s: str) -> list[names.NameParts]:
+        """Splits string like author lists."""
         def _split(ss):
             return [
                 names.parse_single_name_into_parts(n[:-1].strip() if n.endswith(',') else n)
@@ -166,25 +171,32 @@ def _split(ss):
         except names.InvalidNameError:  # pragma: no cover
             # Fix initials which are not properly terminated.
             # e.g "Hall, T. A and Hildebrandt, Kristine A and Bickel, Balthasar"
-            return _split(re.sub(
-                '(?P<initial>[A-Z]) ', lambda m: '{}. '.format(m.group('initial')), s))
+            return _split(re.sub('(?P<initial>[A-Z]) ', lambda m: f"{m.group('initial')}. ", s))
 
     @staticmethod
     def reformat_names(s: str) -> str:
+        """
+        Reformats names using <first last> format.
+
+        .. code-block:: python
+
+            >>> Source.reformat_names('Max Meier and Müller, Hans')
+            'Meier, Max & Hans Müller'
+        """
         res = ''
-        names = Source.split_names(s)
-        for i, nameparts in enumerate(names):
+        names_ = Source.split_names(s)
+        for i, nameparts in enumerate(names_):
             if i == 0:
                 first = ''
                 if nameparts.first:
                     first += ' '.join(nameparts.first)
                 if nameparts.von:
-                    first += ' {}'.format(' '.join(nameparts.von))
+                    first += f" {' '.join(nameparts.von)}"
                 if nameparts.jr:
-                    first += ', {}'.format(' '.join(nameparts.jr))
-                res += '{}{}'.format(' '.join(nameparts.last), ', ' + first if first else '')
+                    first += f", {' '.join(nameparts.jr)}"
+                res += f"{' '.join(nameparts.last)}{', ' + first if first else ''}"
             else:
-                res += ' & ' if i + 1 == len(names) else ', '
+                res += ' & ' if i + 1 == len(names_) else ', '
                 res += nameparts.merge_first_name_first
         return res
 
@@ -195,9 +207,9 @@ def bibtex(self) -> str:
         :return: string encoding the source in BibTeX syntax.
         """
         m = max(itertools.chain(map(len, self), [0]))
-        fields = ("  %s = {%s}" % (k.ljust(m), self[k]) for k in self)
-        return "@%s{%s,\n%s\n}" % (
-            getattr(self.genre, 'value', self.genre), self.id, ",\n".join(fields))
+        fields = ',\n'.join(f"  {k.ljust(m)} = {{{self[k]}}}" for k in self)
+        genre = getattr(self.genre, 'value', self.genre)
+        return f"@{genre}{{{self.id},\n{fields}\n}}"
 
     _genre_note = {
         'phdthesis': 'dissertation',
@@ -205,17 +217,39 @@ def bibtex(self) -> str:
         'unpublished': 'unpublished',
     }
 
-    def get_with_translation(self, key):
+    def get_with_translation(self, key: str) -> str:
+        """Return the value for a key, possibly with an english translation."""
         res = self.get(key)
         if res and self.get(key + '_english'):
-            res = '{0} [{1}]'.format(res, self.get(key + '_english'))
+            res = f'{res} [{self.get(key + "_english")}]'
         return res
 
     @property
-    def norm_pages(self):
+    def norm_pages(self) -> str:
+        """Replace the LaTeX double-hyphen used for page ranges with single hyphen."""
         return (self.get('pages') or '').replace('--', '–')
 
-    def text(self, markdown=False) -> str:
+    @staticmethod
+    def _fmt_edition(e):
+        try:
+            e = int(e)
+            return "%d%s" % (  # pylint: disable=consider-using-f-string
+                e, "tsnrhtdd"[(e // 10 % 10 != 1) * (e % 10 < 4) * e % 10::4])
+        except ValueError:  # pragma: no cover
+            return e
+
+    @staticmethod
+    def _italicized(s, markdown):
+        if not s:
+            return s  # pragma: no cover
+        return f'_{s}_' if markdown else s
+
+    @staticmethod
+    def _doi(s, markdown):
+        doi_ = f'[{s}](https://doi.org/{s})' if markdown else s
+        return f'doi: {doi_}'
+
+    def text(self, markdown=False) -> str:  # pylint: disable=too-many-branches
         """
         Linearize the bib source according to the rules of the unified style.
 
@@ -229,110 +263,42 @@ def text(self, markdown=False) -> str:
 
             `<https://www.linguisticsociety.org/sites/default/files/style-sheet_0.pdf>`_
         """
-        def fmt_edition(e):
-            try:
-                e = int(e)
-                return "%d%s" % (e, "tsnrhtdd"[(e // 10 % 10 != 1) * (e % 10 < 4) * e % 10::4])
-            except ValueError:  # pragma: no cover
-                return e
-
-        def italicized(s):
-            if not s:
-                return s  # pragma: no cover
-            return '_{}_'.format(s) if markdown else s
-
         genre = getattr(self.genre, 'value', self.genre)
-        pages_at_end = genre in (
-            'book',
-            'phdthesis',
-            'mastersthesis',
-            'misc',
-            'techreport')
+        pages_at_end = genre in ('book', 'phdthesis', 'mastersthesis', 'misc', 'techreport')
         thesis = genre in ('phdthesis', 'mastersthesis')
 
+        editors = None
         if self.get('editor'):
             editors = self['editor'] if self.get('author') else self.reformat_names(self['editor'])
             affix = 'eds' if ' and ' in editors or '&' in editors else 'ed'
-            editors = " %s (%s.)" % (editors, affix)
-        else:
-            editors = None
+            editors = f" {editors} ({affix}.)"
 
         res = [
             self.reformat_names(self['author']) if self.get('author') else editors,
             self.get('year', 'n.d')]
-        if genre == 'book':  # book title in italics.
-            res.append(
-                italicized(
-                    self.get_with_translation('booktitle') or  # noqa: W504
-                    self.get_with_translation('title')))
-            series = ', '.join(filter(
-                None, [self.get('series'), self.get('volume', self.get('number'))]))
-            if series:
-                res.append('(%s.)' % series)
-        elif genre == 'misc':
-            # in case of misc records, we use the note field in case a title is missing.
-            res.append(self.get_with_translation('title') or self.get('note'))
-        else:  # Dissertation title in italics.
-            res.append(
-                italicized(self.get_with_translation('title'))
-                if genre == 'phdthesis' else self.get_with_translation('title'))
+        self._format_title(res, markdown, genre)
 
         if genre == 'article':
-            # journal in italics!
-            atom = ' '.join(filter(None, [italicized(self.get('journal')), self.get('volume')]))
-            if self.get('issue') or self.get('number'):
-                atom += '(%s)' % (self.get('issue') or self.get('number'))
-            res.append(atom)
-            if self.get('pages'):
-                res.append(self.norm_pages)
-            if self.get('doi'):
-                res.append('doi: {}'.format(
-                    '[{0}](https://doi.org/{0})'.format(self['doi']) if markdown else self['doi']))
+            self._format_article(res, markdown)
         elif genre in {'incollection', 'inproceedings', 'inbook'}:
-            prefix = 'In'
-            atom = ''
-            if editors:
-                atom += editors
-            if self.get('booktitle'):
-                if atom:
-                    atom += ','
-                atom += " %s" % italicized(self.get_with_translation('booktitle'))
-            if self.get('pages'):
-                atom += ", %s" % self.norm_pages
-            if atom:
-                res.append(prefix + atom)
+            self._format_in(res, markdown, editors)
         else:
-            # check for author to make sure we haven't included the editors yet.
-            if editors and self.get('author'):
-                res.append("In %s" % editors)
-
-            for attr in [
-                'journal',
-                'volume' if genre != 'book' else None,
-            ]:
-                if attr and self.get(attr):
-                    res.append(self.get(italicized(attr) if attr == 'journal' else attr))
-
-            if self.get('issue'):
-                res.append("(%s)" % self['issue'])
-
-            if not pages_at_end and self.get('pages'):  # pragma: no cover
-                res.append(self.norm_pages)
+            self._format_rest(res, markdown, genre, editors, pages_at_end)
 
         thesis_handled = False
         if thesis and self.get('school'):
-            res.append('{}{} {}'.format(
-                '{}: '.format(self['address']) if self.get('address') else '',
+            res.append('{}{} {}'.format(  # pylint: disable=consider-using-f-string
+                f"{self['address']}: " if self.get('address') else '',
                 self['school'],
                 self._genre_note.get(genre)))
             if self.get('pages'):
-                res.append('({}pp.)'.format(self.norm_pages))
+                res.append(f'({self.norm_pages}pp.)')
             thesis_handled = True
         elif self.get('publisher'):
             if self.get('edition'):
-                res.append('{} edn'.format(fmt_edition(self.get('edition'))))
+                res.append(f"{self._fmt_edition(self.get('edition'))} edn")
             publisher = self.get('publisher')
-            if self.get('address') and publisher.startswith('{}:'.format(self['address'])):
+            if self.get('address') and publisher.startswith(f"{self['address']}:"):
                 res.append(self['publisher'])
             else:
                 res.append(": ".join(filter(None, [self.get('address'), self['publisher']])))
@@ -345,16 +311,79 @@ def italicized(s):
 
         if genre != 'article':
             if self.get('doi'):
-                res.append('doi: {}'.format(
-                    '[{0}](https://doi.org/{0})'.format(self['doi']) if markdown else self['doi']))
+                res.append(self._doi(self['doi'], markdown))
 
         note = self.get('note') or (self._genre_note.get(genre) if not thesis_handled else '')
         if note and note not in res:
             if thesis:
                 joiner = ','
                 if self.get('pages'):
-                    note += '{0} {1}pp.'.format(joiner, self.norm_pages)
-            res.append('(%s)' % note)
+                    note += f'{joiner} {self.norm_pages}pp.'
+            res.append(f'({note})')
+
+        return ' '.join(x if x.endswith(('.', '.)')) else f'{x}.' for x in res if x).strip()
+
+    def _format_title(self, res, markdown, genre):
+        if genre == 'book':  # book title in italics.
+            res.append(
+                self._italicized(
+                    self.get_with_translation('booktitle') or  # noqa: W504
+                    self.get_with_translation('title'),
+                    markdown))
+            series = ', '.join(filter(
+                None, [self.get('series'), self.get('volume', self.get('number'))]))
+            if series:
+                res.append(f'({series}.)')
+        elif genre == 'misc':
+            # in case of misc records, we use the note field in case a title is missing.
+            res.append(self.get_with_translation('title') or self.get('note'))
+        else:  # Dissertation title in italics.
+            res.append(
+                self._italicized(self.get_with_translation('title'), markdown)
+                if genre == 'phdthesis' else self.get_with_translation('title'))
 
-        return ' '.join(
-            x if x.endswith(('.', '.)')) else '%s.' % x for x in res if x).strip()
+    def _format_article(self, res, markdown):
+        # journal in italics!
+        atom = ' '.join(
+            filter(None, [self._italicized(self.get('journal'), markdown), self.get('volume')]))
+        if self.get('issue') or self.get('number'):
+            atom += f"({self.get('issue') or self.get('number')})"
+        res.append(atom)
+        if self.get('pages'):
+            res.append(self.norm_pages)
+        if self.get('doi'):
+            res.append(self._doi(self['doi'], markdown))
+
+    def _format_in(self, res, markdown, editors):
+        prefix = 'In'
+        atom = ''
+        if editors:
+            atom += editors
+        if self.get('booktitle'):
+            if atom:
+                atom += ','
+            atom += f" {self._italicized(self.get_with_translation('booktitle'), markdown)}"
+        if self.get('pages'):
+            atom += f", {self.norm_pages}"
+        if atom:
+            res.append(prefix + atom)
+
+    def _format_rest(  # pylint: disable=R0913,R0917
+            self, res, markdown, genre, editors, pages_at_end):
+        # check for author to make sure we haven't included the editors yet.
+        if editors and self.get('author'):
+            res.append(f"In {editors}")
+
+        for attr in [
+            'journal',
+            'volume' if genre != 'book' else None,
+        ]:
+            if attr and self.get(attr):
+                res.append(self.get(
+                    self._italicized(attr, markdown) if attr == 'journal' else attr))
+
+        if self.get('issue'):
+            res.append(f"({self['issue']})")
+
+        if not pages_at_end and self.get('pages'):  # pragma: no cover
+            res.append(self.norm_pages)
diff --git a/src/clldutils/svg.py b/src/clldutils/svg.py
index 3cc0276..75cf886 100644
--- a/src/clldutils/svg.py
+++ b/src/clldutils/svg.py
@@ -2,46 +2,45 @@
 Provides functionality to create simple SVG icons or pie charts which can be used as map markers
 e.g. with leaflet.
 """
+import dataclasses
 import math
-import typing
+from typing import Optional, Union
 from xml.sax.saxutils import escape
 
 import clldutils.misc
 import clldutils.color
-
 from clldutils.color import rgb_as_hex
 
 __all__ = ['svg', 'data_url', 'icon', 'pie']
 
 
-def svg(content: str,
-        height: typing.Optional[int] = None,
-        width: typing.Optional[int] = None) -> str:
+def svg(content: str, height: Optional[int] = None, width: Optional[int] = None) -> str:
     """
     Wrap `content` (some SVG XML) into a `svg` element with optional dimension attributes.
 
     :return: The full SVG XML as string.
     """
-    height = ' height="{0}"'.format(height) if height else ''
-    width = ' width="{0}"'.format(width) if width else ''
-    return """\
+    height = f' height="{height}"' if height else ''
+    width = f' width="{width}"' if width else ''
+    return f"""\
 <svg  xmlns="http://www.w3.org/2000/svg"
-      xmlns:xlink="http://www.w3.org/1999/xlink"{0}{1}>
-  {2}
-</svg>""".format(height, width, content)
+      xmlns:xlink="http://www.w3.org/1999/xlink"{height}{width}>
+  {content}
+</svg>"""
 
 
-def style(stroke=None, fill=None, stroke_width='1px', opacity=None):
+def style(stroke: str = None, fill: str = None, stroke_width: str = '1px', opacity=None) -> str:
+    """SVG style spec."""
     res = ''
     if fill:
-        res += 'fill:{0};'.format(fill)
+        res += f'fill:{fill};'
     if stroke:
-        res += 'stroke:{0};stroke-width:{1};stroke-linecap:round;stroke-linejoin:round;'\
-            .format(stroke, stroke_width)
+        res += (f'stroke:{stroke};stroke-width:{stroke_width};'
+                f'stroke-linecap:round;stroke-linejoin:round;')
     else:
         res += 'stroke:none;'
     if opacity:
-        res += 'opacity:{0};'.format(opacity)
+        res += f'opacity:{opacity};'
     return res
 
 
@@ -68,16 +67,34 @@ def icon(spec: str, opacity=None) -> str:
         'f': 'path d="M2 4 L38 4 L20 35 L2 4"',
         't': 'path d="M2 36 L38 36 L20 5 L2 36"',
     }
-    elem = '<{0} style="{1}"/>'.format(
-        paths[spec[0]], style(stroke='black', fill=rgb_as_hex(spec[1:]), opacity=opacity))
-    return svg(elem, height=40, width=40)
+    style_ = style(stroke='black', fill=rgb_as_hex(spec[1:]), opacity=opacity)
+    return svg(f'<{paths[spec[0]]} style="{style_}"/>', height=40, width=40)
+
 
+@dataclasses.dataclass
+class PieSpec:
+    """Pie specified by center and radius."""
+    cx: float
+    cy: float
+    r: float
+    current_angle_rad: float = 0.0
 
-def pie(data: typing.List[typing.Union[float, int]],
-        colors: typing.Optional[typing.List[str]] = None,
-        titles: typing.Optional[typing.List[str]] = None,
+    def endpoint(self):
+        """
+        Calculate position of point on circle given an angle, a radius, and the location
+        of the center of the circle Zero line points west.
+        """
+        return (round(self.cx - (self.r * math.cos(self.current_angle_rad)), 1),
+                round(self.cy - (self.r * math.sin(self.current_angle_rad)), 1))
+
+
+def pie(
+        data: list[Union[float, int]],
+        colors: Optional[list[str]] = None,
+        titles: Optional[list[str]] = None,
         width: int = 34,
-        stroke_circle: bool = False) -> str:
+        stroke_circle: bool = False,
+) -> str:
     """
     An SVG pie chart.
 
@@ -93,47 +110,44 @@ def pie(data: typing.List[typing.Union[float, int]],
     assert len(data) == len(colors)
     zipped = [(d, c) for d, c in zip(data, colors) if d != 0]
     data, colors = [z[0] for z in zipped], [z[1] for z in zipped]
-    cx = cy = round(width / 2, 1)
-    radius = round((width - 2) / 2, 1)
-    current_angle_rad = 0
+
+    spec = PieSpec(cx=round(width / 2, 1), cy=round(width / 2, 1), r=round((width - 2) / 2, 1))
+
     svg_content = []
-    total = sum(data)
     titles = titles or [None] * len(data)
     stroke_circle = 'black' if stroke_circle is True else stroke_circle or 'none'
 
-    def endpoint(angle_rad):
-        """
-        Calculate position of point on circle given an angle, a radius, and the location
-        of the center of the circle Zero line points west.
-        """
-        return (round(cx - (radius * math.cos(angle_rad)), 1),
-                round(cy - (radius * math.sin(angle_rad)), 1))
-
-    if len(data) == 1:
-        svg_content.append(
-            '<circle cx="{0}" cy="{1}" r="{2}" style="stroke:{3}; fill:{4};">'.format(
-                cx, cy, radius, stroke_circle, rgb_as_hex(colors[0])))
+    def _iter_circle_content():
+        f = rgb_as_hex(colors[0])
+        yield (f'<circle cx="{spec.cx}" cy="{spec.cy}" r="{spec.r}" '
+               f'style="stroke:{stroke_circle}; fill:{f};">')
         if titles[0]:
-            svg_content.append('<title>{0}</title>'.format(escape(titles[0])))
-        svg_content.append('</circle>')
-        return svg(''.join(svg_content), height=width, width=width)
-
-    for angle_deg, color, title in zip([360.0 / total * d for d in data], colors, titles):
-        radius1 = "M{0},{1} L{2},{3}".format(cx, cy, *endpoint(current_angle_rad))
-        current_angle_rad += math.radians(angle_deg)
-        arc = "A{0},{1} 0 {2},1 {3} {4}".format(
-            radius, radius, 1 if angle_deg > 180 else 0, *endpoint(current_angle_rad))
-        radius2 = "L%s,%s" % (cx, cy)
-        svg_content.append(
-            '<path d="{0} {1} {2}" style="{3}" transform="rotate(90 {4} {5})">'.format(
-                radius1, arc, radius2, style(fill=rgb_as_hex(color)), cx, cy))
+            yield f'<title>{escape(titles[0])}</title>'
+        yield '</circle>'
+
+    def _add_wedge(content, angle_deg, color, title):
+        epcx, epcy = spec.endpoint()
+        r1 = f"M{spec.cx},{spec.cy} L{epcx},{epcy}"
+        spec.current_angle_rad += math.radians(angle_deg)
+        epcx, epcy = spec.endpoint()
+        arc = f"A{spec.r},{spec.r} 0 {1 if angle_deg > 180 else 0},1 {epcx} {epcy}"
+        r2 = f"L{spec.cx},{spec.cy}"
+        s = style(fill=rgb_as_hex(color))
+        content.append(
+            f'<path d="{r1} {arc} {r2}" style="{s}" transform="rotate(90 {spec.cx} {spec.cy})">')
         if title:
-            svg_content.append('<title>{0}</title>'.format(escape(title)))
-        svg_content.append('</path>')
+            content.append(f'<title>{escape(title)}</title>')
+        content.append('</path>')
+
+    if len(data) == 1:
+        return svg(''.join(_iter_circle_content()), height=width, width=width)
+
+    for angle_deg, color, title in zip([360.0 / sum(data) * d for d in data], colors, titles):
+        _add_wedge(svg_content, angle_deg, color, title)
 
     if stroke_circle != 'none':
         svg_content.append(
-            '<circle cx="%s" cy="%s" r="%s" style="stroke:%s; fill:none;"/>'
-            % (cx, cy, radius, stroke_circle))
-
+            f'<circle cx="{spec.cx}" cy="{spec.cy}" r="{spec.r}" '
+            f'style="stroke:{stroke_circle}; fill:none;"/>'
+        )
     return svg(''.join(svg_content), height=width, width=width)
diff --git a/src/clldutils/text.py b/src/clldutils/text.py
index d2280ef..ea41225 100644
--- a/src/clldutils/text.py
+++ b/src/clldutils/text.py
@@ -2,10 +2,11 @@
 Support for common text manipulation tasks like stripping content in braces, etc.
 """
 import re
-import typing
-import textwrap
+import enum
+from typing import Optional, Union, Callable
+from collections.abc import Generator, Iterable
 
-from clldutils.misc import nfilter, deprecated
+from .misc import nfilter
 
 __all__ = [
     'strip_brackets', 'split_text_with_context', 'split_text', 'strip_chars', 'replace_pattern',
@@ -33,15 +34,18 @@
     '\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000'
 
 
-class TextType(object):
+class TextType(enum.Enum):
+    """Text token types to parse text with brackets."""
+    text = 1  # token outside of brackets  # pylint: disable=invalid-name
+    open = 2  # start-token of a bracket  # pylint: disable=invalid-name
+    context = 3  # non-bracket token inside brackets  # pylint: disable=invalid-name
+    close = 4  # end-token of a bracket  # pylint: disable=invalid-name
 
-    text = 1  # token outside of brackets
-    open = 2  # start-token of a bracket
-    context = 3  # non-bracket token inside brackets
-    close = 4  # end-token of a bracket
 
-
-def _tokens(text, brackets=None):
+def _tokens(
+        text: str,
+        brackets: Optional[dict[str, str]] = None,
+) -> Generator[tuple[str, TextType], None, None]:
     if brackets is None:
         brackets = BRACKETS
     stack = []
@@ -60,8 +64,9 @@ def _tokens(text, brackets=None):
 
 def strip_brackets(
         text: str,
-        brackets: typing.Optional[dict] = None,
-        strip_surrounding_whitespace: bool = True) -> str:
+        brackets: Optional[dict] = None,
+        strip_surrounding_whitespace: bool = True,
+) -> str:
     """
     Strip brackets and what is inside brackets from text.
 
@@ -87,7 +92,8 @@ def strip_brackets(
 def split_text_with_context(
         text: str,
         separators: str = WHITESPACE,
-        brackets: typing.Optional[dict] = None) -> typing.List[str]:
+        brackets: Optional[dict] = None,
+) -> list[str]:
     """
     Splits text at separators outside of brackets.
 
@@ -117,9 +123,10 @@ def split_text_with_context(
 
 def split_text(
         text: str,
-        separators: typing.Union[typing.Iterable, PATTERN_TYPE] = re.compile(r'\s'),
-        brackets: typing.Optional[dict] = None,
-        strip: bool = False) -> typing.List[str]:
+        separators: Union[Iterable, PATTERN_TYPE] = re.compile(r'\s'),
+        brackets: Optional[dict] = None,
+        strip: bool = False,
+) -> list[str]:
     """
     Split text along the separators unless they appear within brackets.
 
@@ -137,14 +144,15 @@ def split_text(
     """
     if not isinstance(separators, PATTERN_TYPE):
         separators = re.compile(
-            r'[{0}]'.format(''.join(r'\{0}'.format(c) for c in separators)))
+            r'[{0}]'.format(
+                ''.join(r'\{0}'.format(c) for c in separators)))  # pylint: disable=C0209
 
     return nfilter(
         s.strip() if strip else s for s in
         separators.split(strip_brackets(text, brackets=brackets)))
 
 
-def strip_chars(chars: typing.Iterable, sequence: typing.Iterable) -> str:
+def strip_chars(chars: Iterable[str], sequence: Iterable[str]) -> str:
     """
     Strip the specified chars from anywhere in the text.
 
@@ -155,16 +163,12 @@ def strip_chars(chars: typing.Iterable, sequence: typing.Iterable) -> str:
     return ''.join(s for s in sequence if s not in chars)
 
 
-def truncate_with_ellipsis(t, ellipsis='\u2026', width=40, **kw):
-    deprecated('Use of deprecated function truncate_with_ellipsis! Use textwrap.shorten instead.')
-    return textwrap.shorten(t, placeholder=ellipsis, width=width, **kw)
-
-
 def replace_pattern(
-        pattern: typing.Union[str, re.Pattern],
-        repl: typing.Callable[[re.Match], typing.Generator[str, None, None]],
+        pattern: Union[str, re.Pattern],
+        repl: Callable[[re.Match], Generator[str, None, None]],
         text: str,
-        flags=0) -> str:
+        flags: Union[int, re.RegexFlag] = 0,
+) -> str:
     """
     Pretty much `re.sub`, but replacement functions are expected to be generators of strings.
 
diff --git a/src/clldutils/ziparchive.py b/src/clldutils/ziparchive.py
index 2a86283..cfc6111 100644
--- a/src/clldutils/ziparchive.py
+++ b/src/clldutils/ziparchive.py
@@ -1,18 +1,24 @@
+"""
+A zipFile subclass with better support for reading and writing text.
+"""
 import io
 import zipfile
+from typing import Optional, Union
 
+from .path import PathType
 
-class ZipArchive(zipfile.ZipFile):
 
+class ZipArchive(zipfile.ZipFile):
+    """A ZipFile subclass with better support for reading and writing text files."""
     _init_defaults = {
         'compression': zipfile.ZIP_DEFLATED,
         'allowZip64': True,
     }
 
-    def __init__(self, fname, mode='r', **kwargs):
+    def __init__(self, fname: PathType, mode='r', **kwargs):
         for k, v in self._init_defaults.items():
             kwargs.setdefault(k, v)
-        super(ZipArchive, self).__init__(str(fname), mode=mode, **kwargs)
+        super().__init__(str(fname), mode=mode, **kwargs)
 
     def __enter__(self):
         return self
@@ -20,11 +26,14 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    def read_text(self, name, encoding='utf-8-sig'):
+    def read_text(self, name: str, encoding='utf-8-sig') -> Optional[str]:
+        """Read a named archive member as str."""
         if name in self.namelist():
             return io.TextIOWrapper(self.open(name), encoding=encoding).read()
+        return None  # pragma: no cover
 
-    def write_text(self, text, name, _encoding='utf-8'):
+    def write_text(self, text: Union[str, bytes], name: str, _encoding='utf-8'):
+        """Write text to a named archive member."""
         if not isinstance(text, bytes):
             text = text.encode(_encoding)
         self.writestr(name, text)
diff --git a/tests/test_apilib.py b/tests/test_apilib.py
index 69c901a..1d395ce 100644
--- a/tests/test_apilib.py
+++ b/tests/test_apilib.py
@@ -1,9 +1,8 @@
 import argparse
 
-import attr
 import pytest
 
-from clldutils.apilib import API, DataObject, latitude, longitude, VERSION_NUMBER_PATTERN
+from clldutils.apilib import API, VERSION_NUMBER_PATTERN
 
 
 def test_API():
@@ -48,35 +47,6 @@ def f(args):
     assert wb.create.call_count == 3
 
 
-def test_DataObject():
-    @attr.s
-    class C(DataObject):
-        x = attr.ib()
-        y = attr.ib(metadata=dict(ascsv=lambda v: 'xyz'))
-
-    assert C.fieldnames() == ['x', 'y']
-    assert C(None, 2).ascsv() == ['', 'xyz']
-    assert C(['y', 'x'], 2).ascsv() == ['y;x', 'xyz']
-    assert C({'y': 2}, 2).ascsv() == ['{"y": 2}', 'xyz']
-    assert C(2.123456, 'x').ascsv() == ['2.12346', 'xyz']
-    assert C(2, 'x').ascsv() == ['2', 'xyz']
-
-
-def test_latitude_longitude():
-    @attr.s
-    class C(object):
-        lat = latitude()
-        lon = longitude()
-
-    assert C('', None).lat is None
-
-    with pytest.raises(ValueError):
-        C(lat=100, lon=50)
-
-    with pytest.raises(ValueError):
-        C(lat='10', lon='500')
-
-
 def test_VERSION_NUMBER_PATTERN():
     assert VERSION_NUMBER_PATTERN.match('v1.2').group('number') == '1.2'
     assert not VERSION_NUMBER_PATTERN.match('1.2')
diff --git a/tests/test_attrlib.py b/tests/test_attrlib.py
deleted file mode 100644
index d3b1e5e..0000000
--- a/tests/test_attrlib.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import re
-import warnings
-
-import pytest
-import attr
-
-from clldutils.attrlib import asdict, valid_enum_member, valid_re, valid_range, cmp_off
-
-
-def test_cmp_off(recwarn):
-    warnings.simplefilter("always")
-
-    @attr.s(**cmp_off)
-    class A:
-        pass
-
-    _ = A()
-    assert not len(recwarn)
-
-
-def test_asdict():
-    class A(object):
-        def asdict(self, **kw):
-            return 'x'
-
-    @attr.s
-    class C(object):
-        _b = attr.ib()
-        a = attr.ib(default=attr.Factory(lambda: 5))
-
-    assert asdict(C(A())) == {}
-    assert asdict(C(A()), omit_private=False) == {'_b': 'x'}
-    assert asdict(C(4), omit_defaults=False) == {'a': 5}
-
-
-def test_valid_range():
-    @attr.s
-    class C(object):
-        a = attr.ib(validator=valid_range(-1, 5))
-
-    assert C(0).a == 0
-    with pytest.raises(ValueError):
-        C(-3)
-
-    @attr.s
-    class C(object):
-        a = attr.ib(validator=valid_range(0, None))
-
-    assert C(2).a == 2
-    with pytest.raises(ValueError):
-        C(-1)
-
-
-def test_valid_re(recwarn):
-    @attr.s
-    class C(object):
-        a = attr.ib(validator=valid_re('(a[0-9]+)?$'))
-
-    assert recwarn.pop(DeprecationWarning)
-    assert C('a1').a == 'a1'
-    assert C('').a == ''
-
-    with pytest.raises(ValueError):
-        C('b')
-
-    @attr.s
-    class C(object):
-        a = attr.ib(validator=valid_re(re.compile('a[0-9]+'), nullable=True))
-
-    assert recwarn.pop(DeprecationWarning)
-    assert C(None).a is None
-
-    with pytest.raises(ValueError):
-        C('b')
-
-
-def test_valid_enum_member(recwarn):
-    @attr.s
-    class C(object):
-        a = attr.ib(validator=valid_enum_member([1, 2, 3]))
-
-    assert C(3).a == 3
-
-    with pytest.raises(ValueError):
-        C(5)
-    assert recwarn.pop(DeprecationWarning)
diff --git a/tests/test_badge.py b/tests/test_badge.py
deleted file mode 100644
index 06d0ccd..0000000
--- a/tests/test_badge.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from functools import partial
-
-
-def test_badge():
-    from clldutils.badge import badge, Colors
-
-    _badge = partial(badge, 'cov', '20%', Colors.orange)
-
-    assert _badge() == \
-        '![cov: 20%](https://img.shields.io/badge/cov-20%25-orange.svg "cov: 20%")'
-    assert _badge(markdown=False, style='plastic') == \
-        'https://img.shields.io/badge/cov-20%25-orange.svg?style=plastic'
-    assert '[abc]' in badge('subject', 'status', 'color', label='abc')
diff --git a/tests/test_clilib.py b/tests/test_clilib.py
index 5b67507..c0b1279 100644
--- a/tests/test_clilib.py
+++ b/tests/test_clilib.py
@@ -80,84 +80,6 @@ def load(self):
         assert recwarn.pop(UserWarning)
 
 
-def test_ArgumentParser(capsys):
-    def cmd(args):
-        """
-        docstring
-        """
-        if len(args.args) < 1:
-            raise ParserError('not enough arguments')
-        print(args.args[0])
-
-    parser = ArgumentParserWithLogging('pkg', cmd)
-
-    parser.main(args=['help', 'cmd'])
-    out, err = capsys.readouterr()
-    assert 'docstring' in out
-
-    parser.main(args=['cmd', 'arg'])
-    out, err = capsys.readouterr()
-    assert 'arg' in out
-
-    assert parser.main(args=['cmd', 'arg']) == 0
-
-    parser.main(args=['cmd'])
-    out, err = capsys.readouterr()
-    assert 'not enough arguments' in out
-
-    assert parser.main(args=['x']) != 0
-    out, err = capsys.readouterr()
-    assert out.startswith('invalid')
-
-    @command()
-    def ls(args):
-        """
-        my name is ls
-        """
-        return
-
-    @command(name='list', usage='my name is {0}'.format('list'))
-    def f(args):
-        """
-        """
-        return
-
-    parser = ArgumentParserWithLogging('pkg')
-    parser.main(args=['help', 'ls'])
-    out, err = capsys.readouterr()
-    assert 'my name is ls' in out
-
-    parser.main(args=['help', 'list'])
-    out, err = capsys.readouterr()
-    assert 'my name is list' in out
-
-    assert parser.main(args=['ls', 'arg']) == 0
-    assert parser.main(args=['list', 'arg']) == 0
-
-
-def test_deprecation(recwarn):
-    warnings.simplefilter("always")
-
-    class AP(ArgumentParser):
-        pass
-
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
-def test_cmd_error():
-    from clldutils.clilib import ArgumentParser
-
-    def cmd(args):
-        raise ValueError
-
-    parser = ArgumentParser('pkg', cmd)
-    with pytest.raises(ValueError):
-        parser.main(args=['cmd'])
-
-    assert parser.main(args=['cmd'], catch_all=True) == 1
-
-
 def test_confirm(capsys, mocker):
     from clldutils.clilib import confirm
 
@@ -175,7 +97,7 @@ def test_Table(capsys):
     with Table(argparse.Namespace(format='simple'), 'a') as t:
         t.append(['x'])
     out, _ = capsys.readouterr()
-    assert out == 'a\n---\nx\n'
+    assert out == ' a  \n---\n x  \n'
 
 
 def test_add_format():
diff --git a/tests/test_coordinates.py b/tests/test_coordinates.py
index e4e5b3e..369a0f2 100644
--- a/tests/test_coordinates.py
+++ b/tests/test_coordinates.py
@@ -3,6 +3,21 @@
 from clldutils.coordinates import *
 
 
+@pytest.mark.parametrize(
+    'dec,expected',
+    [
+        (0, (0, 0, 0.0)),
+        (20.5, (20, 30, 0.0)),
+    ]
+)
+def test_dec2degminsec(dec, expected):
+    d, m, s = dec2degminsec(dec)
+    assert d == expected[0]
+    assert m == expected[1]
+    assert s == pytest.approx(expected[2])
+    assert degminsec2dec(d, m, s) == pytest.approx(dec)
+
+
 @pytest.mark.parametrize(
     'dec,hem,res,no_seconds',
     [
@@ -19,7 +34,7 @@ def test_degminsec(dec, hem, res, no_seconds):
 @pytest.mark.parametrize(
     'format,coord,lat,lon',
     [
-        ('aln', ('13dN', 0), 13.0, 0),
+        ('alnum', ('13dN', 0), 13.0, 0),
         ('degminsec', ('1°1′1″N', '1°1′1.5″W'), 1.017, -1.017),
         ('degminsec', ('1°1′1″N'.encode('utf8'), '1°1′1.5″W'), 1.1, -1.1),
     ]
diff --git a/tests/test_markup.py b/tests/test_markup.py
index 7b3b4c8..b53ec74 100644
--- a/tests/test_markup.py
+++ b/tests/test_markup.py
@@ -8,19 +8,29 @@
 from clldutils.markup import *
 
 
-def test_Table():
+@pytest.mark.parametrize(
+    'options,expected',
+    [
+        (dict(),
+         '| a | b |\n| :-: | :-: |\n| 1 | 2 |\n| 3 | 4 |'),
+        (dict(condensed=False),
+         '|  a  |  b  |\n| :-: | :-: |\n|  1  |  2  |\n|  3  |  4  |'),
+        (dict(verbose=True),
+         '| a | b |\n| :-: | :-: |\n| 1 | 2 |\n| 3 | 4 |\n\n(2 rows)\n\n'),
+        (dict(sortkey=itemgetter(1), reverse=True),
+         '| a | b |\n| :-: | :-: |\n| 3 | 4 |\n| 1 | 2 |'),
+    ]
+)
+def test_Table(options, expected):
     t = Table()
     assert t.render() == ''
 
     t = Table('a', 'b', rows=[[1, 2], [3, 4]])
-    assert t.render() == \
-        '| a | b |\n|----:|----:|\n| 1 | 2 |\n| 3 | 4 |'
-    assert t.render(condensed=False) == \
-        '|   a |   b |\n|----:|----:|\n|   1 |   2 |\n|   3 |   4 |'
-    assert t.render(verbose=True) == \
-        '| a | b |\n|----:|----:|\n| 1 | 2 |\n| 3 | 4 |\n\n(2 rows)\n\n'
-    assert t.render(sortkey=itemgetter(1), reverse=True) == \
-        '| a | b |\n|----:|----:|\n| 3 | 4 |\n| 1 | 2 |'
+    assert t.render(**options) == expected
+
+
+def test_TableFormat():
+    assert TableFormat.get(TableFormat.pipe) == TableFormat.pipe
 
 
 def test_Table_tsv(capsys):
@@ -32,19 +42,24 @@ def test_Table_tsv(capsys):
 
 def test_Table_context(capsys):
     with Table('a', 'b', tablefmt='simple') as t:
-        t.append([1, 2.345])
+        pass
     out, _ = capsys.readouterr()
-    assert out == '  a     b\n---  ----\n  1  2.35\n'
+    assert ' a ' in out
 
+    with Table('a', 'b', 'b', tablefmt='simple') as t:
+        t.append([1, 2.345])
+    out, _ = capsys.readouterr()
+    assert out == ' a   b      b_2  \n--- ------ -----\n 1   2.35        \n'
     f = io.StringIO()
     with Table('a', 'b', tablefmt='simple', file=f) as t:
         t.append([1, 2.345])
-    assert f.getvalue() == '  a     b\n---  ----\n  1  2.35\n'
+    assert f.getvalue() == ' a   b     \n--- ------\n 1   2.35  \n'
 
 
 def test_iter_markdown_tables():
     header, rows = ['a', 'b'], [[1, 2], [3, 4]]
     text = Table(*header, **dict(rows=rows)).render() + '\nabcd'
+    print(text)
     assert list(iter_markdown_tables(text))[0] == \
         (header, [[str(v) for v in r] for r in rows])
     assert list(iter_markdown_tables('a|b\n---|---\n1|2'))[0] == (header, [['1', '2']])
@@ -100,6 +115,17 @@ def test_add_markdown_text_error():
 def test_markdownlink1(markdown, expected):
     assert MarkdownLink.replace(markdown, lambda ml: ml.update_url(fragment='c')) == expected
 
+def test_non_link_square_brackets():
+    assert MarkdownLink.replace(
+        '\\[stuff\\] and [a](b)) ', lambda ml: "--") == '\\[stuff\\] and --) '
+    assert MarkdownLink.replace(
+        '[stuff] and [a](b)) ', lambda ml: "--") == '[stuff] and --) '
+
+
+def test_invalid_markdownlink():
+    with pytest.raises(ValueError):
+        _ = MarkdownLink.from_string('[abc]')
+
 
 def test_non_link_square_brackets():
     assert MarkdownLink.replace(
diff --git a/tests/test_misc.py b/tests/test_misc.py
index 29411df..00aa0fd 100644
--- a/tests/test_misc.py
+++ b/tests/test_misc.py
@@ -43,20 +43,6 @@ def test_dict_merged():
     assert dict_merged(None, a=None) == {}
 
 
-def test_lazyproperty():
-    class C(object):
-        @lazyproperty
-        def attr(self, _ints=itertools.count()):
-            return next(_ints)
-
-    assert isinstance(C.attr, lazyproperty)
-    c = C()
-    call1 = c.attr
-    assert call1 == c.attr
-    del c.attr
-    assert call1 != c.attr
-
-
 def test_NoDefault():
     def f(default=NO_DEFAULT):
         if default is NO_DEFAULT:
@@ -74,24 +60,14 @@ def test_slug():
 def test_format_size():
     for i in range(10):
         assert format_size(1000 ** i)
-
+    assert format_size(1200) == '1.2KB'
+    assert format_size(1000000000000000000000) == '888178.4PB'
 
 def test_xmlchars():
     assert xmlchars('äöü') == 'äöü'
     assert xmlchars('ä\x08') == 'ä'
 
 
-def test_UnicodeMixin(recwarn):
-    class Test(UnicodeMixin):
-        def __unicode__(self):
-            return 'äöü'
-
-    warnings.simplefilter("always")
-    assert Test().__str__()
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
 def test_data_url_from_string():
     from clldutils.path import Path
 
diff --git a/tests/test_path.py b/tests/test_path.py
index 576c67d..c9f83b1 100644
--- a/tests/test_path.py
+++ b/tests/test_path.py
@@ -39,18 +39,6 @@ def test_memorymapped(tmp_path):
         assert b.find('ö'.encode('utf-8')) == 2
 
 
-def test_read_write(tmp_path, recwarn):
-    from clldutils.path import read_text, write_text
-
-    warnings.simplefilter("always")
-    text = 'äöüß'
-    p = tmp_path / 'test'
-    assert write_text(p, text) == len(text)
-    assert read_text(p) == text
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
 def test_readlines(tmp_path):
     from clldutils.path import readlines
 
@@ -85,19 +73,6 @@ def test_import_module(tmp_path):
     assert len(m.A) == 3
 
 
-def test_non_ascii(recwarn):
-    from clldutils.path import Path, path_component, as_unicode
-
-    assert path_component(b'abc') == 'abc'
-
-    warnings.simplefilter("always")
-    p = Path(path_component('äöü')).joinpath(path_component('äöü'))
-    assert isinstance(as_unicode(p), str)
-    assert isinstance(as_unicode(p.name), str)
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
 def test_as_posix():
     from clldutils.path import as_posix, Path
 
@@ -112,69 +87,6 @@ def test_md5():
     assert re.match('[a-f0-9]{32}$', md5(__file__))
 
 
-def test_copytree(tmp_path):
-    from clldutils.path import copytree
-
-    dst = tmp_path / 'a' / 'b'
-    with pytest.deprecated_call():
-        copytree(tmp_path, dst)
-    assert dst.exists()
-    with pytest.raises(OSError):
-        with pytest.deprecated_call():
-            copytree(dst, dst)
-
-
-def test_copy(tmp_path):
-    from clldutils.path import copy
-
-    src = make_file(tmp_path, name='test', text='abc')
-    dst = tmp_path / 'other'
-    with pytest.deprecated_call():
-        copy(src, dst)
-    assert src.stat().st_size == dst.stat().st_size
-
-
-def test_move(tmp_path):
-    from clldutils.path import move
-
-    dst = tmp_path / 'a'
-    dst.mkdir()
-    src = make_file(tmp_path, name='test')
-    move(src, dst)
-    assert not src.exists()
-    assert dst.joinpath(src.name).exists()
-
-
-def test_remove(tmp_path, recwarn):
-    from clldutils.path import remove
-
-    warnings.simplefilter("always")
-    with pytest.raises(OSError):
-        remove(tmp_path / 'nonexistingpath')
-    tmp = make_file(tmp_path, name='test')
-    assert tmp.exists()
-    remove(tmp)
-    assert not tmp.exists()
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
-def test_rmtree(tmp_path):
-    from clldutils.path import rmtree
-
-    with pytest.raises(OSError):
-        with pytest.deprecated_call():
-            rmtree(tmp_path / 'nonexistingpath')
-    with pytest.deprecated_call():
-        rmtree(tmp_path / 'nonexistingpath', ignore_errors=True)
-    tmp = tmp_path / 'test'
-    tmp.mkdir()
-    assert tmp.exists()
-    with pytest.deprecated_call():
-        rmtree(tmp)
-    assert not tmp.exists()
-
-
 def test_walk(tmp_path):
     from clldutils.path import walk
 
diff --git a/tests/test_svg.py b/tests/test_svg.py
index 4251b9b..1319393 100644
--- a/tests/test_svg.py
+++ b/tests/test_svg.py
@@ -10,6 +10,14 @@ def test_icon():
     assert 'opacity' in icon('tf00', opacity=0.5)
 
 
+PIE = ('<svg  xmlns="http://www.w3.org/2000/svg"\n'
+       '      xmlns:xlink="http://www.w3.org/1999/xlink" height="34" width="34">\n'
+       '  <path d="M17.0,17.0 L1.0,17.0 A16.0,16.0 0 0,1 31.4 10.1 L17.0,17.0" '
+       'style="fill:#000000;stroke:none;" transform="rotate(90 17.0 17.0)"></path>'
+       '<path d="M17.0,17.0 L31.4,10.1 A16.0,16.0 0 1,1 1.0 17.0 L17.0,17.0" '
+       'style="fill:#FFFFFF;stroke:none;" transform="rotate(90 17.0 17.0)"></path>\n'
+       '</svg>')
+
 def test_pie():
     with pytest.raises(AssertionError):
         pie([1], [])
@@ -21,6 +29,7 @@ def test_pie():
     assert 'circle' not in pie([100, 20])
     res = fromstring(pie([2, 7], ['eee', '111'], titles=['a', 'b'], stroke_circle='#f00'))
     assert res.tag == '{http://www.w3.org/2000/svg}svg'
+    assert pie([3, 0, 4], ['#000', '#eee', '#fff']) == PIE
 
 
 def test_data_url():
diff --git a/tests/test_text.py b/tests/test_text.py
index 44eea85..990a6d5 100644
--- a/tests/test_text.py
+++ b/tests/test_text.py
@@ -1,5 +1,4 @@
 import re
-import warnings
 
 from clldutils import text
 
@@ -11,16 +10,6 @@ def repl(m):
     assert text.replace_pattern('^[0-9]+', repl, 'x3y\n2z', flags=re.M) == 'x3y\naaz'
 
 
-def test_truncate_with_ellipsis(recwarn):
-    warnings.simplefilter("always")
-    assert text.truncate_with_ellipsis(' '.join(30 * ['a']), ellipsis='.').endswith('.')
-    assert text.truncate_with_ellipsis(
-        ' '.join(30 * ['a']), ellipsis='.', width=100).endswith('a')
-
-    assert recwarn.pop(DeprecationWarning)
-    warnings.simplefilter("default")
-
-
 def test_strip_brackets():
     strings = ['arm((h)an[d])', '(hand)arm', 'a(hand)r(hand)m(hand)', 'arm⁽hand⁾']
     for string in strings: