diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 0000000..d6d76ca
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,30 @@
+FROM ghcr.io/astral-sh/uv:python3.9-bookworm-slim
+
+# Install the project into `/app`
+WORKDIR /app
+
+# Enable bytecode compilation
+ENV UV_COMPILE_BYTECODE=1
+
+# Copy from the cache instead of linking since it's a mounted volume
+ENV UV_LINK_MODE=copy
+
+# Install the project's dependencies using the lockfile and settings
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev
+
+# Then, add the rest of the project source code and install it
+# Installing separately from its dependencies allows optimal layer caching
+ADD . /app
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev
+
+# Place executables in the environment at the front of the path
+ENV PATH="/app/.venv/bin:/root/.local/bin:$PATH"
+
+# Reset the entrypoint, don't invoke `uv`
+ENTRYPOINT []
+
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..aea6c6e
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,49 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile
+{
+  "name": "Scrapabook",
+  "build": {
+    // Sets the run context to one level up instead of the .devcontainer folder.
+    "context": "..",
+    // Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+    "dockerfile": "./Dockerfile"
+  },
+  "runArgs": [
+    "--name=scrapbook",
+    "-v=scrapbook-vscode-extensions:/root/.vscode-server/extensions"
+  ],
+  "overrideCommand": true,
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-azuretools.vscode-docker",
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "ms-python.mypy-type-checker",
+        "charliermarsh.ruff",
+        "ryanluker.vscode-coverage-gutters"
+      ],
+      "settings": {
+        "terminal.integrated.profiles.linux": {
+          "bash": {
+            "path": "/bin/bash"
+          }
+        },
+        "terminal.integrated.defaultProfile.linux": "bash",
+        "[python]": {
+          "editor.defaultFormatter": "charliermarsh.ruff",
+          "editor.formatOnSave": true,
+          "editor.formatOnType": true,
+          "editor.codeActionsOnSave": {
+            "source.organizeImports": "explicit"
+          }
+        },
+        "python.defaultInterpreterPath": ".venv/bin/python",
+        "python.testing.unittestEnabled": false,
+        "python.testing.pytestEnabled": true,
+        "coverage-gutters.showGutterCoverage": false,
+        "coverage-gutters.showLineCoverage": true
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/.github/workflows/build-and-deploy.yaml b/.github/workflows/build-and-deploy.yaml
new file mode 100644
index 0000000..cb4f803
--- /dev/null
+++ b/.github/workflows/build-and-deploy.yaml
@@ -0,0 +1,36 @@
+name: Scrapbook
+
+on:
+  push:
+    paths:
+      - "src/**"
+      - "tests/**"
+      - ".github/workflows/**"
+      - "pyproject.toml"
+      - "uv.lock"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "0.4.30"
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Set up Python
+        run: uv python install 3.9
+
+      - name: Install the project
+        run: uv sync --all-extras --dev
+
+      - name: Run lint
+        run: uv run ruff check .
+
+      - name: Run tests
+        run: uv run tox
diff --git a/.gitignore b/.gitignore
index db1273c..037b914 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,13 @@
-*.pyc
-*.pyo
 __pycache__
-.direnv
-.envrc
-.vscode
 .cache
+.coverage
+.pytest_cache
+.ruff_cache
+.tox
+.venv
+.vscode
+*.pyc
+*.pyo
+coverage.xml
 dist
 scrapbook.egg-info
diff --git a/README.md b/README.md
index 9627d14..f426181 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
 Scrapbook
 =================================================
 
-[![CircleCI](https://circleci.com/gh/odoku/Scrapbook/tree/master.svg?style=svg)](https://circleci.com/gh/odoku/Scrapbook/tree/master)
-
 Scrapbook is simple scraping library.
 
 
@@ -33,7 +31,7 @@ print(data)
 Requirements
 -------------------------------------------------
 
-- Python 2.7 or Python 3.3+
+- Python 3.9+
 
 
 Installation
diff --git a/circle.yml b/circle.yml
deleted file mode 100644
index 32c03d1..0000000
--- a/circle.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-dependencies:
-  override:
-    - pip install tox tox-pyenv
-    - pyenv local 2.7.12 3.3.6 3.4.4 3.5.3 3.6.2
-
-test:
-  override:
-    - tox
diff --git a/pip_requirements.txt b/pip_requirements.txt
deleted file mode 100644
index db7aaf7..0000000
--- a/pip_requirements.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-parsel>=1.2.0
-six>=1.10.0
-python-dateutil>=2.7.0
-
-# Dev
-flake8>=3.4.1
-pytest>=3.2.2
-pytest-mock>=1.6.3
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..447c01e
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,98 @@
+[project]
+name = "scrapbook"
+version = "1.0.0"
+description = "Simple scraping library."
+keywords = ["html", "parse", "scraping"]
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [{ name = "Masashi Onogawa", email = "masashi.onogawa@wamw.jp" }]
+license = { file = "LICENSE" }
+requires-python = ">=3.9"
+dependencies = ["parsel>=1.9.1", "python-dateutil>=2.9.0.post0"]
+
+[project.urls]
+Homepage = "https://github.com/odoku/Scrapbook"
+Documentation = "https://scrapbook.readthedocs.io/"
+Repository = "https://github.com/odoku/Scrapbook"
+Issues = "https://github.com/odoku/Scrapbook/issues"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.13.0",
+    "pytest-cov>=6.0.0",
+    "pytest-mock>=3.14.0",
+    "pytest>=8.3.3",
+    "ruff>=0.7.2",
+    "tox>=4.23.2",
+    "tox-uv>=1.16.0",
+    "types-python-dateutil>=2.9.0.20241003",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.mypy]
+plugins = []
+show_column_numbers = true
+ignore_missing_imports = true
+exclude = []
+
+[tool.ruff]
+target-version = "py39"
+line-length = 120
+indent-width = 4
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+[tool.ruff.lint]
+select = ["B", "C", "E", "F", "W", "B9"]
+ignore = ["E203", "E266"]
+exclude = []
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true
+exclude = []
+
+[tool.pytest.ini_options]
+pythonpath = "src"
+testpaths = ["tests"]
+addopts = "--cov=. --cov-report=xml"
+python_files = "*.py"
+
+[tool.tox]
+envlist = ["py39", "py310", "py311", "py312", "py313", "pypy39", "pypy310"]
+isolated_build = true
+
+[tool.tox.env_run_base]
+description = "Run test under {base_python}"
+runner = "uv-venv-lock-runner"
+with_dev = true
+commands = [["pytest"]]
diff --git a/scrapbook/__init__.py b/scrapbook/__init__.py
deleted file mode 100644
index 01499a0..0000000
--- a/scrapbook/__init__.py
+++ /dev/null
@@ -1,175 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-from collections import MutableMapping
-import inspect
-import six
-from parsel import Selector
-
-from .exceptions import ScrapBookError
-from .filters import clean_text, Filter, through
-from .parsers import First
-from .utils import merge_dict
-
-
-class BaseElement(object):
-    filter = (through,)
-
-    def __init__(self, xpath=None, filter=None):
-        self.instance = None
-        self.xpath = xpath
-        if filter:
-            self.filter = filter
-
-    def __get__(self, instance, owner):
-        self.instance = instance
-        return self
-
-    @property
-    def is_descriptor(self):
-        return self.instance is not None
-
-    def get_function(self, fn):
-        if isinstance(fn, Filter):
-            fn.element = self
-            return fn
-
-        if callable(fn):
-            return fn
-
-        method = getattr(self, six.text_type(fn), None)
-        if method and callable(method):
-            return method
-
-        if self.instance and hasattr(self.instance, 'get_function'):
-            return self.instance.get_function(fn)
-
-        raise ValueError('{} is not callable.'.format(fn))
-
-    def get_filter(self):
-        if not isinstance(self.filter, (list, tuple)):
-            filters = [self.filter]
-        else:
-            filters = self.filter
-
-        return [self.get_function(f) for f in filters]
-
-    def get_selector(self, html):
-        selector = Selector(text=html) if isinstance(html, six.string_types) else html
-        if self.xpath:
-            return selector.xpath(self.xpath)
-        return selector.xpath('.')
-
-    def parse(self, html):
-        raise NotImplementedError()
-
-
-class ContentMeta(type):
-    def __new__(klass, name, bases, attrs):
-        new_class = super(ContentMeta, klass).__new__(klass, name, bases, attrs)
-
-        elements = {
-            attr: getattr(new_class, attr)
-            for attr in attrs
-            if not attr.startswith('_') and isinstance(getattr(new_class, attr), BaseElement)
-        }
-
-        for base in bases:
-            if hasattr(base, 'elements'):
-                elements = merge_dict(base.elements, elements)
-
-        new_class.elements = elements
-
-        return new_class
-
-
-@six.add_metaclass(ContentMeta)
-class Content(BaseElement):
-    def __init__(self, *args, **kwargs):
-        self.many = kwargs.pop('many', False)
-        super(Content, self).__init__(*args, **kwargs)
-
-    def _parse(self, selector):
-        data = {}
-        for name in self.elements:
-            try:
-                data[name] = getattr(self, name).parse(selector)
-            except Exception as e:
-                raise ScrapBookError(parent=e, field=name)
-        return data
-
-    def parse(self, html, object=None):
-        selector = self.get_selector(html)
-        if len(selector) == 0:
-            return None
-
-        if self.many:
-            value = [self._parse(s) for s in selector]
-        else:
-            value = self._parse(selector)
-
-        for filter in self.get_filter():
-            try:
-                value = filter(value)
-            except Exception as e:
-                raise ScrapBookError(parent=e, selector=selector, value=value)
-
-        return self._map_to(value, object)
-
-    def _map_to(self, value, object):
-        if object is None:
-            return value
-
-        if isinstance(value, (list, tuple)):
-            return [self._map_value(v, object) for v in value]
-        return self._map_value(value, object)
-
-    def _map_value(self, value, object):
-        if inspect.isclass(object):
-            object = object()
-
-        if isinstance(object, MutableMapping):
-            for k, v in value.items():
-                object[k] = v
-            return object
-
-        for k, v in value.items():
-            setattr(object, k, v)
-        return object
-
-    @classmethod
-    def inline(base, xpath=None, filter=None, **attrs):
-        cls = type('InlineContent', (base,), attrs)
-        return cls(xpath, filter)
-
-
-class Element(BaseElement):
-    filter = (clean_text,)
-    parser = First()
-
-    def __init__(self, *args, **kwargs):
-        parser = kwargs.pop('parser', None)
-        if parser:
-            self.parser = parser
-        super(Element, self).__init__(*args, **kwargs)
-
-    def get_parser(self):
-        return self.get_function(self.parser)
-
-    def _parse(self, selector):
-        return self.get_parser()(selector)
-
-    def parse(self, html):
-        selector = self.get_selector(html)
-        if len(selector) == 0:
-            return None
-
-        value = None
-        try:
-            value = self._parse(selector)
-            for filter in self.get_filter():
-                value = filter(value)
-        except Exception as e:
-            raise ScrapBookError(parent=e, selector=selector, value=value)
-
-        return value
diff --git a/scrapbook/filters.py b/scrapbook/filters.py
deleted file mode 100644
index c078c48..0000000
--- a/scrapbook/filters.py
+++ /dev/null
@@ -1,320 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-from collections import Iterable, Mapping
-from datetime import datetime
-import functools
-import re
-import unicodedata
-
-from dateutil.parser import parse as parse_date_string
-import six
-from six.moves.html_parser import HTMLParser
-
-from .utils import remove_tags, tzinfos
-
-
-class Filter(object):
-    def __init__(self, empty_value=None):
-        self.element = None
-        self.empty_value = empty_value
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return value
-
-    def is_empty(self, value):
-        return value is None or value == ''
-
-
-class Map(Filter):
-    def __init__(self, *functions, **kwargs):
-        self._functions = functions
-        super(Map, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        if isinstance(value, Mapping):
-            return self._run_mapping(value)
-
-        if isinstance(value, Iterable):
-            return self._run_iterable(value)
-
-        return self._run_other(value)
-
-    def _run_mapping(self, mapping):
-        functions = self._get_functions()
-        return {
-            k: six.moves.reduce(lambda vv, f: f(vv), functions, v)
-            for k, v in mapping.items()
-        }
-
-    def _run_iterable(self, iterable):
-        functions = self._get_functions()
-        return list(six.moves.reduce(
-            lambda v, f: map(f, v),
-            functions,
-            iterable,
-        ))
-
-    def _run_other(self, value):
-        functions = self._get_functions()
-        return six.moves.reduce(
-            lambda v, f: f(v),
-            functions,
-            value,
-        )
-
-    def _get_functions(self):
-        if not self.element:
-            return self._functions
-        return [self.element.get_function(fn) for fn in self._functions]
-
-
-class Through(Filter):
-    def __call__(self, value):
-        return value
-
-
-class TakeFirst(Filter):
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        for v in value:
-            if v is not None and v != '':
-                return v
-        return self.empty_value
-
-
-class CleanText(Filter):
-    def __init__(self, remove_line_breaks=False, **kwargs):
-        self.remove_line_breaks = remove_line_breaks
-        super(CleanText, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        value = remove_tags(value)
-        value = HTMLParser().unescape(value)
-        if self.remove_line_breaks:
-            value = re.sub(r'(?:\n\r|\r\n|\n|\r)+', ' ', value)
-        value = re.sub(r'[ 　]+', ' ', value)
-        value = value.strip()
-
-        if value == '':
-            return self.empty_value
-
-        return value
-
-
-class Equals(Filter):
-    def __init__(self, value, **kwargs):
-        self.value = value
-        super(Equals, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return self.value == value
-
-
-class Contains(Filter):
-    def __init__(self, value, **kwargs):
-        self.value = value
-        super(Contains, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return self.value in value
-
-
-class Fetch(Filter):
-    def __init__(self, pattern, all=False, **kwargs):
-        self.pattern = re.compile(pattern)
-        self.all = all
-        super(Fetch, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        if self.all:
-            return self._fetch_all(value)
-        return self._fetch(value)
-
-    def _fetch(self, value):
-        match = self.pattern.search(value)
-        if not match:
-            return self.empty_value
-        return self._get_value(match)
-
-    def _fetch_all(self, value):
-        data = []
-        for match in self.pattern.finditer(value):
-            data.append(self._get_value(match))
-        return data
-
-    def _get_value(self, match):
-        dict_value = match.groupdict()
-        if dict_value:
-            return dict_value
-
-        list_value = match.groups()
-        if list_value:
-            return list_value
-
-        return match.group(0)
-
-
-class Replace(Filter):
-    def __init__(self, pattern, replace, **kwargs):
-        self.pattern = re.compile(pattern)
-        self.replace = replace
-        super(Replace, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return self.pattern.sub(self.replace, value)
-
-
-class Join(Filter):
-    def __init__(self, separator='', **kwargs):
-        self.separator = separator
-        super(Join, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return self.separator.join(value)
-
-
-class Split(Filter):
-    def __init__(self, delimiter, **kwargs):
-        self.delimiter = delimiter
-        super(Split, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return value.split(self.delimiter)
-
-
-class Normalize(Filter):
-    def __init__(self, form='NFKD', **kwargs):
-        self.form = form
-        super(Normalize, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return unicodedata.normalize(self.form, value)
-
-
-class RenameKey(Filter):
-    def __init__(self, name_map, **kwargs):
-        self.name_map = name_map
-        super(RenameKey, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return {self.name_map.get(k, k): v for k, v in value.items()}
-
-
-class FilterDict(Filter):
-    def __init__(self, keys, ignore=False, **kwargs):
-        self.keys = keys
-        self.ignore = ignore
-        super(FilterDict, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        if self.ignore:
-            return {
-                k: v
-                for k, v in value.items()
-                if k not in self.keys
-            }
-
-        return {
-            key: value[key]
-            for key in self.keys
-            if key in value
-        }
-
-
-class Partial(Filter):
-    def __init__(self, fn, args=None, kwargs=None, arg_name=None, **parent_kwargs):
-        args = args or tuple()
-        kwargs = kwargs or {}
-        self.fn = functools.partial(fn, *args, **kwargs)
-        self.arg_name = arg_name
-        super(Partial, self).__init__(**parent_kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        if self.arg_name:
-            return self.fn(**{self.arg_name: value})
-        return self.fn(value)
-
-
-class DateTime(Filter):
-    def __init__(
-        self,
-        format=None,
-        timezone=None,
-        truncate_time=False,
-        truncate_timezone=False,
-        **kwargs
-    ):
-        self.format = format
-        self.timezone = timezone
-        self.truncate_time = truncate_time
-        self.truncate_timezone = truncate_timezone
-        super(DateTime, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-
-        if self.format:
-            dt = datetime.strptime(value, self.format)
-            if self.timezone:
-                dt = dt.replace(tzinfo=self.timezone)
-        else:
-            dt = parse_date_string(value, default=datetime(1, 1, 1), tzinfos=tzinfos)
-
-        if self.truncate_timezone:
-            dt = dt.replace(tzinfo=None)
-
-        if self.truncate_time:
-            return dt.date()
-
-        return dt
-
-
-class Bool(Filter):
-    def __init__(self, *true_values, **kwargs):
-        self.true_values = true_values or ['true', 'True', 'TRUE', 'yes', 'Yes', 'YES', '1']
-        super(Bool, self).__init__(**kwargs)
-
-    def __call__(self, value):
-        if self.is_empty(value):
-            return self.empty_value
-        return value in self.true_values
-
-
-through = Through()
-take_first = TakeFirst()
-clean_text = CleanText()
diff --git a/scrapbook/parsers.py b/scrapbook/parsers.py
deleted file mode 100644
index e11482d..0000000
--- a/scrapbook/parsers.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-from .filters import clean_text
-
-
-class First(object):
-    def __call__(self, selector):
-        return selector.extract_first()
-
-
-class All(object):
-    def __call__(self, selector):
-        return selector.extract()
-
-
-class ParseTable(object):
-    def __init__(self, has_header=False):
-        self.has_header = has_header
-
-    def __call__(self, selector):
-        rows = selector.xpath('.//tr')
-
-        if self.has_header:
-            return self._parse_as_dict(rows)
-        return self._parse_as_list(rows)
-
-    def _parse_as_list(self, rows):
-        data = []
-        for row in rows:
-            data.append([
-                clean_text(column.xpath('.//text()').extract_first())
-                for column in row.xpath('./*')
-            ])
-
-        return data
-
-    def _parse_as_dict(self, rows):
-        keys = [
-            clean_text(e.xpath('.//text()').extract_first())
-            for e in rows[0].xpath('./*')
-        ]
-
-        data = []
-        for row in rows[1:]:
-            data.append({
-                k: clean_text(row.xpath('./*[{}]//text()'.format(i + 1)).extract_first())
-                for i, k in enumerate(keys)
-            })
-
-        return data
-
-
-class ParseList(object):
-    def __call__(self, selector):
-        return [
-            clean_text(v)
-            for v in selector.xpath('./li/text()').extract()
-        ]
-
-
-class ParseDefinitionList(object):
-    def __call__(self, selector):
-        data = {}
-
-        for s in selector.xpath('./dt | ./dd'):
-            tag = s.extract()
-            if tag.startswith('<dt>'):
-                current_key = clean_text(tag)
-                data[current_key] = []
-            else:
-                try:
-                    data[current_key].append(clean_text(tag))
-                except NameError:
-                    pass
-
-        return {
-            k: v if len(v) > 1 else v[0]
-            for k, v in data.items()
-        }
diff --git a/scrapbook/utils.py b/scrapbook/utils.py
deleted file mode 100644
index 42f71b5..0000000
--- a/scrapbook/utils.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-import re
-import six
-
-
-def merge_dict(*dicts):
-    return six.moves.reduce(lambda a, b: dict(a, **b), dicts)
-
-
-def remove_tags(text):
-    pattern = re.compile(r'<[^>]+>')
-    return pattern.sub('', text)
-
-
-def generate_tzinfos():
-    tz_map = {
-        -12: ['Y'],
-        -11: ['X', 'NUT', 'SST'],
-        -10: ['W', 'CKT', 'HAST', 'HST', 'TAHT', 'TKT'],
-        -9: ['V', 'AKST', 'GAMT', 'GIT', 'HADT', 'HNY'],
-        -8: ['U', 'AKDT', 'CIST', 'HAY', 'HNP', 'PST', 'PT'],
-        -7: ['T', 'HAP', 'HNR', 'MST', 'PDT'],
-        -6: ['S', 'CST', 'EAST', 'GALT', 'HAR', 'HNC', 'MDT'],
-        -5: ['R', 'CDT', 'COT', 'EASST', 'ECT', 'EST', 'ET', 'HAC', 'HNE', 'PET'],
-        -4: ['Q', 'AST', 'BOT', 'CLT', 'COST', 'EDT', 'FKT', 'GYT', 'HAE', 'HNA', 'PYT'],
-        -3: [
-            'P', 'ADT', 'ART', 'BRT', 'CLST', 'FKST',
-            'GFT', 'HAA', 'PMST', 'PYST', 'SRT', 'UYT', 'WGT',
-        ],
-        -2: ['O', 'BRST', 'FNT', 'PMDT', 'UYST', 'WGST'],
-        -1: ['N', 'AZOT', 'CVT', 'EGT'],
-        0: ['Z', 'EGST', 'GMT', 'UTC', 'WET', 'WT'],
-        1: ['A', 'CET', 'DFT', 'WAT', 'WEDT', 'WEST'],
-        2: ['B', 'CAT', 'CEDT', 'CEST', 'EET', 'SAST', 'WAST'],
-        3: ['C', 'EAT', 'EEDT', 'EEST', 'IDT', 'MSK'],
-        4: ['D', 'AMT', 'AZT', 'GET', 'GST', 'KUYT', 'MSD', 'MUT', 'RET', 'SAMT', 'SCT'],
-        5: [
-            'E', 'AMST', 'AQTT', 'AZST', 'HMT', 'MAWT',
-            'MVT', 'PKT', 'TFT', 'TJT', 'TMT', 'UZT', 'YEKT',
-        ],
-        6: ['F', 'ALMT', 'BIOT', 'BTT', 'IOT', 'KGT', 'NOVT', 'OMST', 'YEKST'],
-        7: ['G', 'CXT', 'DAVT', 'HOVT', 'ICT', 'KRAT', 'NOVST', 'OMSST', 'THA', 'WIB'],
-        8: [
-            'H', 'ACT', 'AWST', 'BDT', 'BNT', 'CAST', 'HKT',
-            'IRKT', 'KRAST', 'MYT', 'PHT', 'SGT', 'ULAT', 'WITA', 'WST',
-        ],
-        9: ['I', 'AWDT', 'IRKST', 'JST', 'KST', 'PWT', 'TLT', 'WDT', 'WIT', 'YAKT'],
-        10: ['K', 'AEST', 'CST', 'PGT', 'VLAT', 'YAKST', 'YAPT'],
-        11: ['L', 'AEDT', 'LHDT', 'MAGT', 'NCT', 'PONT', 'SBT', 'VLAST', 'VUT'],
-        12: [
-            'M', 'ANAST', 'ANAT', 'FJT', 'GILT', 'MAGST',
-            'MHT', 'NZST', 'PETST', 'PETT', 'TVT', 'WFT',
-        ],
-        13: ['FJST', 'NZDT'],
-        11.5: ['NFT'],
-        10.5: ['ACDT', 'LHST'],
-        9.5: ['ACST'],
-        6.5: ['CCT', 'MMT'],
-        5.75: ['NPT'],
-        5.5: ['SLT'],
-        4.5: ['AFT', 'IRDT'],
-        3.5: ['IRST'],
-        -2.5: ['HAT', 'NDT'],
-        -3.5: ['HNT', 'NST', 'NT'],
-        -4.5: ['HLV', 'VET'],
-        -9.5: ['MART', 'MIT'],
-    }
-
-    tzinfos = {}
-    for offset, codes in tz_map.items():
-        offset = int(offset * 3600)
-        for code in codes:
-            tzinfos[code] = offset
-
-    return tzinfos
-
-
-tzinfos = generate_tzinfos()
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 61d9081..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,2 +0,0 @@
-[flake8]
-max-line-length = 99
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 78d8bd9..0000000
--- a/setup.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from setuptools import setup
-
-
-setup(
-    name='scrapbook',
-    version='0.2.0',
-    description='Simple scraping library.',
-    author='odoku',
-    author_email='masashi.onogawa@wamw.jp',
-    keywords='scraping',
-    url='https://github.com/odoku/scrapbook',
-    license='MIT',
-
-    packages=['scrapbook'],
-    install_requires=[
-        'parsel>=1.2.0',
-        'six>=1.10.0',
-        'python-dateutil>=2.7.0',
-    ],
-    extras_require={
-        'test': [
-            'flake8>=3.4.1',
-            'pytest>=3.2.2',
-            'pytest-mock>=1.6.3'
-        ],
-    }
-)
diff --git a/src/scrapbook/__init__.py b/src/scrapbook/__init__.py
new file mode 100644
index 0000000..e9fced9
--- /dev/null
+++ b/src/scrapbook/__init__.py
@@ -0,0 +1,3 @@
+from scrapbook.elements import BaseElement, Content, Element
+
+__all__ = ["BaseElement", "Content", "Element"]
diff --git a/src/scrapbook/elements.py b/src/scrapbook/elements.py
new file mode 100644
index 0000000..0285194
--- /dev/null
+++ b/src/scrapbook/elements.py
@@ -0,0 +1,200 @@
+import inspect
+from collections.abc import MutableMapping
+from typing import Any, Callable, Optional, Union, cast
+
+from parsel import Selector, SelectorList
+
+from scrapbook.exceptions import ScrapBookError
+from scrapbook.filters import Filter, FilterFunction, clean_text, through
+from scrapbook.parsers import First, ParserFunction
+from scrapbook.utils import merge_dict
+
+FilterFunctionOrStr = Union[str, FilterFunction]
+ParserFunctionOrStr = Union[str, ParserFunction]
+
+
+class BaseElement:
+    filter: Union[FilterFunctionOrStr, list[FilterFunctionOrStr]] = [through]
+
+    def __init__(
+        self,
+        xpath: Optional[str] = None,
+        filter: Optional[Union[FilterFunctionOrStr, list[FilterFunctionOrStr]]] = None,
+    ):
+        self.parent: Optional[BaseElement] = None
+        self.xpath = xpath
+        if filter:
+            self.filter = filter
+
+    def __get__(self, instance: Any, owner):
+        self.parent = instance
+        return self
+
+    @property
+    def is_descriptor(self):
+        return self.parent is not None
+
+    def get_function(self, fn: Union[str, Callable]) -> Callable:
+        if isinstance(fn, Filter):
+            fn.element = self
+            return fn
+
+        if callable(fn):
+            return fn
+
+        method = getattr(self, fn, None)
+        if method and callable(method):
+            return method
+
+        if self.parent and hasattr(self.parent, "get_function"):
+            return self.parent.get_function(fn)
+
+        raise ValueError("{} is not callable.".format(fn))
+
+    def get_filter(self) -> list[FilterFunction]:
+        if isinstance(self.filter, list):
+            filters = self.filter
+        else:
+            filters = [self.filter]
+        return [self.get_function(f) for f in filters]
+
+    def get_selector(self, html: Union[str, Selector]):
+        selector = Selector(text=html) if isinstance(html, str) else html
+        if self.xpath:
+            return selector.xpath(self.xpath)
+        return selector.xpath(".")
+
+    def parse(self, html: Union[str, Selector]):
+        raise NotImplementedError()
+
+
+class Element(BaseElement):
+    filter = [clean_text]
+    parser: ParserFunctionOrStr = First()
+
+    def __init__(
+        self,
+        xpath: Optional[str] = None,
+        filter: Optional[Union[FilterFunctionOrStr, list[FilterFunctionOrStr]]] = None,
+        parser: Optional[ParserFunctionOrStr] = None,
+    ):
+        if parser:
+            self.parser = parser
+        super(Element, self).__init__(xpath, filter)
+
+    def get_parser(self) -> ParserFunction:
+        return self.get_function(self.parser)
+
+    def _parse(self, selector: SelectorList[Selector]):
+        return self.get_parser()(selector)
+
+    def parse(self, html: Union[str, Selector]):
+        selector = self.get_selector(html)
+        if len(selector) == 0:
+            return None
+
+        value = None
+        try:
+            value = self._parse(selector)
+            for filter in self.get_filter():
+                value = filter(value)
+        except Exception as e:
+            raise ScrapBookError(parent=e, selector=selector, value=value) from e
+
+        return value
+
+
+class ContentMeta(type):
+    @classmethod
+    def __prepare__(metacls, name, bases):
+        return {"elements": {}}
+
+    def __new__(klass, name: str, bases: tuple[type, ...], attrs: dict[str, Any]):
+        new_class = cast("Content", super(ContentMeta, klass).__new__(klass, name, bases, attrs))
+
+        elements = {
+            attr: getattr(new_class, attr)
+            for attr in attrs
+            if not attr.startswith("_") and isinstance(getattr(new_class, attr), BaseElement)
+        }
+
+        for base in bases:
+            # if issubclass(base, Content):
+            if hasattr(base, "elements"):
+                elements = merge_dict(base.elements, elements)
+
+        new_class.elements = elements
+
+        return new_class
+
+
+class Content(BaseElement, metaclass=ContentMeta):
+    elements: dict[str, BaseElement]
+
+    def __init__(
+        self,
+        xpath: Optional[str] = None,
+        filter: Optional[Union[FilterFunctionOrStr, list[FilterFunctionOrStr]]] = None,
+        many=False,
+    ):
+        self.many = many
+        super(Content, self).__init__(xpath, filter)
+
+    def _parse(self, selector: Selector):
+        data = {}
+        for name in self.elements:
+            try:
+                data[name] = getattr(self, name).parse(selector)
+            except Exception as e:
+                raise ScrapBookError(parent=e, field=name) from e
+        return data
+
+    def parse(self, html: Union[str, Selector], object: Optional[Any] = None):
+        selector = self.get_selector(html)
+        if len(selector) == 0:
+            return None
+
+        if self.many:
+            value = [self._parse(s) for s in selector]
+        else:
+            value = self._parse(selector)
+
+        for filter in self.get_filter():
+            try:
+                value = filter(value)
+            except Exception as e:
+                raise ScrapBookError(parent=e, selector=selector, value=value) from e
+
+        return self._map_to(value, object)
+
+    def _map_to(self, value: Any, object: Optional[Any]):
+        if object is None:
+            return value
+
+        if isinstance(value, (list, tuple)):
+            return [self._map_value(v, object) for v in value]
+        return self._map_value(value, object)
+
+    def _map_value(self, value: Any, object: Optional[Any]):
+        if inspect.isclass(object):
+            object = object()
+
+        if isinstance(object, MutableMapping):
+            for k, v in value.items():
+                object[k] = v
+            return object
+
+        for k, v in value.items():
+            setattr(object, k, v)
+        return object
+
+    @classmethod
+    def inline(
+        base: type,
+        xpath: Optional[str] = None,
+        filter: Optional[Union[FilterFunctionOrStr, list[FilterFunctionOrStr]]] = None,
+        many=False,
+        **attrs,
+    ):
+        cls = type("InlineContent", (base,), attrs)
+        return cls(xpath, filter, many)
diff --git a/scrapbook/exceptions.py b/src/scrapbook/exceptions.py
similarity index 77%
rename from scrapbook/exceptions.py
rename to src/scrapbook/exceptions.py
index 31b348d..85c14d5 100644
--- a/scrapbook/exceptions.py
+++ b/src/scrapbook/exceptions.py
@@ -1,16 +1,13 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
+import io
 import sys
 import traceback
 
 from parsel import SelectorList
-import six
 
 
 def get_traceback_string():
     ex_type, ex, tb = sys.exc_info()
-    fp = six.StringIO()
+    fp = io.StringIO()
     traceback.print_tb(tb, file=fp)
     fp.seek(0)
     return fp.read()
@@ -24,18 +21,14 @@ def __init__(self, parent, selector=None, value=None, field=None):
         self._field = field
 
         super(ScrapBookError, self).__init__(self._create_message())
-        if six.PY3:
-            self.with_traceback(parent.__traceback__)
+        self.with_traceback(parent.__traceback__)
 
     def _create_message(self):
-        if six.PY2:
-            message = get_traceback_string() + '\n'
-        else:
-            message = ''
-
+        message = ""
         parent = self.parent
-        message += 'Raises {}: {}\nXPath: {}\nValue: {}\nField: {}'.format(
-            parent.__class__.__name__, str(parent),
+        message += "Raises {}: {}\nXPath: {}\nValue: {}\nField: {}".format(
+            parent.__class__.__name__,
+            str(parent),
             self.xpath,
             self.value,
             self.field,
@@ -82,6 +75,6 @@ def field(self):
         parent_field = self._parent.field if isinstance(self._parent, self.__class__) else None
 
         if parent_field and self._field:
-            return '{}.{}'.format(self._field, parent_field)
+            return "{}.{}".format(self._field, parent_field)
 
         return self._field
diff --git a/src/scrapbook/filters.py b/src/scrapbook/filters.py
new file mode 100644
index 0000000..a567d60
--- /dev/null
+++ b/src/scrapbook/filters.py
@@ -0,0 +1,323 @@
+import functools
+import html
+import re
+import unicodedata
+from collections.abc import Container, Iterable, Mapping
+from datetime import datetime, tzinfo
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar, Union
+
+from dateutil.parser import parse as parse_date_string
+
+from scrapbook.utils import remove_tags, tzinfos
+
+if TYPE_CHECKING:
+    from scrapbook.elements import BaseElement
+
+FilterFunction = Callable[[Any], Any]
+
+T = TypeVar("T")
+
+
+class Filter(object):
+    def __init__(self, empty_value: Optional[Any] = None):
+        self.element: Optional[BaseElement] = None
+        self.empty_value = empty_value
+
+    def __call__(self, value: Optional[Any]) -> Any:
+        if value is None:
+            return self.empty_value
+        return value
+
+
+class Map(Filter):
+    def __init__(self, *functions: FilterFunction, empty_value: Optional[Any] = None):
+        self._functions = list(functions)
+        super(Map, self).__init__(empty_value)
+
+    def __call__(self, value: Optional[Any]):
+        if value is None:
+            return self.empty_value
+
+        if isinstance(value, Mapping):
+            return self._run_mapping(value)
+
+        if isinstance(value, Iterable):
+            return self._run_iterable(value)
+
+        return self._run_other(value)
+
+    def _run_mapping(self, mapping: Mapping[str, Any]):
+        functions = self._get_functions()
+        return {k: functools.reduce(lambda vv, f: f(vv), functions, v) for k, v in mapping.items()}
+
+    def _run_iterable(self, iterable: Iterable[Any]):
+        functions = self._get_functions()
+        return list(
+            functools.reduce(
+                lambda v, f: map(f, v),
+                functions,
+                iterable,
+            )
+        )
+
+    def _run_other(self, value: Any):
+        functions = self._get_functions()
+        return functools.reduce(
+            lambda v, f: f(v),
+            functions,
+            value,
+        )
+
+    def _get_functions(self) -> list[FilterFunction]:
+        if not self.element:
+            return self._functions
+        return [self.element.get_function(fn) for fn in self._functions]
+
+
+class Through(Filter):
+    def __call__(self, value: Optional[Any]):
+        return value
+
+
+class TakeFirst(Filter):
+    def __call__(self, value: Optional[Iterable[Any]]):
+        if value is None:
+            return self.empty_value
+
+        for v in value:
+            if v is not None and v != "":
+                return v
+
+        return self.empty_value
+
+
+class CleanText(Filter):
+    def __init__(self, remove_line_breaks=False, empty_value: Optional[Any] = None):
+        super(CleanText, self).__init__(empty_value)
+        self.remove_line_breaks = remove_line_breaks
+
+    def __call__(self, value: Optional[str]):
+        if value is None or value == "":
+            return self.empty_value
+
+        retval = remove_tags(value)
+        retval = html.unescape(retval)
+        if self.remove_line_breaks:
+            retval = re.sub(r"(?:\n\r|\r\n|\n|\r)+", " ", retval)
+        retval = re.sub(r"[ 　]+", " ", retval)
+        retval = retval.strip()
+
+        if retval == "":
+            return self.empty_value
+
+        return retval
+
+
+class Equals(Filter):
+    def __init__(self, value: Optional[Any]):
+        super(Equals, self).__init__()
+        self.value = value
+
+    def __call__(self, value: Optional[Any]):
+        return self.value == value
+
+
+class Contains(Filter):
+    def __init__(self, value: Any, empty_value: Optional[Any] = None):
+        super(Contains, self).__init__(empty_value)
+        self.value = value
+
+    def __call__(self, value: Optional[Container]):
+        if value is None:
+            return self.empty_value
+        return self.value in value
+
+
+class Fetch(Filter):
+    def __init__(self, pattern: Union[str, re.Pattern], all=False, empty_value: Optional[Any] = None):
+        super(Fetch, self).__init__(empty_value)
+        self.pattern = pattern if isinstance(pattern, re.Pattern) else re.compile(pattern)
+        self.all = all
+
+    def __call__(self, value: Optional[str]):
+        if value is None:
+            return self.empty_value
+
+        if self.all:
+            return self._fetch_all(value)
+        return self._fetch(value)
+
+    def _fetch(self, value: str):
+        match = self.pattern.search(value)
+        if not match:
+            return self.empty_value
+        return self._get_value(match)
+
+    def _fetch_all(self, value: str):
+        data = []
+        for match in self.pattern.finditer(value):
+            data.append(self._get_value(match))
+        return data
+
+    def _get_value(self, match: re.Match):
+        dict_value = match.groupdict()
+        if dict_value:
+            return dict_value
+
+        list_value = match.groups()
+        if list_value:
+            return list(list_value)
+
+        return match.group(0)
+
+
+class Replace(Filter):
+    def __init__(
+        self,
+        pattern: Union[str, re.Pattern],
+        replace: Union[str, Callable[[re.Match[str]], str]],
+        empty_value: Optional[Any] = None,
+    ):
+        super(Replace, self).__init__(empty_value)
+        self.pattern = pattern if isinstance(pattern, re.Pattern) else re.compile(pattern)
+        self.replace = replace
+
+    def __call__(self, value: Optional[str]):
+        if value is None:
+            return self.empty_value
+        return self.pattern.sub(self.replace, value)
+
+
+class Join(Filter):
+    def __init__(self, separator="", empty_value: Optional[Any] = None):
+        super(Join, self).__init__(empty_value)
+        self.separator = separator
+
+    def __call__(self, value: Optional[Iterable[str]]):
+        if value is None:
+            return self.empty_value
+        return self.separator.join(value)
+
+
+class Split(Filter):
+    def __init__(self, delimiter=",", empty_value: Optional[Any] = None):
+        super(Split, self).__init__(empty_value)
+        self.delimiter = delimiter
+
+    def __call__(self, value: Optional[str]):
+        if value is None:
+            return self.empty_value
+        return value.split(self.delimiter)
+
+
+class Normalize(Filter):
+    def __init__(self, form: Literal["NFC", "NFD", "NFKC", "NFKD"] = "NFKD", empty_value: Optional[Any] = None):
+        super(Normalize, self).__init__(empty_value)
+        self.form = form
+
+    def __call__(self, value: Optional[str]):
+        if value is None:
+            return self.empty_value
+        return unicodedata.normalize(self.form, value)
+
+
+class RenameKey(Filter):
+    def __init__(self, name_map: Mapping[str, str], empty_value: Optional[Any] = None):
+        super(RenameKey, self).__init__(empty_value)
+        self.name_map = name_map
+
+    def __call__(self, value: Optional[Mapping[str, Any]]):
+        if value is None:
+            return self.empty_value
+        return {self.name_map.get(k, k): v for k, v in value.items()}
+
+
+class FilterDict(Filter):
+    def __init__(self, keys: Iterable[str], ignore=False, empty_value: Optional[Any] = None):
+        super(FilterDict, self).__init__(empty_value)
+        self.keys = keys
+        self.ignore = ignore
+
+    def __call__(self, value: Optional[Any]):
+        if value is None:
+            return self.empty_value
+
+        if self.ignore:
+            return {k: v for k, v in value.items() if k not in self.keys}
+
+        return {key: value[key] for key in self.keys if key in value}
+
+
+class Partial(Filter):
+    def __init__(
+        self,
+        fn: Callable,
+        args: Optional[list[Any]] = None,
+        kwargs: Optional[dict[str, Any]] = None,
+        arg_name=None,
+        empty_value: Optional[Any] = None,
+    ):
+        super(Partial, self).__init__(empty_value)
+        args = args or []
+        kwargs = kwargs or {}
+        self.fn = functools.partial(fn, *args, **kwargs)
+        self.arg_name = arg_name
+
+    def __call__(self, value: Optional[Any]):
+        if value is None:
+            return self.empty_value
+
+        if self.arg_name:
+            return self.fn(**{self.arg_name: value})
+        return self.fn(value)
+
+
+class DateTime(Filter):
+    def __init__(
+        self,
+        format: Optional[str] = None,
+        timezone: Optional[tzinfo] = None,
+        truncate_time=False,
+        truncate_timezone=False,
+        empty_value: Optional[Any] = None,
+    ):
+        super(DateTime, self).__init__(empty_value)
+        self.format = format
+        self.timezone = timezone
+        self.truncate_time = truncate_time
+        self.truncate_timezone = truncate_timezone
+
+    def __call__(self, value: Optional[str]):
+        if value is None:
+            return self.empty_value
+
+        if self.format:
+            dt = datetime.strptime(value, self.format)
+            if self.timezone:
+                dt = dt.replace(tzinfo=self.timezone)
+        else:
+            dt = parse_date_string(value, default=datetime(1, 1, 1), tzinfos=tzinfos)
+
+        if self.truncate_timezone:
+            dt = dt.replace(tzinfo=None)
+
+        if self.truncate_time:
+            return dt.date()
+
+        return dt
+
+
+class Bool(Filter):
+    def __init__(self, *true_values: str, empty_value: Optional[Any] = None):
+        super(Bool, self).__init__(empty_value)
+        self.true_values = true_values or ("true", "True", "TRUE", "yes", "Yes", "YES", "1")
+
+    def __call__(self, value: Optional[Any]):
+        if value is None:
+            return self.empty_value
+        return value in self.true_values
+
+
+through = Through()
+take_first = TakeFirst()
+clean_text = CleanText()
diff --git a/src/scrapbook/parsers.py b/src/scrapbook/parsers.py
new file mode 100644
index 0000000..7073de7
--- /dev/null
+++ b/src/scrapbook/parsers.py
@@ -0,0 +1,70 @@
+from typing import Any, Callable
+
+from parsel import Selector, SelectorList
+
+from scrapbook.filters import clean_text
+
+ParserFunction = Callable[[SelectorList[Selector]], Any]
+
+
+class First(object):
+    def __call__(self, selector: SelectorList[Selector]):
+        return selector.extract_first()
+
+
+class All(object):
+    def __call__(self, selector: SelectorList[Selector]):
+        return selector.extract()
+
+
+class ParseTable(object):
+    def __init__(self, has_header=False):
+        self.has_header = has_header
+
+    def __call__(self, selector: SelectorList[Selector]):
+        rows = selector.xpath(".//tr")
+
+        if self.has_header:
+            return self._parse_as_dict(rows)
+        return self._parse_as_list(rows)
+
+    def _parse_as_list(self, rows: SelectorList[Selector]):
+        data = []
+        for row in rows:
+            data.append([clean_text(column.xpath(".//text()").extract_first()) for column in row.xpath("./*")])
+
+        return data
+
+    def _parse_as_dict(self, rows: SelectorList[Selector]):
+        keys = [clean_text(e.xpath(".//text()").extract_first()) for e in rows[0].xpath("./*")]
+
+        data = []
+        for row in rows[1:]:
+            data.append(
+                {k: clean_text(row.xpath("./*[{}]//text()".format(i + 1)).extract_first()) for i, k in enumerate(keys)}
+            )
+
+        return data
+
+
+class ParseList(object):
+    def __call__(self, selector: SelectorList[Selector]):
+        return [clean_text(v) for v in selector.xpath("./li/text()").extract()]
+
+
+class ParseDefinitionList(object):
+    def __call__(self, selector: SelectorList[Selector]):
+        data: dict[str, list[str]] = {}
+
+        for s in selector.xpath("./dt | ./dd"):
+            tag = s.extract()
+            if tag.startswith("<dt>"):
+                current_key = clean_text(tag)
+                data[current_key] = []
+            else:
+                try:
+                    data[current_key].append(clean_text(tag))
+                except NameError:
+                    pass
+
+        return {k: v if len(v) > 1 else v[0] for k, v in data.items()}
diff --git a/src/scrapbook/utils.py b/src/scrapbook/utils.py
new file mode 100644
index 0000000..97eae4b
--- /dev/null
+++ b/src/scrapbook/utils.py
@@ -0,0 +1,122 @@
+import functools
+import re
+
+
+def merge_dict(*dicts):
+    return functools.reduce(lambda a, b: dict(a, **b), dicts)
+
+
+def remove_tags(text: str):
+    pattern = re.compile(r"<[^>]+>")
+    return pattern.sub("", text)
+
+
+def generate_tzinfos():
+    tz_map = {
+        -12: ["Y"],
+        -11: ["X", "NUT", "SST"],
+        -10: ["W", "CKT", "HAST", "HST", "TAHT", "TKT"],
+        -9: ["V", "AKST", "GAMT", "GIT", "HADT", "HNY"],
+        -8: ["U", "AKDT", "CIST", "HAY", "HNP", "PST", "PT"],
+        -7: ["T", "HAP", "HNR", "MST", "PDT"],
+        -6: ["S", "CST", "EAST", "GALT", "HAR", "HNC", "MDT"],
+        -5: ["R", "CDT", "COT", "EASST", "ECT", "EST", "ET", "HAC", "HNE", "PET"],
+        -4: ["Q", "AST", "BOT", "CLT", "COST", "EDT", "FKT", "GYT", "HAE", "HNA", "PYT"],
+        -3: [
+            "P",
+            "ADT",
+            "ART",
+            "BRT",
+            "CLST",
+            "FKST",
+            "GFT",
+            "HAA",
+            "PMST",
+            "PYST",
+            "SRT",
+            "UYT",
+            "WGT",
+        ],
+        -2: ["O", "BRST", "FNT", "PMDT", "UYST", "WGST"],
+        -1: ["N", "AZOT", "CVT", "EGT"],
+        0: ["Z", "EGST", "GMT", "UTC", "WET", "WT"],
+        1: ["A", "CET", "DFT", "WAT", "WEDT", "WEST"],
+        2: ["B", "CAT", "CEDT", "CEST", "EET", "SAST", "WAST"],
+        3: ["C", "EAT", "EEDT", "EEST", "IDT", "MSK"],
+        4: ["D", "AMT", "AZT", "GET", "GST", "KUYT", "MSD", "MUT", "RET", "SAMT", "SCT"],
+        5: [
+            "E",
+            "AMST",
+            "AQTT",
+            "AZST",
+            "HMT",
+            "MAWT",
+            "MVT",
+            "PKT",
+            "TFT",
+            "TJT",
+            "TMT",
+            "UZT",
+            "YEKT",
+        ],
+        6: ["F", "ALMT", "BIOT", "BTT", "IOT", "KGT", "NOVT", "OMST", "YEKST"],
+        7: ["G", "CXT", "DAVT", "HOVT", "ICT", "KRAT", "NOVST", "OMSST", "THA", "WIB"],
+        8: [
+            "H",
+            "ACT",
+            "AWST",
+            "BDT",
+            "BNT",
+            "CAST",
+            "HKT",
+            "IRKT",
+            "KRAST",
+            "MYT",
+            "PHT",
+            "SGT",
+            "ULAT",
+            "WITA",
+            "WST",
+        ],
+        9: ["I", "AWDT", "IRKST", "JST", "KST", "PWT", "TLT", "WDT", "WIT", "YAKT"],
+        10: ["K", "AEST", "CST", "PGT", "VLAT", "YAKST", "YAPT"],
+        11: ["L", "AEDT", "LHDT", "MAGT", "NCT", "PONT", "SBT", "VLAST", "VUT"],
+        12: [
+            "M",
+            "ANAST",
+            "ANAT",
+            "FJT",
+            "GILT",
+            "MAGST",
+            "MHT",
+            "NZST",
+            "PETST",
+            "PETT",
+            "TVT",
+            "WFT",
+        ],
+        13: ["FJST", "NZDT"],
+        11.5: ["NFT"],
+        10.5: ["ACDT", "LHST"],
+        9.5: ["ACST"],
+        6.5: ["CCT", "MMT"],
+        5.75: ["NPT"],
+        5.5: ["SLT"],
+        4.5: ["AFT", "IRDT"],
+        3.5: ["IRST"],
+        -2.5: ["HAT", "NDT"],
+        -3.5: ["HNT", "NST", "NT"],
+        -4.5: ["HLV", "VET"],
+        -9.5: ["MART", "MIT"],
+    }
+
+    tzinfos = {}
+    for offset, codes in tz_map.items():
+        offset = int(offset * 3600)
+        for code in codes:
+            tzinfos[code] = offset
+
+    return tzinfos
+
+
+tzinfos = generate_tzinfos()
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/html/parse_definition_list/definition_list.html b/tests/assets/parse_definition_list/definition_list.html
similarity index 100%
rename from tests/html/parse_definition_list/definition_list.html
rename to tests/assets/parse_definition_list/definition_list.html
diff --git a/tests/html/parse_list/ordered_list.html b/tests/assets/parse_list/ordered_list.html
similarity index 100%
rename from tests/html/parse_list/ordered_list.html
rename to tests/assets/parse_list/ordered_list.html
diff --git a/tests/html/parse_list/unordered_list.html b/tests/assets/parse_list/unordered_list.html
similarity index 100%
rename from tests/html/parse_list/unordered_list.html
rename to tests/assets/parse_list/unordered_list.html
diff --git a/tests/html/parse_table/table.html b/tests/assets/parse_table/table.html
similarity index 100%
rename from tests/html/parse_table/table.html
rename to tests/assets/parse_table/table.html
diff --git a/tests/html/parse_table/table_has_thead_and_tbody.html b/tests/assets/parse_table/table_has_thead_and_tbody.html
similarity index 100%
rename from tests/html/parse_table/table_has_thead_and_tbody.html
rename to tests/assets/parse_table/table_has_thead_and_tbody.html
diff --git a/tests/conftest.py b/tests/conftest.py
deleted file mode 100644
index 59ce9f6..0000000
--- a/tests/conftest.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals, print_function
-
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
diff --git a/tests/filters_test.py b/tests/filters_test.py
deleted file mode 100644
index 0ef9ee1..0000000
--- a/tests/filters_test.py
+++ /dev/null
@@ -1,334 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-from datetime import date, datetime
-
-from dateutil.tz import tzoffset
-import pytest
-
-from scrapbook import Content, Element
-from scrapbook.filters import (
-    Bool,
-    CleanText,
-    Contains,
-    DateTime,
-    Equals,
-    Fetch,
-    FilterDict,
-    Join,
-    Map,
-    Normalize,
-    Partial,
-    RenameKey,
-    Replace,
-    take_first,
-    through,
-)
-from scrapbook.parsers import All
-
-
-class TestMap(object):
-    def test_with_int(self, mocker):
-        fn1 = mocker.Mock(name='fn1', return_value=1)
-        fn2 = mocker.Mock(name='fn2', return_value=2)
-
-        result = Map(fn1, fn2)(0)
-
-        fn1.assert_called_once_with(0)
-        fn2.assert_called_once_with(1)
-        assert 2 == result
-
-    def test_with_dict(self, mocker):
-        fn1 = mocker.Mock(name='fn1', side_effect=lambda v: v * 2)
-        fn2 = mocker.Mock(name='fn2', side_effect=lambda v: v * 10)
-
-        result = Map(fn1, fn2)({'AAA': 1, 'BBB': 2})
-
-        fn1.assert_has_calls([mocker.call(1), mocker.call(2)], any_order=True)
-        fn2.assert_has_calls([mocker.call(2), mocker.call(4)], any_order=True)
-        assert {'AAA': 20, 'BBB': 40} == result
-
-    def test_with_list(self, mocker):
-        fn1 = mocker.Mock(name='fn1', side_effect=lambda v: v * 2)
-        fn2 = mocker.Mock(name='fn2', side_effect=lambda v: v * 10)
-
-        result = Map(fn1, fn2)([1, 2])
-
-        fn1.assert_has_calls([mocker.call(1), mocker.call(2)], any_order=True)
-        fn2.assert_has_calls([mocker.call(2), mocker.call(4)], any_order=True)
-        assert [20, 40] == result
-
-    def test_with_none(self, mocker):
-        fn1 = mocker.Mock(name='fn1', side_effect=lambda v: v)
-        fn2 = mocker.Mock(name='fn2', side_effect=lambda v: v)
-
-        result = Map(fn1, fn2)(None)
-
-        fn1.assert_not_called()
-        fn2.assert_not_called()
-        assert result is None
-
-    def test_on_element(self, mocker):
-        class El(Element):
-            def fn2(self, value):
-                pass
-
-        fn1 = mocker.Mock(name='fn1', side_effect=lambda v: v * 2)
-        fn2 = mocker.patch.object(target=El, attribute='fn2', side_effect=lambda v: v * 3)
-
-        element = El(xpath='//p/text()', parser=All(), filter=Map(fn1, 'fn2'))
-        result = element.parse(u'<p>a</p><p>b</p>')
-
-        fn1.assert_has_calls([mocker.call('a'), mocker.call('b')], any_order=True)
-        fn2.assert_has_calls([mocker.call('aa'), mocker.call('bb'), ], any_order=True)
-        assert ['aaaaaa', 'bbbbbb'] == result
-
-    def test_on_content(self, mocker):
-        fn1 = mocker.Mock(name='fn1', side_effect=lambda v: v * 2)
-
-        class C(Content):
-            field = Element(xpath='//p/text()', parser=All(), filter=Map(fn1, 'fn2'))
-
-            def fn2(self, value):
-                pass
-
-        fn2 = mocker.patch.object(target=C, attribute='fn2', side_effect=lambda v: v * 3)
-
-        c = C(xpath='')
-        result = c.parse(u'<p>a</p><p>b</p>')
-
-        fn1.assert_has_calls([mocker.call('a'), mocker.call('b')], any_order=True)
-        fn2.assert_has_calls([mocker.call('aa'), mocker.call('bb'), ], any_order=True)
-        assert ['aaaaaa', 'bbbbbb'] == result['field']
-
-
-class TestThrough(object):
-    def test_(self):
-        value = 100
-        assert value == through(value)
-
-    def test_with_none(self):
-        assert through(None) is None
-
-
-class TestTakeFirst(object):
-    def test_(self):
-        assert 1 == take_first([1, 2, 3, 4])
-
-    def test_with_list_include_empty_value(self):
-        assert 0 == take_first([None, '', 0, 1])
-
-    def test_with_none(self):
-        assert take_first(None) is None
-
-
-class TestCleanText(object):
-    @pytest.mark.parametrize(['text', 'result'], [
-        ('  aaa  ', 'aaa'),
-        ('<p>aaa</p>', 'aaa'),
-        ('&amp;', '&'),
-        ('aa       bb', 'aa bb'),
-        ('<p>  aaa  &amp;  bbb  </p>', 'aaa & bbb'),
-        ('a\nb', 'a\nb'),
-        ('', None),
-        (None, None),
-    ])
-    def test_(self, text, result):
-        assert result == CleanText()(text)
-
-    def test_with_empty_value(self):
-        assert 'empty' == CleanText(empty_value='empty')('')
-
-    @pytest.mark.parametrize(['text', 'result'], [
-        ('a\nb', 'a b'),
-        ('a\rb', 'a b'),
-        ('a\n\rb', 'a b'),
-        ('a\r\nb', 'a b'),
-    ])
-    def test_with_remove_line_breaks(self, text, result):
-        assert result == CleanText(remove_line_breaks=True)(text)
-
-
-class TestEquals(object):
-    def test_(self):
-        assert Equals('AAA')('AAA')
-        assert not Equals('AAA')('AAABBBCCC')
-        assert not Equals('AAA')(None)
-
-
-class TestContains(object):
-    def test_(self):
-        assert Contains('BBB')('AAABBBCCC')
-        assert not Contains('DDD')('AAABBBCCC')
-        assert not Contains('AAA')(None)
-
-
-class TestFetch(object):
-    def test_fetch(self):
-        pattern = r'\d+'
-        result = Fetch(pattern)('10, 20, 30')
-        assert '10' == result
-
-    def test_fetch_with_group(self):
-        pattern = r'(\d+), (\d+), (\d+)'
-        result = Fetch(pattern)('10, 20, 30')
-        assert ('10', '20', '30') == result
-
-    def test_fetch_with_labeled_group(self):
-        pattern = r'(?P<type>\w+): (?P<count>\d+)'
-        result = Fetch(pattern)('Cat: 10, Dog: 20')
-        assert {'type': 'Cat', 'count': '10'} == result
-
-    def test_fetch_with_none(self):
-        pattern = r'(?P<type>\w+): (?P<count>\d+)'
-        result = Fetch(pattern)(None)
-        assert result is None
-
-    def test_fetch_all(self):
-        pattern = r'\d+'
-        result = Fetch(pattern, all=True)('10, 20, 30')
-        assert ['10', '20', '30'] == result
-
-    def test_fetch_all_with_group(self):
-        pattern = r'(\d+), (\d+), (\d+)'
-        result = Fetch(pattern, all=True)('10, 20, 30')
-        assert [('10', '20', '30')] == result
-
-    def test_fetch_all_with_labeled_group(self):
-        pattern = r'(?P<type>\w+): (?P<count>\d+)'
-        result = Fetch(pattern, all=True)('Cat: 10, Dog: 20')
-        assert [
-            {'type': 'Cat', 'count': '10'},
-            {'type': 'Dog', 'count': '20'},
-        ] == result
-
-    def test_fetch_all_with_none(self):
-        pattern = r'(?P<type>\w+): (?P<count>\d+)'
-        result = Fetch(pattern, all=True)(None)
-        assert result is None
-
-
-class TestReplace(object):
-    def test_(self):
-        pattern = r'A+'
-        replace = 'B'
-        result = Replace(pattern, replace)('AAAAAABBBAAAA')
-        assert 'BBBBB' == result
-
-    def test_with_none(self):
-        pattern = r'A+'
-        replace = 'B'
-        result = Replace(pattern, replace)(None)
-        assert result is None
-
-
-class TestJoin(object):
-    def test_(self):
-        assert 'A,B,C' == Join(',')(['A', 'B', 'C'])
-
-    def test_with_none(self):
-        assert Join(',')(None) is None
-
-
-class TestNormalize(object):
-    def test_(self):
-        assert '12AB&%' == Normalize()(u'１２ＡＢ＆％')
-
-    def test_with_none(self):
-        assert Normalize()(None) is None
-
-
-class TestRenameKey(object):
-    def test_(self):
-        name_map = {'AAA': 'XXX', 'BBB': 'YYY'}
-        result = RenameKey(name_map)({'AAA': '10', 'BBB': '20'})
-        assert {'XXX': '10', 'YYY': '20'} == result
-
-    def test_with_none(self):
-        name_map = {'AAA': 'XXX', 'BBB': 'YYY'}
-        result = RenameKey(name_map)(None)
-        assert result is None
-
-
-class TestFilterDict(object):
-    def test_(self):
-        keys = ['AAA']
-        result = FilterDict(keys)({'AAA': '10', 'BBB': '20'})
-        assert {'AAA': '10'} == result
-
-    def test_with_ignore(self):
-        keys = ['AAA']
-        result = FilterDict(keys, ignore=True)({'AAA': '10', 'BBB': '20'})
-        assert {'BBB': '20'} == result
-
-    def test_with_none(self):
-        keys = ['AAA']
-        result = FilterDict(keys)(None)
-        assert result is None
-
-
-class TestPartial(object):
-    def test_with_args(self):
-        def add(a, b, c):
-            return a + b + c
-        result = Partial(add, args=(10, 20))(30)
-        assert 60 == result
-
-    def test_with_kwargs(self):
-        def add(a, b):
-            return a + b
-        result = Partial(add, kwargs={'b': 10})(5)
-        assert 15 == result
-
-    def test_with_arg_name(self):
-        def add(a, b, c):
-            return a + b + c
-        result = Partial(add, kwargs={'a': 10, 'c': 30}, arg_name='b')(20)
-        assert 60 == result
-
-
-class TestDateTime(object):
-    @pytest.mark.parametrize(['value', 'result'], [
-        ('2001', datetime(2001, 1, 1)),
-        ('2001-02', datetime(2001, 2, 1)),
-        ('2001-02-03', datetime(2001, 2, 3)),
-        ('2001-02-03 04:05:06', datetime(2001, 2, 3, 4, 5, 6)),
-        ('2001-02-03T04:05:06+09:00', datetime(2001, 2, 3, 4, 5, 6, 0, tzoffset(None, 3600 * 9))),
-    ])
-    def test_(self, value, result):
-        dt = DateTime()(value)
-        assert dt == result
-
-    @pytest.mark.parametrize(['value', 'format', 'result'], [
-        ('2001', '%Y', datetime(2001, 1, 1)),
-        ('02 2001', '%m %Y', datetime(2001, 2, 1)),
-    ])
-    def test_with_format(self, value, format, result):
-        dt = DateTime(format=format)(value)
-        assert dt == result
-
-    def test_with_truncate_time(self):
-        dt = DateTime(truncate_time=True)('2001-02-03 04:05:06')
-        assert dt == date(2001, 2, 3)
-
-    def test_with_truncate_timezone(self):
-        dt = DateTime(truncate_timezone=True)('2001-02-03T04:05:06+09:00')
-        assert dt.tzinfo is None
-
-
-class TestBool(object):
-    @pytest.mark.parametrize(['value', 'result'], [
-        ('true', True),
-        ('false', False),
-    ])
-    def test_(self, value, result):
-        assert result == Bool()(value)
-
-    @pytest.mark.parametrize(['value', 'result'], [
-        ('OK', True),
-        ('ok', True),
-        ('true', False),
-        ('ng', False),
-    ])
-    def test_with_true_values(self, value, result):
-        assert result == Bool('OK', 'ok')(value)
diff --git a/tests/parsers_test.py b/tests/parsers_test.py
deleted file mode 100644
index 0dfe814..0000000
--- a/tests/parsers_test.py
+++ /dev/null
@@ -1,125 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-import os
-
-from parsel import Selector
-import pytest
-import six
-
-from scrapbook.parsers import (
-    All,
-    First,
-    ParseDefinitionList,
-    ParseList,
-    ParseTable,
-)
-
-
-basepath = os.path.dirname(os.path.abspath(__file__))
-html_dir = os.path.join(basepath, 'html')
-
-
-def load_html(filepath):
-    filepath = os.path.join(html_dir, filepath)
-    with open(filepath) as fp:
-        return six.u(fp.read())
-
-
-class TestFirst(object):
-    def test_(self):
-        selector = Selector(u'<html><body><p>aaa<br>bbb<br>ccc</p></body></html>')
-        assert 'aaa' == First()(selector.xpath('//html/body/p/text()'))
-
-
-class TestAll(object):
-    def test_(self):
-        selector = Selector(u'<html><body><p>aaa<br>bbb<br>ccc</p></body></html>')
-        assert ['aaa', 'bbb', 'ccc'] == All()(selector.xpath('//html/body/p/text()'))
-
-
-class TestParseTable(object):
-    @pytest.mark.parametrize('filepath', [
-        'parse_table/table.html',
-        'parse_table/table_has_thead_and_tbody.html',
-    ])
-    def test_(self, filepath):
-        selector = Selector(load_html(filepath))
-        result = ParseTable()(selector.xpath('//table'))
-        expected = [
-            ['Company', 'Contact', 'Country'],
-            ['Alfreds Futterkiste', 'Maria Anders', 'Germany'],
-            ['Centro comercial Moctezuma', 'Francisco Chang', 'Mexico'],
-            ['Ernst Handel', 'Roland Mendel', 'Austria'],
-            ['Island Trading', 'Helen Bennett', 'UK'],
-            ['Laughing Bacchus Winecellars', 'Yoshi Tannamuri', 'Canada'],
-            ['Magazzini Alimentari Riuniti', 'Giovanni Rovelli', None],
-        ]
-        assert expected == result
-
-    @pytest.mark.parametrize('filepath', [
-        'parse_table/table.html',
-        'parse_table/table_has_thead_and_tbody.html',
-    ])
-    def test_with_table_has_header(self, filepath):
-        selector = Selector(load_html(filepath))
-        result = ParseTable(has_header=True)(selector.xpath('//table'))
-        expected = [
-            {
-                'Company': 'Alfreds Futterkiste',
-                'Contact': 'Maria Anders',
-                'Country': 'Germany',
-            },
-            {
-                'Company': 'Centro comercial Moctezuma',
-                'Contact': 'Francisco Chang',
-                'Country': 'Mexico',
-            },
-            {
-                'Company': 'Ernst Handel',
-                'Contact': 'Roland Mendel',
-                'Country': 'Austria',
-            },
-            {
-                'Company': 'Island Trading',
-                'Contact': 'Helen Bennett',
-                'Country': 'UK',
-            },
-            {
-                'Company': 'Laughing Bacchus Winecellars',
-                'Contact': 'Yoshi Tannamuri',
-                'Country': 'Canada',
-            },
-            {
-                'Company': 'Magazzini Alimentari Riuniti',
-                'Contact': 'Giovanni Rovelli',
-                'Country': None,
-            },
-        ]
-        assert expected == result
-
-
-class TestParseList(object):
-    @pytest.mark.parametrize('filepath', [
-        'parse_list/unordered_list.html',
-        'parse_list/ordered_list.html',
-    ])
-    def test_(self, filepath):
-        selector = Selector(load_html(filepath))
-        result = ParseList()(selector.xpath('//ul | //ol'))
-        expected = ['Coffee', 'Tea', 'Milk']
-        assert expected == result
-
-
-class TestParseDefinitionList(object):
-    def test_(self):
-        selector = Selector(load_html('parse_definition_list/definition_list.html'))
-        result = ParseDefinitionList()(selector.xpath('//dl'))
-        expected = {
-            'Coffee': '- black hot drink',
-            'Milk': [
-                '- white cold drink',
-                '- white hot drink',
-            ],
-        }
-        assert expected == result
diff --git a/tests/scrapbook/__init__.py b/tests/scrapbook/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/core_test.py b/tests/scrapbook/elements.py
similarity index 52%
rename from tests/core_test.py
rename to tests/scrapbook/elements.py
index 572eb9d..0914d3c 100644
--- a/tests/core_test.py
+++ b/tests/scrapbook/elements.py
@@ -1,11 +1,8 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
 from collections import OrderedDict
 
 from parsel import Selector
 
-from scrapbook import (
+from scrapbook.elements import (
     BaseElement,
     Content,
     Element,
@@ -34,9 +31,9 @@ def fn2(self, value):
 
         a = A()
         assert fn1 == a.get_function(fn1)
-        assert a.fn2 == a.get_function('fn2')
+        assert a.fn2 == a.get_function("fn2")
         assert fn1 == a.element.get_function(fn1)
-        assert a.fn2 == a.element.get_function('fn2')
+        assert a.fn2 == a.element.get_function("fn2")
 
     def test_get_filter(self, mocker):
         def fn1(value):
@@ -44,24 +41,23 @@ def fn1(value):
 
         class A(BaseElement):
             element1 = BaseElement(filter=fn1)
-            element2 = BaseElement(filter='fn2')
-            element3 = BaseElement(filter=[fn1, 'fn2'])
+            element2 = BaseElement(filter="fn2")
+            element3 = BaseElement(filter=[fn1, "fn2"])
 
             def fn2(self, value):
                 return 2
 
-        a = A(filter='fn2')
+        a = A(filter="fn2")
         assert [a.fn2] == a.get_filter()
         assert [fn1] == a.element1.get_filter()
         assert [a.fn2] == a.element2.get_filter()
         assert [fn1, a.fn2] == a.element3.get_filter()
 
     def test_get_selector(self):
-        html = Selector(u'<html><body><p><a href="http://google.com">Link</a></p></body></html>')
+        html = Selector('<html><body><p><a href="http://google.com">Link</a></p></body></html>')
 
-        assert BaseElement().get_selector(html).extract() == html.xpath('.').extract()
-        assert BaseElement(xpath='/p/a').get_selector(html).extract() == \
-            html.xpath('/p/a').extract()
+        assert BaseElement().get_selector(html).extract() == html.xpath(".").extract()
+        assert BaseElement(xpath="/p/a").get_selector(html).extract() == html.xpath("/p/a").extract()
 
 
 class TestContent(object):
@@ -80,56 +76,56 @@ class D(A, C):
             el4 = Element()
 
         assert D().elements == {
-            'el1': A.el1,
-            'el2': B.el2,
-            'el3': C.el3,
-            'el4': D.el4,
+            "el1": A.el1,
+            "el2": B.el2,
+            "el3": C.el3,
+            "el4": D.el4,
         }
 
     def test_parse(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
 
         class A(Content):
-            el1 = Element(xpath='/html/body/p/a/text()')
-            el2 = Element(xpath='/html/body/p/a/@href')
+            el1 = Element(xpath="/html/body/p/a/text()")
+            el2 = Element(xpath="/html/body/p/a/@href")
 
         assert A().parse(html) == {
-            'el1': 'Link',
-            'el2': 'http://google.com',
+            "el1": "Link",
+            "el2": "http://google.com",
         }
 
     def test_parse_with_mutable_mapping_instance(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
 
         class A(Content):
-            el1 = Element(xpath='/html/body/p/a/text()')
-            el2 = Element(xpath='/html/body/p/a/@href')
+            el1 = Element(xpath="/html/body/p/a/text()")
+            el2 = Element(xpath="/html/body/p/a/@href")
 
         obj = OrderedDict()
 
         result = A().parse(html, object=obj)
         assert isinstance(result, OrderedDict)
-        assert 'Link' == result['el1']
-        assert 'http://google.com' == result['el2']
+        assert "Link" == result["el1"]
+        assert "http://google.com" == result["el2"]
 
     def test_parse_with_mutable_mapping_class(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
 
         class A(Content):
-            el1 = Element(xpath='/html/body/p/a/text()')
-            el2 = Element(xpath='/html/body/p/a/@href')
+            el1 = Element(xpath="/html/body/p/a/text()")
+            el2 = Element(xpath="/html/body/p/a/@href")
 
         result = A().parse(html, object=OrderedDict)
         assert isinstance(result, OrderedDict)
-        assert 'Link' == result['el1']
-        assert 'http://google.com' == result['el2']
+        assert "Link" == result["el1"]
+        assert "http://google.com" == result["el2"]
 
     def test_parse_with_object(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
 
         class A(Content):
-            el1 = Element(xpath='/html/body/p/a/text()')
-            el2 = Element(xpath='/html/body/p/a/@href')
+            el1 = Element(xpath="/html/body/p/a/text()")
+            el2 = Element(xpath="/html/body/p/a/@href")
 
         class Obj(object):
             def __init__(self):
@@ -140,57 +136,55 @@ def __init__(self):
 
         result = A().parse(html, object=obj)
         assert isinstance(result, Obj)
-        assert 'Link' == result.el1
-        assert 'http://google.com' == result.el2
+        assert "Link" == result.el1
+        assert "http://google.com" == result.el2
 
     def test_parse_many(self):
-        html = u'<html><body><ul><li>1</li><li>2</li><li>3</li></ul></body></html>'
+        html = "<html><body><ul><li>1</li><li>2</li><li>3</li></ul></body></html>"
 
         class A(Content):
-            value = Element(xpath='./text()')
+            value = Element(xpath="./text()")
 
-        result = A(xpath='/html/body/ul/li', many=True).parse(html)
+        result = A(xpath="/html/body/ul/li", many=True).parse(html)
         assert [
-            {'value': '1'},
-            {'value': '2'},
-            {'value': '3'},
+            {"value": "1"},
+            {"value": "2"},
+            {"value": "3"},
         ] == result
 
     def test_parse_many_with_object(self):
-        html = u'<html><body><ul><li>1</li><li>2</li><li>3</li></ul></body></html>'
+        html = "<html><body><ul><li>1</li><li>2</li><li>3</li></ul></body></html>"
 
         class A(Content):
-            value = Element(xpath='./text()')
+            value = Element(xpath="./text()")
 
         class Obj(object):
             def __init__(self):
                 self.value = None
 
-        result = A(xpath='/html/body/ul/li', many=True).parse(html, object=Obj)
+        result = A(xpath="/html/body/ul/li", many=True).parse(html, object=Obj)
         assert isinstance(result, list)
         assert 3 == len(result)
         assert isinstance(result[0], Obj)
-        assert '1' == result[0].value
+        assert "1" == result[0].value
         assert isinstance(result[1], Obj)
-        assert '2' == result[1].value
+        assert "2" == result[1].value
         assert isinstance(result[2], Obj)
-        assert '3' == result[2].value
+        assert "3" == result[2].value
 
     def test_inline(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
 
         class A(Content):
-            content = Content.inline(
-                el1=Element(xpath='/html/body/p/a/text()', filter='twice')
-            )
-            el2 = Element(xpath='/html/body/p/a/@href')
+            content = Content.inline(el1=Element(xpath="/html/body/p/a/text()", filter="twice"))
+            el2 = Element(xpath="/html/body/p/a/@href")
 
             def twice(self, value):
                 return value * 2
 
         assert A().parse(html) == {
-            'content': {'el1': 'LinkLink'},
-            'el2': 'http://google.com',
+            "content": {"el1": "LinkLink"},
+            "el2": "http://google.com",
         }
 
 
@@ -201,7 +195,7 @@ def fn1(value):
 
         class A(Content):
             element1 = Element(parser=fn1)
-            element2 = Element(parser='fn2')
+            element2 = Element(parser="fn2")
 
             def fn2(self, value):
                 return 2
@@ -211,5 +205,5 @@ def fn2(self, value):
         assert a.element2.get_parser() == a.fn2
 
     def test_parse(self):
-        html = u'<html><body><p><a href="http://google.com">Link</a></p></body></html>'
-        assert Element(xpath='/html/body/p/a/text()').parse(html) == 'Link'
+        html = '<html><body><p><a href="http://google.com">Link</a></p></body></html>'
+        assert Element(xpath="/html/body/p/a/text()").parse(html) == "Link"
diff --git a/tests/exceptions_test.py b/tests/scrapbook/exceptions.py
similarity index 53%
rename from tests/exceptions_test.py
rename to tests/scrapbook/exceptions.py
index d622269..57f9a0f 100644
--- a/tests/exceptions_test.py
+++ b/tests/scrapbook/exceptions.py
@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
+import pytest
 from parsel import Selector
 
 from scrapbook import Content, Element, filters
@@ -9,7 +7,7 @@
 
 class TestScrapBookError(object):
     def test_get_parent_property(self):
-        ex1 = Exception('Root exception')
+        ex1 = Exception("Root exception")
 
         ex2 = ScrapBookError(ex1)
         assert ex2.parent == ex1
@@ -18,7 +16,7 @@ def test_get_parent_property(self):
         assert ex3.parent == ex1
 
     def test_get_value_property(self):
-        ex1 = Exception('Root exception')
+        ex1 = Exception("Root exception")
 
         ex2 = ScrapBookError(ex1, value=10)
         assert ex2.value == 10
@@ -30,71 +28,65 @@ def test_get_value_property(self):
         assert ex4.value == 20
 
     def test_get_selector_property(self):
-        ex1 = Exception('Root exception')
+        ex1 = Exception("Root exception")
 
-        s1 = Selector(u'<p />')
+        s1 = Selector("<p />")
         ex2 = ScrapBookError(ex1, selector=s1)
         assert ex2.selector == s1
 
         ex3 = ScrapBookError(ex2)
         assert ex3.selector == s1
 
-        s2 = Selector(u'<div />')
+        s2 = Selector("<div />")
         ex4 = ScrapBookError(ex3, selector=s2)
         assert ex4.selector == s2
 
     def test_get_xpath_property(self):
-        ex1 = Exception('Root exception')
+        ex1 = Exception("Root exception")
 
         ex2 = ScrapBookError(ex1)
         assert ex2.xpath is None
 
-        s1 = Selector(u'<p><span>zzz</span></p>')
-        s1 = s1.xpath('/html/body/p')
+        s1 = Selector("<p><span>zzz</span></p>")
+        s1 = s1.xpath("/html/body/p")
         ex3 = ScrapBookError(ex2, selector=s1)
-        assert ex3.xpath == '/html/body/p'
+        assert ex3.xpath == "/html/body/p"
 
         ex4 = ScrapBookError(ex3)
-        assert ex4.xpath == '/html/body/p'
+        assert ex4.xpath == "/html/body/p"
 
-        s2 = s1.xpath('./span')
+        s2 = s1.xpath("./span")
         ex5 = ScrapBookError(ex4, selector=s2)
-        assert ex5.xpath == './span'
+        assert ex5.xpath == "./span"
 
     def test_get_field_property(self):
-        ex1 = Exception('Root exception')
+        ex1 = Exception("Root exception")
 
         ex2 = ScrapBookError(ex1)
         assert ex2.field is None
 
-        ex3 = ScrapBookError(ex2, field='aaa')
-        assert ex3.field == 'aaa'
+        ex3 = ScrapBookError(ex2, field="aaa")
+        assert ex3.field == "aaa"
 
-        ex4 = ScrapBookError(ex3, field='bbb')
-        assert ex4.field == 'bbb.aaa'
+        ex4 = ScrapBookError(ex3, field="bbb")
+        assert ex4.field == "bbb.aaa"
 
     def test_with_content(self):
         content = Content.inline(
-            xpath='/html',
-            field1=Content.inline(
-                xpath='./body',
-                field2=Element('./p/text()', filter=filters.DateTime())
-            ),
+            xpath="/html",
+            field1=Content.inline(xpath="./body", field2=Element("./p/text()", filter=filters.DateTime())),
         )
 
-        try:
-            content.parse(u'''
+        with pytest.raises(ScrapBookError) as e:
+            content.parse("""
                 <html>
                     <body>
                         <p>aaaa</p>
                         <div>bbbb</div>
                     </body>
                 </html>
-            ''')
-        except ScrapBookError as e:
-            assert isinstance(e.parent, ValueError)
-            assert e.xpath == './p/text()'
-            assert e.field == 'field1.field2'
-            assert e.value == 'aaaa'
-        else:
-            assert False, 'ScrapBookError is not raise.'
+            """)
+        assert isinstance(e.value.parent, ValueError)
+        assert e.value.xpath == "./p/text()"
+        assert e.value.field == "field1.field2"
+        assert e.value.value == "aaaa"
diff --git a/tests/scrapbook/filters.py b/tests/scrapbook/filters.py
new file mode 100644
index 0000000..79e68d3
--- /dev/null
+++ b/tests/scrapbook/filters.py
@@ -0,0 +1,364 @@
+from datetime import date, datetime
+
+import pytest
+from dateutil.tz import tzoffset
+
+from scrapbook import Content, Element
+from scrapbook.filters import (
+    Bool,
+    CleanText,
+    Contains,
+    DateTime,
+    Equals,
+    Fetch,
+    FilterDict,
+    Join,
+    Map,
+    Normalize,
+    Partial,
+    RenameKey,
+    Replace,
+    take_first,
+    through,
+)
+from scrapbook.parsers import All
+
+
+class TestMap(object):
+    def test_with_int(self, mocker):
+        fn1 = mocker.Mock(name="fn1", return_value=1)
+        fn2 = mocker.Mock(name="fn2", return_value=2)
+
+        result = Map(fn1, fn2)(0)
+
+        fn1.assert_called_once_with(0)
+        fn2.assert_called_once_with(1)
+        assert 2 == result
+
+    def test_with_dict(self, mocker):
+        fn1 = mocker.Mock(name="fn1", side_effect=lambda v: v * 2)
+        fn2 = mocker.Mock(name="fn2", side_effect=lambda v: v * 10)
+
+        result = Map(fn1, fn2)({"AAA": 1, "BBB": 2})
+
+        fn1.assert_has_calls([mocker.call(1), mocker.call(2)], any_order=True)
+        fn2.assert_has_calls([mocker.call(2), mocker.call(4)], any_order=True)
+        assert {"AAA": 20, "BBB": 40} == result
+
+    def test_with_list(self, mocker):
+        fn1 = mocker.Mock(name="fn1", side_effect=lambda v: v * 2)
+        fn2 = mocker.Mock(name="fn2", side_effect=lambda v: v * 10)
+
+        result = Map(fn1, fn2)([1, 2])
+
+        fn1.assert_has_calls([mocker.call(1), mocker.call(2)], any_order=True)
+        fn2.assert_has_calls([mocker.call(2), mocker.call(4)], any_order=True)
+        assert [20, 40] == result
+
+    def test_with_none(self, mocker):
+        fn1 = mocker.Mock(name="fn1", side_effect=lambda v: v)
+        fn2 = mocker.Mock(name="fn2", side_effect=lambda v: v)
+
+        result = Map(fn1, fn2)(None)
+
+        fn1.assert_not_called()
+        fn2.assert_not_called()
+        assert result is None
+
+    def test_on_element(self, mocker):
+        class El(Element):
+            def fn2(self, value):
+                pass
+
+        fn1 = mocker.Mock(name="fn1", side_effect=lambda v: v * 2)
+        fn2 = mocker.patch.object(target=El, attribute="fn2", side_effect=lambda v: v * 3)
+
+        element = El(xpath="//p/text()", parser=All(), filter=Map(fn1, "fn2"))
+        result = element.parse("<p>a</p><p>b</p>")
+
+        fn1.assert_has_calls([mocker.call("a"), mocker.call("b")], any_order=True)
+        fn2.assert_has_calls(
+            [
+                mocker.call("aa"),
+                mocker.call("bb"),
+            ],
+            any_order=True,
+        )
+        assert ["aaaaaa", "bbbbbb"] == result
+
+    def test_on_content(self, mocker):
+        fn1 = mocker.Mock(name="fn1", side_effect=lambda v: v * 2)
+
+        class C(Content):
+            field = Element(xpath="//p/text()", parser=All(), filter=Map(fn1, "fn2"))
+
+            def fn2(self, value):
+                pass
+
+        fn2 = mocker.patch.object(target=C, attribute="fn2", side_effect=lambda v: v * 3)
+
+        c = C(xpath="")
+        result = c.parse("<p>a</p><p>b</p>")
+
+        fn1.assert_has_calls([mocker.call("a"), mocker.call("b")], any_order=True)
+        fn2.assert_has_calls(
+            [
+                mocker.call("aa"),
+                mocker.call("bb"),
+            ],
+            any_order=True,
+        )
+        assert ["aaaaaa", "bbbbbb"] == result["field"]
+
+
+class TestThrough(object):
+    def test_(self):
+        value = 100
+        assert value == through(value)
+
+    def test_with_none(self):
+        assert through(None) is None
+
+
+class TestTakeFirst(object):
+    def test_(self):
+        assert 1 == take_first([1, 2, 3, 4])
+
+    def test_with_list_include_empty_value(self):
+        assert 0 == take_first([None, "", 0, 1])
+
+    def test_with_none(self):
+        assert take_first(None) is None
+
+
+class TestCleanText(object):
+    @pytest.mark.parametrize(
+        ["text", "result"],
+        [
+            ("  aaa  ", "aaa"),
+            ("<p>aaa</p>", "aaa"),
+            ("&amp;", "&"),
+            ("aa       bb", "aa bb"),
+            ("<p>  aaa  &amp;  bbb  </p>", "aaa & bbb"),
+            ("a\nb", "a\nb"),
+            ("", None),
+            (None, None),
+        ],
+    )
+    def test_(self, text, result):
+        assert result == CleanText()(text)
+
+    def test_with_empty_value(self):
+        assert "empty" == CleanText(empty_value="empty")("")
+
+    @pytest.mark.parametrize(
+        ["text", "result"],
+        [
+            ("a\nb", "a b"),
+            ("a\rb", "a b"),
+            ("a\n\rb", "a b"),
+            ("a\r\nb", "a b"),
+        ],
+    )
+    def test_with_remove_line_breaks(self, text, result):
+        assert result == CleanText(remove_line_breaks=True)(text)
+
+
+class TestEquals(object):
+    def test_(self):
+        assert Equals("AAA")("AAA")
+        assert not Equals("AAA")("AAABBBCCC")
+        assert not Equals("AAA")(None)
+
+
+class TestContains(object):
+    def test_(self):
+        assert Contains("BBB")("AAABBBCCC")
+        assert not Contains("DDD")("AAABBBCCC")
+        assert not Contains("AAA")(None)
+
+
+class TestFetch(object):
+    def test_fetch(self):
+        pattern = r"\d+"
+        result = Fetch(pattern)("10, 20, 30")
+        assert "10" == result
+
+    def test_fetch_with_group(self):
+        pattern = r"(\d+), (\d+), (\d+)"
+        result = Fetch(pattern)("10, 20, 30")
+        assert ["10", "20", "30"] == result
+
+    def test_fetch_with_labeled_group(self):
+        pattern = r"(?P<type>\w+): (?P<count>\d+)"
+        result = Fetch(pattern)("Cat: 10, Dog: 20")
+        assert {"type": "Cat", "count": "10"} == result
+
+    def test_fetch_with_none(self):
+        pattern = r"(?P<type>\w+): (?P<count>\d+)"
+        result = Fetch(pattern)(None)
+        assert result is None
+
+    def test_fetch_all(self):
+        pattern = r"\d+"
+        result = Fetch(pattern, all=True)("10, 20, 30")
+        assert ["10", "20", "30"] == result
+
+    def test_fetch_all_with_group(self):
+        pattern = r"(\d+), (\d+), (\d+)"
+        result = Fetch(pattern, all=True)("10, 20, 30")
+        assert [["10", "20", "30"]] == result
+
+    def test_fetch_all_with_labeled_group(self):
+        pattern = r"(?P<type>\w+): (?P<count>\d+)"
+        result = Fetch(pattern, all=True)("Cat: 10, Dog: 20")
+        assert [
+            {"type": "Cat", "count": "10"},
+            {"type": "Dog", "count": "20"},
+        ] == result
+
+    def test_fetch_all_with_none(self):
+        pattern = r"(?P<type>\w+): (?P<count>\d+)"
+        result = Fetch(pattern, all=True)(None)
+        assert result is None
+
+
+class TestReplace(object):
+    def test_(self):
+        pattern = r"A+"
+        replace = "B"
+        result = Replace(pattern, replace)("AAAAAABBBAAAA")
+        assert "BBBBB" == result
+
+    def test_with_none(self):
+        pattern = r"A+"
+        replace = "B"
+        result = Replace(pattern, replace)(None)
+        assert result is None
+
+
+class TestJoin(object):
+    def test_(self):
+        assert "A,B,C" == Join(",")(["A", "B", "C"])
+
+    def test_with_none(self):
+        assert Join(",")(None) is None
+
+
+class TestNormalize(object):
+    def test_(self):
+        assert "12AB&%" == Normalize()("１２ＡＢ＆％")
+
+    def test_with_none(self):
+        assert Normalize()(None) is None
+
+
+class TestRenameKey(object):
+    def test_(self):
+        name_map = {"AAA": "XXX", "BBB": "YYY"}
+        result = RenameKey(name_map)({"AAA": "10", "BBB": "20"})
+        assert {"XXX": "10", "YYY": "20"} == result
+
+    def test_with_none(self):
+        name_map = {"AAA": "XXX", "BBB": "YYY"}
+        result = RenameKey(name_map)(None)
+        assert result is None
+
+
+class TestFilterDict(object):
+    def test_(self):
+        keys = ["AAA"]
+        result = FilterDict(keys)({"AAA": "10", "BBB": "20"})
+        assert {"AAA": "10"} == result
+
+    def test_with_ignore(self):
+        keys = ["AAA"]
+        result = FilterDict(keys, ignore=True)({"AAA": "10", "BBB": "20"})
+        assert {"BBB": "20"} == result
+
+    def test_with_none(self):
+        keys = ["AAA"]
+        result = FilterDict(keys)(None)
+        assert result is None
+
+
+class TestPartial(object):
+    def test_with_args(self):
+        def add(a, b, c):
+            return a + b + c
+
+        result = Partial(add, args=(10, 20))(30)
+        assert 60 == result
+
+    def test_with_kwargs(self):
+        def add(a, b):
+            return a + b
+
+        result = Partial(add, kwargs={"b": 10})(5)
+        assert 15 == result
+
+    def test_with_arg_name(self):
+        def add(a, b, c):
+            return a + b + c
+
+        result = Partial(add, kwargs={"a": 10, "c": 30}, arg_name="b")(20)
+        assert 60 == result
+
+
+class TestDateTime(object):
+    @pytest.mark.parametrize(
+        ["value", "result"],
+        [
+            ("2001", datetime(2001, 1, 1)),
+            ("2001-02", datetime(2001, 2, 1)),
+            ("2001-02-03", datetime(2001, 2, 3)),
+            ("2001-02-03 04:05:06", datetime(2001, 2, 3, 4, 5, 6)),
+            ("2001-02-03T04:05:06+09:00", datetime(2001, 2, 3, 4, 5, 6, 0, tzoffset(None, 3600 * 9))),
+        ],
+    )
+    def test_(self, value, result):
+        dt = DateTime()(value)
+        assert dt == result
+
+    @pytest.mark.parametrize(
+        ["value", "format", "result"],
+        [
+            ("2001", "%Y", datetime(2001, 1, 1)),
+            ("02 2001", "%m %Y", datetime(2001, 2, 1)),
+        ],
+    )
+    def test_with_format(self, value, format, result):
+        dt = DateTime(format=format)(value)
+        assert dt == result
+
+    def test_with_truncate_time(self):
+        dt = DateTime(truncate_time=True)("2001-02-03 04:05:06")
+        assert dt == date(2001, 2, 3)
+
+    def test_with_truncate_timezone(self):
+        dt = DateTime(truncate_timezone=True)("2001-02-03T04:05:06+09:00")
+        assert dt.tzinfo is None
+
+
+class TestBool(object):
+    @pytest.mark.parametrize(
+        ["value", "result"],
+        [
+            ("true", True),
+            ("false", False),
+        ],
+    )
+    def test_(self, value, result):
+        assert result == Bool()(value)
+
+    @pytest.mark.parametrize(
+        ["value", "result"],
+        [
+            ("OK", True),
+            ("ok", True),
+            ("true", False),
+            ("ng", False),
+        ],
+    )
+    def test_with_true_values(self, value, result):
+        assert result == Bool("OK", "ok")(value)
diff --git a/tests/scrapbook/parsers.py b/tests/scrapbook/parsers.py
new file mode 100644
index 0000000..64f04ff
--- /dev/null
+++ b/tests/scrapbook/parsers.py
@@ -0,0 +1,130 @@
+import os
+
+import pytest
+import six
+from parsel import Selector
+
+from scrapbook.parsers import (
+    All,
+    First,
+    ParseDefinitionList,
+    ParseList,
+    ParseTable,
+)
+
+basepath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+html_dir = os.path.join(basepath, "assets")
+
+
+def load_html(filepath):
+    filepath = os.path.join(html_dir, filepath)
+    with open(filepath) as fp:
+        return six.u(fp.read())
+
+
+class TestFirst(object):
+    def test_(self):
+        selector = Selector("<html><body><p>aaa<br>bbb<br>ccc</p></body></html>")
+        assert "aaa" == First()(selector.xpath("//html/body/p/text()"))
+
+
+class TestAll(object):
+    def test_(self):
+        selector = Selector("<html><body><p>aaa<br>bbb<br>ccc</p></body></html>")
+        assert ["aaa", "bbb", "ccc"] == All()(selector.xpath("//html/body/p/text()"))
+
+
+class TestParseTable(object):
+    @pytest.mark.parametrize(
+        "filepath",
+        [
+            "parse_table/table.html",
+            "parse_table/table_has_thead_and_tbody.html",
+        ],
+    )
+    def test_(self, filepath):
+        selector = Selector(load_html(filepath))
+        result = ParseTable()(selector.xpath("//table"))
+        expected = [
+            ["Company", "Contact", "Country"],
+            ["Alfreds Futterkiste", "Maria Anders", "Germany"],
+            ["Centro comercial Moctezuma", "Francisco Chang", "Mexico"],
+            ["Ernst Handel", "Roland Mendel", "Austria"],
+            ["Island Trading", "Helen Bennett", "UK"],
+            ["Laughing Bacchus Winecellars", "Yoshi Tannamuri", "Canada"],
+            ["Magazzini Alimentari Riuniti", "Giovanni Rovelli", None],
+        ]
+        assert expected == result
+
+    @pytest.mark.parametrize(
+        "filepath",
+        [
+            "parse_table/table.html",
+            "parse_table/table_has_thead_and_tbody.html",
+        ],
+    )
+    def test_with_table_has_header(self, filepath):
+        selector = Selector(load_html(filepath))
+        result = ParseTable(has_header=True)(selector.xpath("//table"))
+        expected = [
+            {
+                "Company": "Alfreds Futterkiste",
+                "Contact": "Maria Anders",
+                "Country": "Germany",
+            },
+            {
+                "Company": "Centro comercial Moctezuma",
+                "Contact": "Francisco Chang",
+                "Country": "Mexico",
+            },
+            {
+                "Company": "Ernst Handel",
+                "Contact": "Roland Mendel",
+                "Country": "Austria",
+            },
+            {
+                "Company": "Island Trading",
+                "Contact": "Helen Bennett",
+                "Country": "UK",
+            },
+            {
+                "Company": "Laughing Bacchus Winecellars",
+                "Contact": "Yoshi Tannamuri",
+                "Country": "Canada",
+            },
+            {
+                "Company": "Magazzini Alimentari Riuniti",
+                "Contact": "Giovanni Rovelli",
+                "Country": None,
+            },
+        ]
+        assert expected == result
+
+
+class TestParseList(object):
+    @pytest.mark.parametrize(
+        "filepath",
+        [
+            "parse_list/unordered_list.html",
+            "parse_list/ordered_list.html",
+        ],
+    )
+    def test_(self, filepath):
+        selector = Selector(load_html(filepath))
+        result = ParseList()(selector.xpath("//ul | //ol"))
+        expected = ["Coffee", "Tea", "Milk"]
+        assert expected == result
+
+
+class TestParseDefinitionList(object):
+    def test_(self):
+        selector = Selector(load_html("parse_definition_list/definition_list.html"))
+        result = ParseDefinitionList()(selector.xpath("//dl"))
+        expected = {
+            "Coffee": "- black hot drink",
+            "Milk": [
+                "- white cold drink",
+                "- white hot drink",
+            ],
+        }
+        assert expected == result
diff --git a/tests/scrapbook/utils.py b/tests/scrapbook/utils.py
new file mode 100644
index 0000000..585091f
--- /dev/null
+++ b/tests/scrapbook/utils.py
@@ -0,0 +1,35 @@
+import pytest
+
+from scrapbook.utils import merge_dict, remove_tags
+
+
+class TestMergeDict(object):
+    def test_(self):
+        a = {"AAA": 10, "BBB": 20}
+        b = {"CCC": 30, "DDD": 40}
+        c = {"EEE": 50, "FFF": 60}
+        merged = merge_dict(a, b, c)
+        assert all(
+            [
+                a["AAA"] == merged["AAA"],
+                a["BBB"] == merged["BBB"],
+                b["CCC"] == merged["CCC"],
+                b["DDD"] == merged["DDD"],
+                c["EEE"] == merged["EEE"],
+                c["FFF"] == merged["FFF"],
+            ]
+        )
+
+
+class TestRemoveTag(object):
+    @pytest.mark.parametrize(
+        ["tag", "text"],
+        [
+            ("<p>aaa</p>", "aaa"),
+            ('<a href="http://google.com">aaa</a>', "aaa"),
+            ("<p>aaa<br>bbb</p>", "aaabbb"),
+            ("<p><span>aaa</span></p>", "aaa"),
+        ],
+    )
+    def test_(self, tag, text):
+        assert text == remove_tags(tag)
diff --git a/tests/utils_test.py b/tests/utils_test.py
deleted file mode 100644
index 6237caf..0000000
--- a/tests/utils_test.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, print_function
-
-import pytest
-
-from scrapbook.utils import merge_dict, remove_tags
-
-
-class TestMergeDict(object):
-    def test_(self):
-        a = {'AAA': 10, 'BBB': 20}
-        b = {'CCC': 30, 'DDD': 40}
-        c = {'EEE': 50, 'FFF': 60}
-        merged = merge_dict(a, b, c)
-        assert all([
-            a['AAA'] == merged['AAA'],
-            a['BBB'] == merged['BBB'],
-            b['CCC'] == merged['CCC'],
-            b['DDD'] == merged['DDD'],
-            c['EEE'] == merged['EEE'],
-            c['FFF'] == merged['FFF'],
-        ])
-
-
-class TestRemoveTag(object):
-    @pytest.mark.parametrize(['tag', 'text'], [
-        ('<p>aaa</p>', 'aaa'),
-        ('<a href="http://google.com">aaa</a>', 'aaa'),
-        ('<p>aaa<br>bbb</p>', 'aaabbb'),
-        ('<p><span>aaa</span></p>', 'aaa'),
-    ])
-    def test_(self, tag, text):
-        assert text == remove_tags(tag)
diff --git a/tox.ini b/tox.ini
deleted file mode 100644
index 7ed1a70..0000000
--- a/tox.ini
+++ /dev/null
@@ -1,6 +0,0 @@
-[tox]
-envlist = py27,py33,py34,py35,py36
-
-[testenv]
-deps     = -rpip_requirements.txt
-commands = py.test tests
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..4578faa
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,609 @@
+version = 1
+requires-python = ">=3.9"
+resolution-markers = [
+    "python_full_version < '3.13'",
+    "python_full_version >= '3.13'",
+]
+
+[[package]]
+name = "cachetools"
+version = "5.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/38/a0f315319737ecf45b4319a8cd1f3a908e29d9277b46942263292115eee7/cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a", size = 27661 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/07/14f8ad37f2d12a5ce41206c21820d8cb6561b728e51fad4530dff0552a67/cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292", size = 9524 },
+]
+
+[[package]]
+name = "chardet"
+version = "5.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/f7b6ab21ec75897ed80c17d79b15951a719226b9fababf1e40ea74d69079/chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7", size = 2069618 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970", size = 199385 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "coverage"
+version = "7.6.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/12/3669b6382792783e92046730ad3327f53b2726f0603f4c311c4da4824222/coverage-7.6.4.tar.gz", hash = "sha256:29fc0f17b1d3fea332f8001d4558f8214af7f1d87a345f3a133c901d60347c73", size = 798716 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/93/4ad92f71e28ece5c0326e5f4a6630aa4928a8846654a65cfff69b49b95b9/coverage-7.6.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5f8ae553cba74085db385d489c7a792ad66f7f9ba2ee85bfa508aeb84cf0ba07", size = 206713 },
+    { url = "https://files.pythonhosted.org/packages/01/ae/747a580b1eda3f2e431d87de48f0604bd7bc92e52a1a95185a4aa585bc47/coverage-7.6.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8165b796df0bd42e10527a3f493c592ba494f16ef3c8b531288e3d0d72c1f6f0", size = 207149 },
+    { url = "https://files.pythonhosted.org/packages/07/1a/1f573f8a6145f6d4c9130bbc120e0024daf1b24cf2a78d7393fa6eb6aba7/coverage-7.6.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7c8b95bf47db6d19096a5e052ffca0a05f335bc63cef281a6e8fe864d450a72", size = 235584 },
+    { url = "https://files.pythonhosted.org/packages/40/42/c8523f2e4db34aa9389caee0d3688b6ada7a84fcc782e943a868a7f302bd/coverage-7.6.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ed9281d1b52628e81393f5eaee24a45cbd64965f41857559c2b7ff19385df51", size = 233486 },
+    { url = "https://files.pythonhosted.org/packages/8d/95/565c310fffa16ede1a042e9ea1ca3962af0d8eb5543bc72df6b91dc0c3d5/coverage-7.6.4-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0809082ee480bb8f7416507538243c8863ac74fd8a5d2485c46f0f7499f2b491", size = 234649 },
+    { url = "https://files.pythonhosted.org/packages/d5/81/3b550674d98968ec29c92e3e8650682be6c8b1fa7581a059e7e12e74c431/coverage-7.6.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d541423cdd416b78626b55f123412fcf979d22a2c39fce251b350de38c15c15b", size = 233744 },
+    { url = "https://files.pythonhosted.org/packages/0d/70/d66c7f51b3e33aabc5ea9f9624c1c9d9655472962270eb5e7b0d32707224/coverage-7.6.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:58809e238a8a12a625c70450b48e8767cff9eb67c62e6154a642b21ddf79baea", size = 232204 },
+    { url = "https://files.pythonhosted.org/packages/23/2d/2b3a2dbed7a5f40693404c8a09e779d7c1a5fbed089d3e7224c002129ec8/coverage-7.6.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c9b8e184898ed014884ca84c70562b4a82cbc63b044d366fedc68bc2b2f3394a", size = 233335 },
+    { url = "https://files.pythonhosted.org/packages/5a/4f/92d1d2ad720d698a4e71c176eacf531bfb8e0721d5ad560556f2c484a513/coverage-7.6.4-cp310-cp310-win32.whl", hash = "sha256:6bd818b7ea14bc6e1f06e241e8234508b21edf1b242d49831831a9450e2f35fa", size = 209435 },
+    { url = "https://files.pythonhosted.org/packages/c7/b9/cdf158e7991e2287bcf9082670928badb73d310047facac203ff8dcd5ff3/coverage-7.6.4-cp310-cp310-win_amd64.whl", hash = "sha256:06babbb8f4e74b063dbaeb74ad68dfce9186c595a15f11f5d5683f748fa1d172", size = 210243 },
+    { url = "https://files.pythonhosted.org/packages/87/31/9c0cf84f0dfcbe4215b7eb95c31777cdc0483c13390e69584c8150c85175/coverage-7.6.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:73d2b73584446e66ee633eaad1a56aad577c077f46c35ca3283cd687b7715b0b", size = 206819 },
+    { url = "https://files.pythonhosted.org/packages/53/ed/a38401079ad320ad6e054a01ec2b61d270511aeb3c201c80e99c841229d5/coverage-7.6.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:51b44306032045b383a7a8a2c13878de375117946d68dcb54308111f39775a25", size = 207263 },
+    { url = "https://files.pythonhosted.org/packages/20/e7/c3ad33b179ab4213f0d70da25a9c214d52464efa11caeab438592eb1d837/coverage-7.6.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b3fb02fe73bed561fa12d279a417b432e5b50fe03e8d663d61b3d5990f29546", size = 239205 },
+    { url = "https://files.pythonhosted.org/packages/36/91/fc02e8d8e694f557752120487fd982f654ba1421bbaa5560debf96ddceda/coverage-7.6.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed8fe9189d2beb6edc14d3ad19800626e1d9f2d975e436f84e19efb7fa19469b", size = 236612 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/cb08f0eda0389a9a8aaa4fc1f9fec7ac361c3e2d68efd5890d7042c18aa3/coverage-7.6.4-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b369ead6527d025a0fe7bd3864e46dbee3aa8f652d48df6174f8d0bac9e26e0e", size = 238479 },
+    { url = "https://files.pythonhosted.org/packages/d5/c9/2c7681a9b3ca6e6f43d489c2e6653a53278ed857fd6e7010490c307b0a47/coverage-7.6.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ade3ca1e5f0ff46b678b66201f7ff477e8fa11fb537f3b55c3f0568fbfe6e718", size = 237405 },
+    { url = "https://files.pythonhosted.org/packages/b5/4e/ebfc6944b96317df8b537ae875d2e57c27b84eb98820bc0a1055f358f056/coverage-7.6.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:27fb4a050aaf18772db513091c9c13f6cb94ed40eacdef8dad8411d92d9992db", size = 236038 },
+    { url = "https://files.pythonhosted.org/packages/13/f2/3a0bf1841a97c0654905e2ef531170f02c89fad2555879db8fe41a097871/coverage-7.6.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4f704f0998911abf728a7783799444fcbbe8261c4a6c166f667937ae6a8aa522", size = 236812 },
+    { url = "https://files.pythonhosted.org/packages/b9/9c/66bf59226b52ce6ed9541b02d33e80a6e816a832558fbdc1111a7bd3abd4/coverage-7.6.4-cp311-cp311-win32.whl", hash = "sha256:29155cd511ee058e260db648b6182c419422a0d2e9a4fa44501898cf918866cf", size = 209400 },
+    { url = "https://files.pythonhosted.org/packages/2a/a0/b0790934c04dfc8d658d4a62acb8f7ca0efdf3818456fcad757b11c6479d/coverage-7.6.4-cp311-cp311-win_amd64.whl", hash = "sha256:8902dd6a30173d4ef09954bfcb24b5d7b5190cf14a43170e386979651e09ba19", size = 210243 },
+    { url = "https://files.pythonhosted.org/packages/7d/e7/9291de916d084f41adddfd4b82246e68d61d6a75747f075f7e64628998d2/coverage-7.6.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12394842a3a8affa3ba62b0d4ab7e9e210c5e366fbac3e8b2a68636fb19892c2", size = 207013 },
+    { url = "https://files.pythonhosted.org/packages/27/03/932c2c5717a7fa80cd43c6a07d3177076d97b79f12f40f882f9916db0063/coverage-7.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2b6b4c83d8e8ea79f27ab80778c19bc037759aea298da4b56621f4474ffeb117", size = 207251 },
+    { url = "https://files.pythonhosted.org/packages/d5/3f/0af47dcb9327f65a45455fbca846fe96eb57c153af46c4754a3ba678938a/coverage-7.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d5b8007f81b88696d06f7df0cb9af0d3b835fe0c8dbf489bad70b45f0e45613", size = 240268 },
+    { url = "https://files.pythonhosted.org/packages/8a/3c/37a9d81bbd4b23bc7d46ca820e16174c613579c66342faa390a271d2e18b/coverage-7.6.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b57b768feb866f44eeed9f46975f3d6406380275c5ddfe22f531a2bf187eda27", size = 237298 },
+    { url = "https://files.pythonhosted.org/packages/c0/70/6b0627e5bd68204ee580126ed3513140b2298995c1233bd67404b4e44d0e/coverage-7.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5915fcdec0e54ee229926868e9b08586376cae1f5faa9bbaf8faf3561b393d52", size = 239367 },
+    { url = "https://files.pythonhosted.org/packages/3c/eb/634d7dfab24ac3b790bebaf9da0f4a5352cbc125ce6a9d5c6cf4c6cae3c7/coverage-7.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b58c672d14f16ed92a48db984612f5ce3836ae7d72cdd161001cc54512571f2", size = 238853 },
+    { url = "https://files.pythonhosted.org/packages/d9/0d/8e3ed00f1266ef7472a4e33458f42e39492e01a64281084fb3043553d3f1/coverage-7.6.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:2fdef0d83a2d08d69b1f2210a93c416d54e14d9eb398f6ab2f0a209433db19e1", size = 237160 },
+    { url = "https://files.pythonhosted.org/packages/ce/9c/4337f468ef0ab7a2e0887a9c9da0e58e2eada6fc6cbee637a4acd5dfd8a9/coverage-7.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8cf717ee42012be8c0cb205dbbf18ffa9003c4cbf4ad078db47b95e10748eec5", size = 238824 },
+    { url = "https://files.pythonhosted.org/packages/5e/09/3e94912b8dd37251377bb02727a33a67ee96b84bbbe092f132b401ca5dd9/coverage-7.6.4-cp312-cp312-win32.whl", hash = "sha256:7bb92c539a624cf86296dd0c68cd5cc286c9eef2d0c3b8b192b604ce9de20a17", size = 209639 },
+    { url = "https://files.pythonhosted.org/packages/01/69/d4f3a4101171f32bc5b3caec8ff94c2c60f700107a6aaef7244b2c166793/coverage-7.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:1032e178b76a4e2b5b32e19d0fd0abbce4b58e77a1ca695820d10e491fa32b08", size = 210428 },
+    { url = "https://files.pythonhosted.org/packages/c2/4d/2dede4f7cb5a70fb0bb40a57627fddf1dbdc6b9c1db81f7c4dcdcb19e2f4/coverage-7.6.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:023bf8ee3ec6d35af9c1c6ccc1d18fa69afa1cb29eaac57cb064dbb262a517f9", size = 207039 },
+    { url = "https://files.pythonhosted.org/packages/3f/f9/d86368ae8c79e28f1fb458ebc76ae9ff3e8bd8069adc24e8f2fed03c58b7/coverage-7.6.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b0ac3d42cb51c4b12df9c5f0dd2f13a4f24f01943627120ec4d293c9181219ba", size = 207298 },
+    { url = "https://files.pythonhosted.org/packages/64/c5/b4cc3c3f64622c58fbfd4d8b9a7a8ce9d355f172f91fcabbba1f026852f6/coverage-7.6.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8fe4984b431f8621ca53d9380901f62bfb54ff759a1348cd140490ada7b693c", size = 239813 },
+    { url = "https://files.pythonhosted.org/packages/8a/86/14c42e60b70a79b26099e4d289ccdfefbc68624d096f4481163085aa614c/coverage-7.6.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5fbd612f8a091954a0c8dd4c0b571b973487277d26476f8480bfa4b2a65b5d06", size = 236959 },
+    { url = "https://files.pythonhosted.org/packages/7f/f8/4436a643631a2fbab4b44d54f515028f6099bfb1cd95b13cfbf701e7f2f2/coverage-7.6.4-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dacbc52de979f2823a819571f2e3a350a7e36b8cb7484cdb1e289bceaf35305f", size = 238950 },
+    { url = "https://files.pythonhosted.org/packages/49/50/1571810ddd01f99a0a8be464a4ac8b147f322cd1e8e296a1528984fc560b/coverage-7.6.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dab4d16dfef34b185032580e2f2f89253d302facba093d5fa9dbe04f569c4f4b", size = 238610 },
+    { url = "https://files.pythonhosted.org/packages/f3/8c/6312d241fe7cbd1f0cade34a62fea6f333d1a261255d76b9a87074d8703c/coverage-7.6.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:862264b12ebb65ad8d863d51f17758b1684560b66ab02770d4f0baf2ff75da21", size = 236697 },
+    { url = "https://files.pythonhosted.org/packages/ce/5f/fef33dfd05d87ee9030f614c857deb6df6556b8f6a1c51bbbb41e24ee5ac/coverage-7.6.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5beb1ee382ad32afe424097de57134175fea3faf847b9af002cc7895be4e2a5a", size = 238541 },
+    { url = "https://files.pythonhosted.org/packages/a9/64/6a984b6e92e1ea1353b7ffa08e27f707a5e29b044622445859200f541e8c/coverage-7.6.4-cp313-cp313-win32.whl", hash = "sha256:bf20494da9653f6410213424f5f8ad0ed885e01f7e8e59811f572bdb20b8972e", size = 209707 },
+    { url = "https://files.pythonhosted.org/packages/5c/60/ce5a9e942e9543783b3db5d942e0578b391c25cdd5e7f342d854ea83d6b7/coverage-7.6.4-cp313-cp313-win_amd64.whl", hash = "sha256:182e6cd5c040cec0a1c8d415a87b67ed01193ed9ad458ee427741c7d8513d963", size = 210439 },
+    { url = "https://files.pythonhosted.org/packages/78/53/6719677e92c308207e7f10561a1b16ab8b5c00e9328efc9af7cfd6fb703e/coverage-7.6.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a181e99301a0ae128493a24cfe5cfb5b488c4e0bf2f8702091473d033494d04f", size = 207784 },
+    { url = "https://files.pythonhosted.org/packages/fa/dd/7054928930671fcb39ae6a83bb71d9ab5f0afb733172543ced4b09a115ca/coverage-7.6.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:df57bdbeffe694e7842092c5e2e0bc80fff7f43379d465f932ef36f027179806", size = 208058 },
+    { url = "https://files.pythonhosted.org/packages/b5/7d/fd656ddc2b38301927b9eb3aae3fe827e7aa82e691923ed43721fd9423c9/coverage-7.6.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bcd1069e710600e8e4cf27f65c90c7843fa8edfb4520fb0ccb88894cad08b11", size = 250772 },
+    { url = "https://files.pythonhosted.org/packages/90/d0/eb9a3cc2100b83064bb086f18aedde3afffd7de6ead28f69736c00b7f302/coverage-7.6.4-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99b41d18e6b2a48ba949418db48159d7a2e81c5cc290fc934b7d2380515bd0e3", size = 246490 },
+    { url = "https://files.pythonhosted.org/packages/45/44/3f64f38f6faab8a0cfd2c6bc6eb4c6daead246b97cf5f8fc23bf3788f841/coverage-7.6.4-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6b1e54712ba3474f34b7ef7a41e65bd9037ad47916ccb1cc78769bae324c01a", size = 248848 },
+    { url = "https://files.pythonhosted.org/packages/5d/11/4c465a5f98656821e499f4b4619929bd5a34639c466021740ecdca42aa30/coverage-7.6.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:53d202fd109416ce011578f321460795abfe10bb901b883cafd9b3ef851bacfc", size = 248340 },
+    { url = "https://files.pythonhosted.org/packages/f1/96/ebecda2d016cce9da812f404f720ca5df83c6b29f65dc80d2000d0078741/coverage-7.6.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:c48167910a8f644671de9f2083a23630fbf7a1cb70ce939440cd3328e0919f70", size = 246229 },
+    { url = "https://files.pythonhosted.org/packages/16/d9/3d820c00066ae55d69e6d0eae11d6149a5ca7546de469ba9d597f01bf2d7/coverage-7.6.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cc8ff50b50ce532de2fa7a7daae9dd12f0a699bfcd47f20945364e5c31799fef", size = 247510 },
+    { url = "https://files.pythonhosted.org/packages/8f/c3/4fa1eb412bb288ff6bfcc163c11700ff06e02c5fad8513817186e460ed43/coverage-7.6.4-cp313-cp313t-win32.whl", hash = "sha256:b8d3a03d9bfcaf5b0141d07a88456bb6a4c3ce55c080712fec8418ef3610230e", size = 210353 },
+    { url = "https://files.pythonhosted.org/packages/7e/77/03fc2979d1538884d921c2013075917fc927f41cd8526909852fe4494112/coverage-7.6.4-cp313-cp313t-win_amd64.whl", hash = "sha256:f3ddf056d3ebcf6ce47bdaf56142af51bb7fad09e4af310241e9db7a3a8022e1", size = 211502 },
+    { url = "https://files.pythonhosted.org/packages/fb/27/7efede2355bd1417137246246ab0980751b3ba6065102518a2d1eba6a278/coverage-7.6.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9cb7fa111d21a6b55cbf633039f7bc2749e74932e3aa7cb7333f675a58a58bf3", size = 206714 },
+    { url = "https://files.pythonhosted.org/packages/f3/94/594af55226676d078af72b329372e2d036f9ba1eb6bcf1f81debea2453c7/coverage-7.6.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:11a223a14e91a4693d2d0755c7a043db43d96a7450b4f356d506c2562c48642c", size = 207146 },
+    { url = "https://files.pythonhosted.org/packages/d5/13/19de1c5315b22795dd67dbd9168281632424a344b648d23d146572e42c2b/coverage-7.6.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a413a096c4cbac202433c850ee43fa326d2e871b24554da8327b01632673a076", size = 235180 },
+    { url = "https://files.pythonhosted.org/packages/db/26/8fba01ce9f376708c7efed2761cea740f50a1b4138551886213797a4cecd/coverage-7.6.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00a1d69c112ff5149cabe60d2e2ee948752c975d95f1e1096742e6077affd376", size = 233100 },
+    { url = "https://files.pythonhosted.org/packages/74/66/4db60266551b89e820b457bc3811a3c5eaad3c1324cef7730c468633387a/coverage-7.6.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f76846299ba5c54d12c91d776d9605ae33f8ae2b9d1d3c3703cf2db1a67f2c0", size = 234231 },
+    { url = "https://files.pythonhosted.org/packages/2a/9b/7b33f0892fccce50fc82ad8da76c7af1731aea48ec71279eef63a9522db7/coverage-7.6.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:fe439416eb6380de434886b00c859304338f8b19f6f54811984f3420a2e03858", size = 233383 },
+    { url = "https://files.pythonhosted.org/packages/91/49/6ff9c4e8a67d9014e1c434566e9169965f970350f4792a0246cd0d839442/coverage-7.6.4-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:0294ca37f1ba500667b1aef631e48d875ced93ad5e06fa665a3295bdd1d95111", size = 231863 },
+    { url = "https://files.pythonhosted.org/packages/81/f9/c9d330dec440676b91504fcceebca0814718fa71c8498cf29d4e21e9dbfc/coverage-7.6.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6f01ba56b1c0e9d149f9ac85a2f999724895229eb36bd997b61e62999e9b0901", size = 232854 },
+    { url = "https://files.pythonhosted.org/packages/ee/d9/605517a023a0ba8eb1f30d958f0a7ff3a21867b07dcb42618f862695ca0e/coverage-7.6.4-cp39-cp39-win32.whl", hash = "sha256:bc66f0bf1d7730a17430a50163bb264ba9ded56739112368ba985ddaa9c3bd09", size = 209437 },
+    { url = "https://files.pythonhosted.org/packages/aa/79/2626903efa84e9f5b9c8ee6972de8338673fdb5bb8d8d2797740bf911027/coverage-7.6.4-cp39-cp39-win_amd64.whl", hash = "sha256:c481b47f6b5845064c65a7bc78bc0860e635a9b055af0df46fdf1c58cebf8e8f", size = 210209 },
+    { url = "https://files.pythonhosted.org/packages/cc/56/e1d75e8981a2a92c2a777e67c26efa96c66da59d645423146eb9ff3a851b/coverage-7.6.4-pp39.pp310-none-any.whl", hash = "sha256:3c65d37f3a9ebb703e710befdc489a38683a5b152242664b973a7b7b22348a4e", size = 198954 },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cssselect"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d1/91/d51202cc41fbfca7fa332f43a5adac4b253962588c7cc5a54824b019081c/cssselect-1.2.0.tar.gz", hash = "sha256:666b19839cfaddb9ce9d36bfe4c969132c647b92fc9088c4e23f786b30f1b3dc", size = 41423 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/06/a9/2da08717a6862c48f1d61ef957a7bba171e7eefa6c0aa0ceb96a140c2a6b/cssselect-1.2.0-py2.py3-none-any.whl", hash = "sha256:da1885f0c10b60c03ed5eccbb6b68d6eff248d91976fcde348f395d54c9fd35e", size = 18687 },
+]
+
+[[package]]
+name = "distlib"
+version = "0.3.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973 },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 },
+]
+
+[[package]]
+name = "filelock"
+version = "3.16.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
+]
+
+[[package]]
+name = "jmespath"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256 },
+]
+
+[[package]]
+name = "lxml"
+version = "5.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/6b/20c3a4b24751377aaa6307eb230b66701024012c29dd374999cc92983269/lxml-5.3.0.tar.gz", hash = "sha256:4e109ca30d1edec1ac60cdbe341905dc3b8f55b16855e03a54aaf59e51ec8c6f", size = 3679318 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/ce/2789e39eddf2b13fac29878bfa465f0910eb6b0096e29090e5176bc8cf43/lxml-5.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:dd36439be765e2dde7660212b5275641edbc813e7b24668831a5c8ac91180656", size = 8124570 },
+    { url = "https://files.pythonhosted.org/packages/24/a8/f4010166a25d41715527129af2675981a50d3bbf7df09c5d9ab8ca24fbf9/lxml-5.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ae5fe5c4b525aa82b8076c1a59d642c17b6e8739ecf852522c6321852178119d", size = 4413042 },
+    { url = "https://files.pythonhosted.org/packages/41/a4/7e45756cecdd7577ddf67a68b69c1db0f5ddbf0c9f65021ee769165ffc5a/lxml-5.3.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:501d0d7e26b4d261fca8132854d845e4988097611ba2531408ec91cf3fd9d20a", size = 5139213 },
+    { url = "https://files.pythonhosted.org/packages/02/e2/ecf845b12323c92748077e1818b64e8b4dba509a4cb12920b3762ebe7552/lxml-5.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb66442c2546446944437df74379e9cf9e9db353e61301d1a0e26482f43f0dd8", size = 4838814 },
+    { url = "https://files.pythonhosted.org/packages/12/91/619f9fb72cf75e9ceb8700706f7276f23995f6ad757e6d400fbe35ca4990/lxml-5.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e41506fec7a7f9405b14aa2d5c8abbb4dbbd09d88f9496958b6d00cb4d45330", size = 5425084 },
+    { url = "https://files.pythonhosted.org/packages/25/3b/162a85a8f0fd2a3032ec3f936636911c6e9523a8e263fffcfd581ce98b54/lxml-5.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f7d4a670107d75dfe5ad080bed6c341d18c4442f9378c9f58e5851e86eb79965", size = 4875993 },
+    { url = "https://files.pythonhosted.org/packages/43/af/dd3f58cc7d946da6ae42909629a2b1d5dd2d1b583334d4af9396697d6863/lxml-5.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41ce1f1e2c7755abfc7e759dc34d7d05fd221723ff822947132dc934d122fe22", size = 5012462 },
+    { url = "https://files.pythonhosted.org/packages/69/c1/5ea46b2d4c98f5bf5c83fffab8a0ad293c9bc74df9ecfbafef10f77f7201/lxml-5.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:44264ecae91b30e5633013fb66f6ddd05c006d3e0e884f75ce0b4755b3e3847b", size = 4815288 },
+    { url = "https://files.pythonhosted.org/packages/1d/51/a0acca077ad35da458f4d3f729ef98effd2b90f003440d35fc36323f8ae6/lxml-5.3.0-cp310-cp310-manylinux_2_28_ppc64le.whl", hash = "sha256:3c174dc350d3ec52deb77f2faf05c439331d6ed5e702fc247ccb4e6b62d884b7", size = 5472435 },
+    { url = "https://files.pythonhosted.org/packages/4d/6b/0989c9368986961a6b0f55b46c80404c4b758417acdb6d87bfc3bd5f4967/lxml-5.3.0-cp310-cp310-manylinux_2_28_s390x.whl", hash = "sha256:2dfab5fa6a28a0b60a20638dc48e6343c02ea9933e3279ccb132f555a62323d8", size = 4976354 },
+    { url = "https://files.pythonhosted.org/packages/05/9e/87492d03ff604fbf656ed2bf3e2e8d28f5d58ea1f00ff27ac27b06509079/lxml-5.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b1c8c20847b9f34e98080da785bb2336ea982e7f913eed5809e5a3c872900f32", size = 5029973 },
+    { url = "https://files.pythonhosted.org/packages/f9/cc/9ae1baf5472af88e19e2c454b3710c1be9ecafb20eb474eeabcd88a055d2/lxml-5.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2c86bf781b12ba417f64f3422cfc302523ac9cd1d8ae8c0f92a1c66e56ef2e86", size = 4888837 },
+    { url = "https://files.pythonhosted.org/packages/d2/10/5594ffaec8c120d75b17e3ad23439b740a51549a9b5fd7484b2179adfe8f/lxml-5.3.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:c162b216070f280fa7da844531169be0baf9ccb17263cf5a8bf876fcd3117fa5", size = 5530555 },
+    { url = "https://files.pythonhosted.org/packages/ea/9b/de17f05377c8833343b629905571fb06cff2028f15a6f58ae2267662e341/lxml-5.3.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:36aef61a1678cb778097b4a6eeae96a69875d51d1e8f4d4b491ab3cfb54b5a03", size = 5405314 },
+    { url = "https://files.pythonhosted.org/packages/8a/b4/227be0f1f3cca8255925985164c3838b8b36e441ff0cc10c1d3c6bdba031/lxml-5.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f65e5120863c2b266dbcc927b306c5b78e502c71edf3295dfcb9501ec96e5fc7", size = 5079303 },
+    { url = "https://files.pythonhosted.org/packages/5c/ee/19abcebb7fc40319bb71cd6adefa1ad94d09b5660228715854d6cc420713/lxml-5.3.0-cp310-cp310-win32.whl", hash = "sha256:ef0c1fe22171dd7c7c27147f2e9c3e86f8bdf473fed75f16b0c2e84a5030ce80", size = 3475126 },
+    { url = "https://files.pythonhosted.org/packages/a1/35/183d32551447e280032b2331738cd850da435a42f850b71ebeaab42c1313/lxml-5.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:052d99051e77a4f3e8482c65014cf6372e61b0a6f4fe9edb98503bb5364cfee3", size = 3805065 },
+    { url = "https://files.pythonhosted.org/packages/5c/a8/449faa2a3cbe6a99f8d38dcd51a3ee8844c17862841a6f769ea7c2a9cd0f/lxml-5.3.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:74bcb423462233bc5d6066e4e98b0264e7c1bed7541fff2f4e34fe6b21563c8b", size = 8141056 },
+    { url = "https://files.pythonhosted.org/packages/ac/8a/ae6325e994e2052de92f894363b038351c50ee38749d30cc6b6d96aaf90f/lxml-5.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a3d819eb6f9b8677f57f9664265d0a10dd6551d227afb4af2b9cd7bdc2ccbf18", size = 4425238 },
+    { url = "https://files.pythonhosted.org/packages/f8/fb/128dddb7f9086236bce0eeae2bfb316d138b49b159f50bc681d56c1bdd19/lxml-5.3.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5b8f5db71b28b8c404956ddf79575ea77aa8b1538e8b2ef9ec877945b3f46442", size = 5095197 },
+    { url = "https://files.pythonhosted.org/packages/b4/f9/a181a8ef106e41e3086629c8bdb2d21a942f14c84a0e77452c22d6b22091/lxml-5.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3406b63232fc7e9b8783ab0b765d7c59e7c59ff96759d8ef9632fca27c7ee4", size = 4809809 },
+    { url = "https://files.pythonhosted.org/packages/25/2f/b20565e808f7f6868aacea48ddcdd7e9e9fb4c799287f21f1a6c7c2e8b71/lxml-5.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ecdd78ab768f844c7a1d4a03595038c166b609f6395e25af9b0f3f26ae1230f", size = 5407593 },
+    { url = "https://files.pythonhosted.org/packages/23/0e/caac672ec246d3189a16c4d364ed4f7d6bf856c080215382c06764058c08/lxml-5.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:168f2dfcfdedf611eb285efac1516c8454c8c99caf271dccda8943576b67552e", size = 4866657 },
+    { url = "https://files.pythonhosted.org/packages/67/a4/1f5fbd3f58d4069000522196b0b776a014f3feec1796da03e495cf23532d/lxml-5.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa617107a410245b8660028a7483b68e7914304a6d4882b5ff3d2d3eb5948d8c", size = 4967017 },
+    { url = "https://files.pythonhosted.org/packages/ee/73/623ecea6ca3c530dd0a4ed0d00d9702e0e85cd5624e2d5b93b005fe00abd/lxml-5.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:69959bd3167b993e6e710b99051265654133a98f20cec1d9b493b931942e9c16", size = 4810730 },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/fb84fb8e3c298f3a245ae3ea6221c2426f1bbaa82d10a88787412a498145/lxml-5.3.0-cp311-cp311-manylinux_2_28_ppc64le.whl", hash = "sha256:bd96517ef76c8654446fc3db9242d019a1bb5fe8b751ba414765d59f99210b79", size = 5455154 },
+    { url = "https://files.pythonhosted.org/packages/b1/72/4d1ad363748a72c7c0411c28be2b0dc7150d91e823eadad3b91a4514cbea/lxml-5.3.0-cp311-cp311-manylinux_2_28_s390x.whl", hash = "sha256:ab6dd83b970dc97c2d10bc71aa925b84788c7c05de30241b9e96f9b6d9ea3080", size = 4969416 },
+    { url = "https://files.pythonhosted.org/packages/42/07/b29571a58a3a80681722ea8ed0ba569211d9bb8531ad49b5cacf6d409185/lxml-5.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:eec1bb8cdbba2925bedc887bc0609a80e599c75b12d87ae42ac23fd199445654", size = 5013672 },
+    { url = "https://files.pythonhosted.org/packages/b9/93/bde740d5a58cf04cbd38e3dd93ad1e36c2f95553bbf7d57807bc6815d926/lxml-5.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6a7095eeec6f89111d03dabfe5883a1fd54da319c94e0fb104ee8f23616b572d", size = 4878644 },
+    { url = "https://files.pythonhosted.org/packages/56/b5/645c8c02721d49927c93181de4017164ec0e141413577687c3df8ff0800f/lxml-5.3.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6f651ebd0b21ec65dfca93aa629610a0dbc13dbc13554f19b0113da2e61a4763", size = 5511531 },
+    { url = "https://files.pythonhosted.org/packages/85/3f/6a99a12d9438316f4fc86ef88c5d4c8fb674247b17f3173ecadd8346b671/lxml-5.3.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f422a209d2455c56849442ae42f25dbaaba1c6c3f501d58761c619c7836642ec", size = 5402065 },
+    { url = "https://files.pythonhosted.org/packages/80/8a/df47bff6ad5ac57335bf552babfb2408f9eb680c074ec1ba412a1a6af2c5/lxml-5.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:62f7fdb0d1ed2065451f086519865b4c90aa19aed51081979ecd05a21eb4d1be", size = 5069775 },
+    { url = "https://files.pythonhosted.org/packages/08/ae/e7ad0f0fbe4b6368c5ee1e3ef0c3365098d806d42379c46c1ba2802a52f7/lxml-5.3.0-cp311-cp311-win32.whl", hash = "sha256:c6379f35350b655fd817cd0d6cbeef7f265f3ae5fedb1caae2eb442bbeae9ab9", size = 3474226 },
+    { url = "https://files.pythonhosted.org/packages/c3/b5/91c2249bfac02ee514ab135e9304b89d55967be7e53e94a879b74eec7a5c/lxml-5.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:9c52100e2c2dbb0649b90467935c4b0de5528833c76a35ea1a2691ec9f1ee7a1", size = 3814971 },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/d1f1c5e40c64bf62afd7a3f9b34ce18a586a1cccbf71e783cd0a6d8e8971/lxml-5.3.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:e99f5507401436fdcc85036a2e7dc2e28d962550afe1cbfc07c40e454256a859", size = 8171753 },
+    { url = "https://files.pythonhosted.org/packages/bd/83/26b1864921869784355459f374896dcf8b44d4af3b15d7697e9156cb2de9/lxml-5.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:384aacddf2e5813a36495233b64cb96b1949da72bef933918ba5c84e06af8f0e", size = 4441955 },
+    { url = "https://files.pythonhosted.org/packages/e0/d2/e9bff9fb359226c25cda3538f664f54f2804f4b37b0d7c944639e1a51f69/lxml-5.3.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:874a216bf6afaf97c263b56371434e47e2c652d215788396f60477540298218f", size = 5050778 },
+    { url = "https://files.pythonhosted.org/packages/88/69/6972bfafa8cd3ddc8562b126dd607011e218e17be313a8b1b9cc5a0ee876/lxml-5.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65ab5685d56914b9a2a34d67dd5488b83213d680b0c5d10b47f81da5a16b0b0e", size = 4748628 },
+    { url = "https://files.pythonhosted.org/packages/5d/ea/a6523c7c7f6dc755a6eed3d2f6d6646617cad4d3d6d8ce4ed71bfd2362c8/lxml-5.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aac0bbd3e8dd2d9c45ceb82249e8bdd3ac99131a32b4d35c8af3cc9db1657179", size = 5322215 },
+    { url = "https://files.pythonhosted.org/packages/99/37/396fbd24a70f62b31d988e4500f2068c7f3fd399d2fd45257d13eab51a6f/lxml-5.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b369d3db3c22ed14c75ccd5af429086f166a19627e84a8fdade3f8f31426e52a", size = 4813963 },
+    { url = "https://files.pythonhosted.org/packages/09/91/e6136f17459a11ce1757df864b213efbeab7adcb2efa63efb1b846ab6723/lxml-5.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c24037349665434f375645fa9d1f5304800cec574d0310f618490c871fd902b3", size = 4923353 },
+    { url = "https://files.pythonhosted.org/packages/1d/7c/2eeecf87c9a1fca4f84f991067c693e67340f2b7127fc3eca8fa29d75ee3/lxml-5.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:62d172f358f33a26d6b41b28c170c63886742f5b6772a42b59b4f0fa10526cb1", size = 4740541 },
+    { url = "https://files.pythonhosted.org/packages/3b/ed/4c38ba58defca84f5f0d0ac2480fdcd99fc7ae4b28fc417c93640a6949ae/lxml-5.3.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:c1f794c02903c2824fccce5b20c339a1a14b114e83b306ff11b597c5f71a1c8d", size = 5346504 },
+    { url = "https://files.pythonhosted.org/packages/a5/22/bbd3995437e5745cb4c2b5d89088d70ab19d4feabf8a27a24cecb9745464/lxml-5.3.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:5d6a6972b93c426ace71e0be9a6f4b2cfae9b1baed2eed2006076a746692288c", size = 4898077 },
+    { url = "https://files.pythonhosted.org/packages/0a/6e/94537acfb5b8f18235d13186d247bca478fea5e87d224644e0fe907df976/lxml-5.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:3879cc6ce938ff4eb4900d901ed63555c778731a96365e53fadb36437a131a99", size = 4946543 },
+    { url = "https://files.pythonhosted.org/packages/8d/e8/4b15df533fe8e8d53363b23a41df9be907330e1fa28c7ca36893fad338ee/lxml-5.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:74068c601baff6ff021c70f0935b0c7bc528baa8ea210c202e03757c68c5a4ff", size = 4816841 },
+    { url = "https://files.pythonhosted.org/packages/1a/e7/03f390ea37d1acda50bc538feb5b2bda6745b25731e4e76ab48fae7106bf/lxml-5.3.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ecd4ad8453ac17bc7ba3868371bffb46f628161ad0eefbd0a855d2c8c32dd81a", size = 5417341 },
+    { url = "https://files.pythonhosted.org/packages/ea/99/d1133ab4c250da85a883c3b60249d3d3e7c64f24faff494cf0fd23f91e80/lxml-5.3.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7e2f58095acc211eb9d8b5771bf04df9ff37d6b87618d1cbf85f92399c98dae8", size = 5327539 },
+    { url = "https://files.pythonhosted.org/packages/7d/ed/e6276c8d9668028213df01f598f385b05b55a4e1b4662ee12ef05dab35aa/lxml-5.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e63601ad5cd8f860aa99d109889b5ac34de571c7ee902d6812d5d9ddcc77fa7d", size = 5012542 },
+    { url = "https://files.pythonhosted.org/packages/36/88/684d4e800f5aa28df2a991a6a622783fb73cf0e46235cfa690f9776f032e/lxml-5.3.0-cp312-cp312-win32.whl", hash = "sha256:17e8d968d04a37c50ad9c456a286b525d78c4a1c15dd53aa46c1d8e06bf6fa30", size = 3486454 },
+    { url = "https://files.pythonhosted.org/packages/fc/82/ace5a5676051e60355bd8fb945df7b1ba4f4fb8447f2010fb816bfd57724/lxml-5.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:c1a69e58a6bb2de65902051d57fde951febad631a20a64572677a1052690482f", size = 3816857 },
+    { url = "https://files.pythonhosted.org/packages/94/6a/42141e4d373903bfea6f8e94b2f554d05506dfda522ada5343c651410dc8/lxml-5.3.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c72e9563347c7395910de6a3100a4840a75a6f60e05af5e58566868d5eb2d6a", size = 8156284 },
+    { url = "https://files.pythonhosted.org/packages/91/5e/fa097f0f7d8b3d113fb7312c6308af702f2667f22644441715be961f2c7e/lxml-5.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e92ce66cd919d18d14b3856906a61d3f6b6a8500e0794142338da644260595cd", size = 4432407 },
+    { url = "https://files.pythonhosted.org/packages/2d/a1/b901988aa6d4ff937f2e5cfc114e4ec561901ff00660c3e56713642728da/lxml-5.3.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d04f064bebdfef9240478f7a779e8c5dc32b8b7b0b2fc6a62e39b928d428e51", size = 5048331 },
+    { url = "https://files.pythonhosted.org/packages/30/0f/b2a54f48e52de578b71bbe2a2f8160672a8a5e103df3a78da53907e8c7ed/lxml-5.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c2fb570d7823c2bbaf8b419ba6e5662137f8166e364a8b2b91051a1fb40ab8b", size = 4744835 },
+    { url = "https://files.pythonhosted.org/packages/82/9d/b000c15538b60934589e83826ecbc437a1586488d7c13f8ee5ff1f79a9b8/lxml-5.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0c120f43553ec759f8de1fee2f4794452b0946773299d44c36bfe18e83caf002", size = 5316649 },
+    { url = "https://files.pythonhosted.org/packages/e3/ee/ffbb9eaff5e541922611d2c56b175c45893d1c0b8b11e5a497708a6a3b3b/lxml-5.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:562e7494778a69086f0312ec9689f6b6ac1c6b65670ed7d0267e49f57ffa08c4", size = 4812046 },
+    { url = "https://files.pythonhosted.org/packages/15/ff/7ff89d567485c7b943cdac316087f16b2399a8b997007ed352a1248397e5/lxml-5.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:423b121f7e6fa514ba0c7918e56955a1d4470ed35faa03e3d9f0e3baa4c7e492", size = 4918597 },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/535b6ed8c048412ff51268bdf4bf1cf052a37aa7e31d2e6518038a883b29/lxml-5.3.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c00f323cc00576df6165cc9d21a4c21285fa6b9989c5c39830c3903dc4303ef3", size = 4738071 },
+    { url = "https://files.pythonhosted.org/packages/7a/8f/cbbfa59cb4d4fd677fe183725a76d8c956495d7a3c7f111ab8f5e13d2e83/lxml-5.3.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:1fdc9fae8dd4c763e8a31e7630afef517eab9f5d5d31a278df087f307bf601f4", size = 5342213 },
+    { url = "https://files.pythonhosted.org/packages/5c/fb/db4c10dd9958d4b52e34d1d1f7c1f434422aeaf6ae2bbaaff2264351d944/lxml-5.3.0-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:658f2aa69d31e09699705949b5fc4719cbecbd4a97f9656a232e7d6c7be1a367", size = 4893749 },
+    { url = "https://files.pythonhosted.org/packages/f2/38/bb4581c143957c47740de18a3281a0cab7722390a77cc6e610e8ebf2d736/lxml-5.3.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1473427aff3d66a3fa2199004c3e601e6c4500ab86696edffdbc84954c72d832", size = 4945901 },
+    { url = "https://files.pythonhosted.org/packages/fc/d5/18b7de4960c731e98037bd48fa9f8e6e8f2558e6fbca4303d9b14d21ef3b/lxml-5.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a87de7dd873bf9a792bf1e58b1c3887b9264036629a5bf2d2e6579fe8e73edff", size = 4815447 },
+    { url = "https://files.pythonhosted.org/packages/97/a8/cd51ceaad6eb849246559a8ef60ae55065a3df550fc5fcd27014361c1bab/lxml-5.3.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0d7b36afa46c97875303a94e8f3ad932bf78bace9e18e603f2085b652422edcd", size = 5411186 },
+    { url = "https://files.pythonhosted.org/packages/89/c3/1e3dabab519481ed7b1fdcba21dcfb8832f57000733ef0e71cf6d09a5e03/lxml-5.3.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cf120cce539453ae086eacc0130a324e7026113510efa83ab42ef3fcfccac7fb", size = 5324481 },
+    { url = "https://files.pythonhosted.org/packages/b6/17/71e9984cf0570cd202ac0a1c9ed5c1b8889b0fc8dc736f5ef0ffb181c284/lxml-5.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:df5c7333167b9674aa8ae1d4008fa4bc17a313cc490b2cca27838bbdcc6bb15b", size = 5011053 },
+    { url = "https://files.pythonhosted.org/packages/69/68/9f7e6d3312a91e30829368c2b3217e750adef12a6f8eb10498249f4e8d72/lxml-5.3.0-cp313-cp313-win32.whl", hash = "sha256:c802e1c2ed9f0c06a65bc4ed0189d000ada8049312cfeab6ca635e39c9608957", size = 3485634 },
+    { url = "https://files.pythonhosted.org/packages/7d/db/214290d58ad68c587bd5d6af3d34e56830438733d0d0856c0275fde43652/lxml-5.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:406246b96d552e0503e17a1006fd27edac678b3fcc9f1be71a2f94b4ff61528d", size = 3814417 },
+    { url = "https://files.pythonhosted.org/packages/89/a9/63af38c7f42baff8251d937be91c6decfe9e4725fe16283dcee428e08d5c/lxml-5.3.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1ffc23010330c2ab67fac02781df60998ca8fe759e8efde6f8b756a20599c5de", size = 8129239 },
+    { url = "https://files.pythonhosted.org/packages/23/b2/45e12a5b8508ee9de0af432d0dc5fcc786cd78037d692a3de7571c2db04c/lxml-5.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2b3778cb38212f52fac9fe913017deea2fdf4eb1a4f8e4cfc6b009a13a6d3fcc", size = 4415821 },
+    { url = "https://files.pythonhosted.org/packages/88/88/a01dc8055d431c39859ec3806dbe4df6cf7a80b0431227a52de8428d2cf6/lxml-5.3.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b0c7a688944891086ba192e21c5229dea54382f4836a209ff8d0a660fac06be", size = 5139927 },
+    { url = "https://files.pythonhosted.org/packages/13/d9/c0f3fd5582a26ea887122feb9cfe84215642ecf10886dcb50a603a6ef448/lxml-5.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:747a3d3e98e24597981ca0be0fd922aebd471fa99d0043a3842d00cdcad7ad6a", size = 4839659 },
+    { url = "https://files.pythonhosted.org/packages/64/06/290728f6fde1761c323db28ece9601018db72ecafa21b182cfea99e7cb2e/lxml-5.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86a6b24b19eaebc448dc56b87c4865527855145d851f9fc3891673ff97950540", size = 5427269 },
+    { url = "https://files.pythonhosted.org/packages/52/43/af104743bb733e85efc0be0e32c140e3e7be6050aca52b1e8a0b2867c382/lxml-5.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b11a5d918a6216e521c715b02749240fb07ae5a1fefd4b7bf12f833bc8b4fe70", size = 4876667 },
+    { url = "https://files.pythonhosted.org/packages/d8/5f/9dea130ae3ba77848f4b93d11dfd365085620fb34c5c9d22746227b86952/lxml-5.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68b87753c784d6acb8a25b05cb526c3406913c9d988d51f80adecc2b0775d6aa", size = 5013541 },
+    { url = "https://files.pythonhosted.org/packages/e8/87/a089806f0327ad7f7268c3f4d22f1d76215a923bf33ea808bb665bdeacfa/lxml-5.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:109fa6fede314cc50eed29e6e56c540075e63d922455346f11e4d7a036d2b8cf", size = 4818394 },
+    { url = "https://files.pythonhosted.org/packages/87/63/b36ddd4a829a5de681bde7e9be4008a8b53c392dea4c8b1492c35727e150/lxml-5.3.0-cp39-cp39-manylinux_2_28_ppc64le.whl", hash = "sha256:02ced472497b8362c8e902ade23e3300479f4f43e45f4105c85ef43b8db85229", size = 5472977 },
+    { url = "https://files.pythonhosted.org/packages/99/1f/677226f48e2d1ea590c24f3ead1799584517a62a394a338b96f62d3c732e/lxml-5.3.0-cp39-cp39-manylinux_2_28_s390x.whl", hash = "sha256:6b038cc86b285e4f9fea2ba5ee76e89f21ed1ea898e287dc277a25884f3a7dfe", size = 4978803 },
+    { url = "https://files.pythonhosted.org/packages/9d/f8/1b96af1396f237de488b14f70b2c6ced5079b792770e6a0f7153f912124d/lxml-5.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:7437237c6a66b7ca341e868cda48be24b8701862757426852c9b3186de1da8a2", size = 5026166 },
+    { url = "https://files.pythonhosted.org/packages/a9/42/86a09a2cabb7bed04d904e38cc09ac65e4916fc1b7eadf94bb924893988b/lxml-5.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7f41026c1d64043a36fda21d64c5026762d53a77043e73e94b71f0521939cc71", size = 4890234 },
+    { url = "https://files.pythonhosted.org/packages/c9/0a/bf0edfe5635ed05ed69a8ae9c1e06dc28cf8becc4ea72f39d3624f20b3d9/lxml-5.3.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:482c2f67761868f0108b1743098640fbb2a28a8e15bf3f47ada9fa59d9fe08c3", size = 5533730 },
+    { url = "https://files.pythonhosted.org/packages/00/cd/dfd8fd56415508751caac07c7ddb3b0a40aff346c11fabdd9d8aa2bfb329/lxml-5.3.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:1483fd3358963cc5c1c9b122c80606a3a79ee0875bcac0204149fa09d6ff2727", size = 5406452 },
+    { url = "https://files.pythonhosted.org/packages/3f/35/fcc233c86f4e59f9498cde8ad6131e1ca41dc7aa084ec982d2cccca91cd7/lxml-5.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:2dec2d1130a9cda5b904696cec33b2cfb451304ba9081eeda7f90f724097300a", size = 5078114 },
+    { url = "https://files.pythonhosted.org/packages/9b/55/94c9bc55ec20744a21c949138649442298cff4189067b7e0844dd0a111d0/lxml-5.3.0-cp39-cp39-win32.whl", hash = "sha256:a0eabd0a81625049c5df745209dc7fcef6e2aea7793e5f003ba363610aa0a3ff", size = 3478072 },
+    { url = "https://files.pythonhosted.org/packages/bb/ab/68821837e454c4c34f40cbea8806637ec4d814b76d3d017a24a39c651a79/lxml-5.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:89e043f1d9d341c52bf2af6d02e6adde62e0a46e6755d5eb60dc6e4f0b8aeca2", size = 3806100 },
+    { url = "https://files.pythonhosted.org/packages/99/f7/b73a431c8500565aa500e99e60b448d305eaf7c0b4c893c7c5a8a69cc595/lxml-5.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7b1cd427cb0d5f7393c31b7496419da594fe600e6fdc4b105a54f82405e6626c", size = 3925431 },
+    { url = "https://files.pythonhosted.org/packages/db/48/4a206623c0d093d0e3b15f415ffb4345b0bdf661a3d0b15a112948c033c7/lxml-5.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51806cfe0279e06ed8500ce19479d757db42a30fd509940b1701be9c86a5ff9a", size = 4216683 },
+    { url = "https://files.pythonhosted.org/packages/54/47/577820c45dd954523ae8453b632d91e76da94ca6d9ee40d8c98dd86f916b/lxml-5.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee70d08fd60c9565ba8190f41a46a54096afa0eeb8f76bd66f2c25d3b1b83005", size = 4326732 },
+    { url = "https://files.pythonhosted.org/packages/68/de/96cb6d3269bc994b4f5ede8ca7bf0840f5de0a278bc6e50cb317ff71cafa/lxml-5.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:8dc2c0395bea8254d8daebc76dcf8eb3a95ec2a46fa6fae5eaccee366bfe02ce", size = 4218377 },
+    { url = "https://files.pythonhosted.org/packages/a5/43/19b1ef6cbffa4244a217f95cc5f41a6cb4720fed33510a49670b03c5f1a0/lxml-5.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:6ba0d3dcac281aad8a0e5b14c7ed6f9fa89c8612b47939fc94f80b16e2e9bc83", size = 4351237 },
+    { url = "https://files.pythonhosted.org/packages/ba/b2/6a22fb5c0885da3b00e116aee81f0b829ec9ac8f736cd414b4a09413fc7d/lxml-5.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:6e91cf736959057f7aac7adfc83481e03615a8e8dd5758aa1d95ea69e8931dba", size = 3487557 },
+    { url = "https://files.pythonhosted.org/packages/c9/ac/e8ec7b6f7d76f8b88dfe78dd547b0d8915350160a5a01cca7aceba91e87f/lxml-5.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:68934b242c51eb02907c5b81d138cb977b2129a0a75a8f8b60b01cb8586c7b21", size = 3923032 },
+    { url = "https://files.pythonhosted.org/packages/f7/b6/d94041c11aa294a09ffac7caa633114941935938eaaba159a93985283c07/lxml-5.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b710bc2b8292966b23a6a0121f7a6c51d45d2347edcc75f016ac123b8054d3f2", size = 4214557 },
+    { url = "https://files.pythonhosted.org/packages/dd/0d/ccb5e4e7a4188a9c881a3c07ee7eaf21772ae847ca5e9a3b140341f2668a/lxml-5.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18feb4b93302091b1541221196a2155aa296c363fd233814fa11e181adebc52f", size = 4325217 },
+    { url = "https://files.pythonhosted.org/packages/7a/17/9d3b43b63b0ddd77f1a680edf00de3c8c2441e8d379be17d2b712b67688b/lxml-5.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:3eb44520c4724c2e1a57c0af33a379eee41792595023f367ba3952a2d96c2aab", size = 4216018 },
+    { url = "https://files.pythonhosted.org/packages/19/4f/f71029b3f37f43e846b6ec0d6baaa1791c65f8c3356cc78d18076f4c5422/lxml-5.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:609251a0ca4770e5a8768ff902aa02bf636339c5a93f9349b48eb1f606f7f3e9", size = 4347893 },
+    { url = "https://files.pythonhosted.org/packages/17/45/0fe53cb16a704b35b5ec93af305f77a14ec65830fc399e6634a81f17a1ea/lxml-5.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:516f491c834eb320d6c843156440fe7fc0d50b33e44387fcec5b02f0bc118a4c", size = 3486287 },
+]
+
+[[package]]
+name = "mypy"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e8/21/7e9e523537991d145ab8a0a2fd98548d67646dc2aaaf6091c31ad883e7c1/mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e", size = 3152532 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/8c/206de95a27722b5b5a8c85ba3100467bd86299d92a4f71c6b9aa448bfa2f/mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a", size = 11020731 },
+    { url = "https://files.pythonhosted.org/packages/ab/bb/b31695a29eea76b1569fd28b4ab141a1adc9842edde080d1e8e1776862c7/mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80", size = 10184276 },
+    { url = "https://files.pythonhosted.org/packages/a5/2d/4a23849729bb27934a0e079c9c1aad912167d875c7b070382a408d459651/mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7", size = 12587706 },
+    { url = "https://files.pythonhosted.org/packages/5c/c3/d318e38ada50255e22e23353a469c791379825240e71b0ad03e76ca07ae6/mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f", size = 13105586 },
+    { url = "https://files.pythonhosted.org/packages/4a/25/3918bc64952370c3dbdbd8c82c363804678127815febd2925b7273d9482c/mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372", size = 9632318 },
+    { url = "https://files.pythonhosted.org/packages/d0/19/de0822609e5b93d02579075248c7aa6ceaddcea92f00bf4ea8e4c22e3598/mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d", size = 10939027 },
+    { url = "https://files.pythonhosted.org/packages/c8/71/6950fcc6ca84179137e4cbf7cf41e6b68b4a339a1f5d3e954f8c34e02d66/mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d", size = 10108699 },
+    { url = "https://files.pythonhosted.org/packages/26/50/29d3e7dd166e74dc13d46050b23f7d6d7533acf48f5217663a3719db024e/mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b", size = 12506263 },
+    { url = "https://files.pythonhosted.org/packages/3f/1d/676e76f07f7d5ddcd4227af3938a9c9640f293b7d8a44dd4ff41d4db25c1/mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73", size = 12984688 },
+    { url = "https://files.pythonhosted.org/packages/9c/03/5a85a30ae5407b1d28fab51bd3e2103e52ad0918d1e68f02a7778669a307/mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca", size = 9626811 },
+    { url = "https://files.pythonhosted.org/packages/fb/31/c526a7bd2e5c710ae47717c7a5f53f616db6d9097caf48ad650581e81748/mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5", size = 11077900 },
+    { url = "https://files.pythonhosted.org/packages/83/67/b7419c6b503679d10bd26fc67529bc6a1f7a5f220bbb9f292dc10d33352f/mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e", size = 10074818 },
+    { url = "https://files.pythonhosted.org/packages/ba/07/37d67048786ae84e6612575e173d713c9a05d0ae495dde1e68d972207d98/mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2", size = 12589275 },
+    { url = "https://files.pythonhosted.org/packages/1f/17/b1018c6bb3e9f1ce3956722b3bf91bff86c1cefccca71cec05eae49d6d41/mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0", size = 13037783 },
+    { url = "https://files.pythonhosted.org/packages/cb/32/cd540755579e54a88099aee0287086d996f5a24281a673f78a0e14dba150/mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2", size = 9726197 },
+    { url = "https://files.pythonhosted.org/packages/11/bb/ab4cfdc562cad80418f077d8be9b4491ee4fb257440da951b85cbb0a639e/mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7", size = 11069721 },
+    { url = "https://files.pythonhosted.org/packages/59/3b/a393b1607cb749ea2c621def5ba8c58308ff05e30d9dbdc7c15028bca111/mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62", size = 10063996 },
+    { url = "https://files.pythonhosted.org/packages/d1/1f/6b76be289a5a521bb1caedc1f08e76ff17ab59061007f201a8a18cc514d1/mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8", size = 12584043 },
+    { url = "https://files.pythonhosted.org/packages/a6/83/5a85c9a5976c6f96e3a5a7591aa28b4a6ca3a07e9e5ba0cec090c8b596d6/mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7", size = 13036996 },
+    { url = "https://files.pythonhosted.org/packages/b4/59/c39a6f752f1f893fccbcf1bdd2aca67c79c842402b5283563d006a67cf76/mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc", size = 9737709 },
+    { url = "https://files.pythonhosted.org/packages/5f/d4/b33ddd40dad230efb317898a2d1c267c04edba73bc5086bf77edeb410fb2/mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc", size = 11013906 },
+    { url = "https://files.pythonhosted.org/packages/f4/e6/f414bca465b44d01cd5f4a82761e15044bedd1bf8025c5af3cc64518fac5/mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732", size = 10180657 },
+    { url = "https://files.pythonhosted.org/packages/38/e9/fc3865e417722f98d58409770be01afb961e2c1f99930659ff4ae7ca8b7e/mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc", size = 12586394 },
+    { url = "https://files.pythonhosted.org/packages/2e/35/f4d8b6d2cb0b3dad63e96caf159419dda023f45a358c6c9ac582ccaee354/mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d", size = 13103591 },
+    { url = "https://files.pythonhosted.org/packages/22/1d/80594aef135f921dd52e142fa0acd19df197690bd0cde42cea7b88cf5aa2/mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24", size = 9634690 },
+    { url = "https://files.pythonhosted.org/packages/3b/86/72ce7f57431d87a7ff17d442f521146a6585019eb8f4f31b7c02801f78ad/mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a", size = 2647043 },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/65/50db4dda066951078f0a96cf12f4b9ada6e4b811516bf0262c0f4f7064d4/packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002", size = 148788 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124", size = 53985 },
+]
+
+[[package]]
+name = "parsel"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cssselect" },
+    { name = "jmespath" },
+    { name = "lxml" },
+    { name = "packaging" },
+    { name = "w3lib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/87/bd/b982085f091367ca25ccb61f2d127655a0daac1716ecfde014ab7c538116/parsel-1.9.1.tar.gz", hash = "sha256:14e00dc07731c9030db620c195fcae884b5b4848e9f9c523c6119f708ccfa9ac", size = 51225 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/7e/e3f1a7ff69303a4e08a8742a285406e5786650d8218ff194743eff292a1e/parsel-1.9.1-py2.py3-none-any.whl", hash = "sha256:c4a777ee6c3ff5e39652b58e351c5cf02c12ff420d05b07a7966aebb68ab1700", size = 17116 },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.3.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+]
+
+[[package]]
+name = "pyproject-api"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/19/441e0624a8afedd15bbcce96df1b80479dd0ff0d965f5ce8fde4f2f6ffad/pyproject_api-1.8.0.tar.gz", hash = "sha256:77b8049f2feb5d33eefcc21b57f1e279636277a8ac8ad6b5871037b243778496", size = 22340 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/f4/3c4ddfcc0c19c217c6de513842d286de8021af2f2ab79bbb86c00342d778/pyproject_api-1.8.0-py3-none-any.whl", hash = "sha256:3d7d347a047afe796fd5d1885b1e391ba29be7169bd2f102fcd378f04273d228", size = 13100 },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "6.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/95/51/231bb3790e5b0b9fd4131f9a231d73d061b3667522e3f406fd9b63334d0e/ruff-0.7.2.tar.gz", hash = "sha256:2b14e77293380e475b4e3a7a368e14549288ed2931fce259a6f99978669e844f", size = 3210036 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/56/0caa2b5745d66a39aa239c01059f6918fc76ed8380033d2f44bf297d141d/ruff-0.7.2-py3-none-linux_armv6l.whl", hash = "sha256:b73f873b5f52092e63ed540adefc3c36f1f803790ecf2590e1df8bf0a9f72cb8", size = 10373973 },
+    { url = "https://files.pythonhosted.org/packages/1a/33/cad6ff306731f335d481c50caa155b69a286d5b388e87ff234cd2a4b3557/ruff-0.7.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5b813ef26db1015953daf476202585512afd6a6862a02cde63f3bafb53d0b2d4", size = 10171140 },
+    { url = "https://files.pythonhosted.org/packages/97/f5/6a2ca5c9ba416226eac9cf8121a1baa6f06655431937e85f38ffcb9d0d01/ruff-0.7.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:853277dbd9675810c6826dad7a428d52a11760744508340e66bf46f8be9701d9", size = 9809333 },
+    { url = "https://files.pythonhosted.org/packages/16/83/e3e87f13d1a1dc205713632978cd7bc287a59b08bc95780dbe359b9aefcb/ruff-0.7.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21aae53ab1490a52bf4e3bf520c10ce120987b047c494cacf4edad0ba0888da2", size = 10622987 },
+    { url = "https://files.pythonhosted.org/packages/22/16/97ccab194480e99a2e3c77ae132b3eebfa38c2112747570c403a4a13ba3a/ruff-0.7.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ccc7e0fc6e0cb3168443eeadb6445285abaae75142ee22b2b72c27d790ab60ba", size = 10184640 },
+    { url = "https://files.pythonhosted.org/packages/97/1b/82ff05441b036f68817296c14f24da47c591cb27acfda473ee571a5651ac/ruff-0.7.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd77877a4e43b3a98e5ef4715ba3862105e299af0c48942cc6d51ba3d97dc859", size = 11210203 },
+    { url = "https://files.pythonhosted.org/packages/a6/96/7ecb30a7ef7f942e2d8e0287ad4c1957dddc6c5097af4978c27cfc334f97/ruff-0.7.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:e00163fb897d35523c70d71a46fbaa43bf7bf9af0f4534c53ea5b96b2e03397b", size = 11870894 },
+    { url = "https://files.pythonhosted.org/packages/06/6a/c716bb126218227f8e604a9c484836257708a05ee3d2ebceb666ff3d3867/ruff-0.7.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f3c54b538633482dc342e9b634d91168fe8cc56b30a4b4f99287f4e339103e88", size = 11449533 },
+    { url = "https://files.pythonhosted.org/packages/e6/2f/3a5f9f9478904e5ae9506ea699109070ead1e79aac041e872cbaad8a7458/ruff-0.7.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7b792468e9804a204be221b14257566669d1db5c00d6bb335996e5cd7004ba80", size = 12607919 },
+    { url = "https://files.pythonhosted.org/packages/a0/57/4642e57484d80d274750dcc872ea66655bbd7e66e986fede31e1865b463d/ruff-0.7.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dba53ed84ac19ae4bfb4ea4bf0172550a2285fa27fbb13e3746f04c80f7fa088", size = 11016915 },
+    { url = "https://files.pythonhosted.org/packages/4d/6d/59be6680abee34c22296ae3f46b2a3b91662b8b18ab0bf388b5eb1355c97/ruff-0.7.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b19fafe261bf741bca2764c14cbb4ee1819b67adb63ebc2db6401dcd652e3748", size = 10625424 },
+    { url = "https://files.pythonhosted.org/packages/82/e7/f6a643683354c9bc7879d2f228ee0324fea66d253de49273a0814fba1927/ruff-0.7.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:28bd8220f4d8f79d590db9e2f6a0674f75ddbc3847277dd44ac1f8d30684b828", size = 10233692 },
+    { url = "https://files.pythonhosted.org/packages/d7/48/b4e02fc835cd7ed1ee7318d9c53e48bcf6b66301f55925a7dcb920e45532/ruff-0.7.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9fd67094e77efbea932e62b5d2483006154794040abb3a5072e659096415ae1e", size = 10751825 },
+    { url = "https://files.pythonhosted.org/packages/1e/06/6c5ee6ab7bb4cbad9e8bb9b2dd0d818c759c90c1c9e057c6ed70334b97f4/ruff-0.7.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:576305393998b7bd6c46018f8104ea3a9cb3fa7908c21d8580e3274a3b04b691", size = 11074811 },
+    { url = "https://files.pythonhosted.org/packages/a1/16/8969304f25bcd0e4af1778342e63b715e91db8a2dbb51807acd858cba915/ruff-0.7.2-py3-none-win32.whl", hash = "sha256:fa993cfc9f0ff11187e82de874dfc3611df80852540331bc85c75809c93253a8", size = 8650268 },
+    { url = "https://files.pythonhosted.org/packages/d9/18/c4b00d161def43fe5968e959039c8f6ce60dca762cec4a34e4e83a4210a0/ruff-0.7.2-py3-none-win_amd64.whl", hash = "sha256:dd8800cbe0254e06b8fec585e97554047fb82c894973f7ff18558eee33d1cb88", size = 9433693 },
+    { url = "https://files.pythonhosted.org/packages/7f/7b/c920673ac01c19814dd15fc617c02301c522f3d6812ca2024f4588ed4549/ruff-0.7.2-py3-none-win_arm64.whl", hash = "sha256:bb8368cd45bba3f57bb29cbb8d64b4a33f8415d0149d2655c5c8539452ce7760", size = 8735845 },
+]
+
+[[package]]
+name = "scrapbook"
+version = "1.0.0"
+source = { editable = "." }
+dependencies = [
+    { name = "parsel" },
+    { name = "python-dateutil" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "mypy" },
+    { name = "pytest" },
+    { name = "pytest-cov" },
+    { name = "pytest-mock" },
+    { name = "ruff" },
+    { name = "tox" },
+    { name = "tox-uv" },
+    { name = "types-python-dateutil" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "parsel", specifier = ">=1.9.1" },
+    { name = "python-dateutil", specifier = ">=2.9.0.post0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "mypy", specifier = ">=1.13.0" },
+    { name = "pytest", specifier = ">=8.3.3" },
+    { name = "pytest-cov", specifier = ">=6.0.0" },
+    { name = "pytest-mock", specifier = ">=3.14.0" },
+    { name = "ruff", specifier = ">=0.7.2" },
+    { name = "tox", specifier = ">=4.23.2" },
+    { name = "tox-uv", specifier = ">=1.16.0" },
+    { name = "types-python-dateutil", specifier = ">=2.9.0.20241003" },
+]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926", size = 34041 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/5a/e7c31adbe875f2abbb91bd84cf2dc52d792b5a01506781dbcf25c91daf11/six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254", size = 11053 },
+]
+
+[[package]]
+name = "tomli"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/b9/de2a5c0144d7d75a57ff355c0c24054f965b2dc3036456ae03a51ea6264b/tomli-2.0.2.tar.gz", hash = "sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed", size = 16096 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cf/db/ce8eda256fa131af12e0a76d481711abe4681b6923c27efb9a255c9e4594/tomli-2.0.2-py3-none-any.whl", hash = "sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38", size = 13237 },
+]
+
+[[package]]
+name = "tox"
+version = "4.23.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cachetools" },
+    { name = "chardet" },
+    { name = "colorama" },
+    { name = "filelock" },
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "pluggy" },
+    { name = "pyproject-api" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/86/32b10f91b4b975a37ac402b0f9fa016775088e0565c93602ba0b3c729ce8/tox-4.23.2.tar.gz", hash = "sha256:86075e00e555df6e82e74cfc333917f91ecb47ffbc868dcafbd2672e332f4a2c", size = 189998 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/c0/124b73d01c120e917383bc6c53ebc34efdf7243faa9fca64d105c94cf2ab/tox-4.23.2-py3-none-any.whl", hash = "sha256:452bc32bb031f2282881a2118923176445bac783ab97c874b8770ab4c3b76c38", size = 166758 },
+]
+
+[[package]]
+name = "tox-uv"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "tox" },
+    { name = "typing-extensions", marker = "python_full_version < '3.10'" },
+    { name = "uv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ed/5e/c3d2a45ab5465dddbbc267a589c9cfce23b91750d49af10738a08c98534e/tox_uv-1.16.0.tar.gz", hash = "sha256:71b2e2fa6c35c1360b91a302df1d65b3e5a1f656b321c5ebf7b84545804c9f01", size = 16337 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/8d/1baa9f725ddd4824708759cf7b74bc43379f5f7feb079fde0629d7b32b3e/tox_uv-1.16.0-py3-none-any.whl", hash = "sha256:e6f0b525a687e745ab878d07cbf5c7e85d582028d4a7c8935f95e84350651432", size = 13661 },
+]
+
+[[package]]
+name = "types-python-dateutil"
+version = "2.9.0.20241003"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/31/f8/f6ee4c803a7beccffee21bb29a71573b39f7037c224843eff53e5308c16e/types-python-dateutil-2.9.0.20241003.tar.gz", hash = "sha256:58cb85449b2a56d6684e41aeefb4c4280631246a0da1a719bdbe6f3fb0317446", size = 9210 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/d6/ba5f61958f358028f2e2ba1b8e225b8e263053bd57d3a79e2d2db64c807b/types_python_dateutil-2.9.0.20241003-py3-none-any.whl", hash = "sha256:250e1d8e80e7bbc3a6c99b907762711d1a1cdd00e978ad39cb5940f6f0a87f3d", size = 9693 },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "uv"
+version = "0.4.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/66/8191736201d0b503f75cc5682e5d1a47e0e4fe55f5616605af8727e2c9de/uv-0.4.30.tar.gz", hash = "sha256:d9de718380e2f167243ca5e1dccea781e06404158442491255fec5955d57fed9", size = 2126167 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/67/f8eefd7499740fc5c2764574ad2d577a50d925c506e74cd0557c2d64f05b/uv-0.4.30-py3-none-linux_armv6l.whl", hash = "sha256:4ddad09385221fa5c609169e4a0dd5bee27cf56c1dc450d4cdc113122c54bb09", size = 13447487 },
+    { url = "https://files.pythonhosted.org/packages/bb/07/9e8f09a4f93fd3cda20e635392994bf15c79ec5c853b5d3fe001b8259ef6/uv-0.4.30-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f63d6646acdf2f38a5afca9fb9eeac62efa663a57f3c134f735a5f575b4e748f", size = 13478492 },
+    { url = "https://files.pythonhosted.org/packages/67/37/8994c3d0be99851a21a6ee01bbf3cb35ddc4b202a2f6f4014098d5893660/uv-0.4.30-py3-none-macosx_11_0_arm64.whl", hash = "sha256:353617bfcf72e1eabade426d83fb86a69d11273d1612aabc3f4566d41c596c97", size = 12467039 },
+    { url = "https://files.pythonhosted.org/packages/0a/bc/c5fc5ede7f073c850fe61d1b35d45d45936bd212a188a513e319d11e450c/uv-0.4.30-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:dedcae3619f0eb181459b597fefefd99cb21fe5a5a48a530be6f5ad934399bfb", size = 12740841 },
+    { url = "https://files.pythonhosted.org/packages/a1/a7/a728622e0990ba8fe5188387c7a21218e605f00297c6466ecd4caff068e4/uv-0.4.30-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:232575f30ed971ea32d4a525b7146c4b088a07ed6e70a31da63792d563fcac44", size = 13257182 },
+    { url = "https://files.pythonhosted.org/packages/53/08/eb5283f4fb758537f18d5dfbb0f8dae3198be9f091e7a66d016a6a8c0b5c/uv-0.4.30-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c89f2eff63a08d04e81629611f43b1ffa668af6de0382b95a71599af7d4b77c", size = 13817386 },
+    { url = "https://files.pythonhosted.org/packages/43/28/b1b914c67807cd05d0e0ffe682d82335fa9d222ebd271553aa423b34b734/uv-0.4.30-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:4d41d09cabba1988728c2d9b9ad25f79233c2aa3d6ecd724c36f4678c4c89711", size = 14417701 },
+    { url = "https://files.pythonhosted.org/packages/0a/5d/fa1294dec14271be15affd420bdbba415dbc7e3db5b63719f8fb6d5cef34/uv-0.4.30-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9ed0183e747065b9b1bcfb699ff10df671ebe6259709ce83e709f86cea564aee", size = 14163236 },
+    { url = "https://files.pythonhosted.org/packages/ff/ce/e2fedbfcf055f79dd8c6e827d130bb8b9f2fd0841a6a0973baca8bdee242/uv-0.4.30-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e17a799c6279800996828e10288ca8ccc40cc883d8998802b938aa671dfa9ce", size = 18250185 },
+    { url = "https://files.pythonhosted.org/packages/3b/36/592477b62bbd1d652ec2d45a5a6daba7ed5a6ce008690eb0749e18733adb/uv-0.4.30-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63196143f45018364c450ba94279a5bcff8562c14ba63deb41a92ed30baa6e22", size = 13953259 },
+    { url = "https://files.pythonhosted.org/packages/f0/a1/4eb54d4b2809cb6b896881609d8620321f9907d052afee3111f72a50d16c/uv-0.4.30-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:6395820540f368f622e818735862abd633dfe7e729c450fca56b65bab4b46661", size = 12941390 },
+    { url = "https://files.pythonhosted.org/packages/e4/68/e963aa4c235151f8f91442ffeb734642fa9d139630b5bcdb77719c84638f/uv-0.4.30-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:1a83df281c5d900b4758b1a3969b3cff57231f9027db8508b71dce1f2da78684", size = 13209967 },
+    { url = "https://files.pythonhosted.org/packages/86/10/b72965bf44de9f31f5031efe9abad871b22c05884092314da4eb1233d0f0/uv-0.4.30-py3-none-musllinux_1_1_i686.whl", hash = "sha256:4aecd9fb39cf018e129627090a1d35af2b0184bb87078d573c9998f5e4072416", size = 13559034 },
+    { url = "https://files.pythonhosted.org/packages/3a/58/2ed027ea9ae017d16a78f0b49e738f2df36ce67d2c1c836fcf442731170c/uv-0.4.30-py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:444468ad0e94b35cbf6acfc8a28589cfe1247136d43895e60a18955ff89a07ad", size = 15433457 },
+    { url = "https://files.pythonhosted.org/packages/2b/db/b45b2d1470e39961e7d612f1f2ecd815de9b0fdd3298fbf14ef770863dbc/uv-0.4.30-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:ea55ca0fe5bdd04e46deaf395b3daf4fa92392f774e83610d066a2b272af5d3f", size = 14062977 },
+    { url = "https://files.pythonhosted.org/packages/39/ee/1bac3464ae9c666c974a03e673a8cbb36023783a9c07de24d8a5e0473c4e/uv-0.4.30-py3-none-win32.whl", hash = "sha256:7f09bd6a853767863e2fb905f0eb1a0ed7afa9ea118852e5c02d2b451944e1cf", size = 13377566 },
+    { url = "https://files.pythonhosted.org/packages/7b/05/3b42d33752cc0085369b4320e05ff667617de5a570be7cb358c6150ca046/uv-0.4.30-py3-none-win_amd64.whl", hash = "sha256:44c5aeb5b374f9fd1083959934daa9020db3610f0405198c5e3d8ec1f23d961d", size = 15022847 },
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.27.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/b3/7b6a79c5c8cf6d90ea681310e169cf2db2884f4d583d16c6e1d5a75a4e04/virtualenv-20.27.1.tar.gz", hash = "sha256:142c6be10212543b32c6c45d3d3893dff89112cc588b7d0879ae5a1ec03a47ba", size = 6491145 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/92/78324ff89391e00c8f4cf6b8526c41c6ef36b4ea2d2c132250b1a6fc2b8d/virtualenv-20.27.1-py3-none-any.whl", hash = "sha256:f11f1b8a29525562925f745563bfd48b189450f61fb34c4f9cc79dd5aa32a1f4", size = 3117838 },
+]
+
+[[package]]
+name = "w3lib"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/dd/8d080c3bf19f4e853433193e0ffd894d9f5c5a55c11d7283038ee822a0db/w3lib-2.2.1.tar.gz", hash = "sha256:756ff2d94c64e41c8d7c0c59fea12a5d0bc55e33a531c7988b4a163deb9b07dd", size = 49603 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/d6/ff9000e85b820ab36c0a93f2c8a4b334a80821b631a56c252aed2d0bd2d3/w3lib-2.2.1-py3-none-any.whl", hash = "sha256:e56d81c6a6bf507d7039e0c95745ab80abd24b465eb0f248af81e3eaa46eb510", size = 21948 },
+]