testsweet 0.1.2__py3-none-any.whl

testsweet/__init__.py

@@ -0,0 +1,17 @@
+from testsweet._catches import catch_exceptions, catch_warnings
+from testsweet._config import ConfigurationError
+from testsweet._discover import discover
+from testsweet._markers import test
+from testsweet._params import test_params, test_params_lazy
+from testsweet._runner import run
+
+__all__ = [
+    'ConfigurationError',
+    'catch_exceptions',
+    'catch_warnings',
+    'discover',
+    'run',
+    'test',
+    'test_params',
+    'test_params_lazy',
+]

testsweet/__main__.py

@@ -0,0 +1,28 @@
+import pathlib
+import sys
+
+from testsweet._config import load_config
+from testsweet._runner import run
+from testsweet._targets import discover_targets
+
+
+def main(argv: list[str]) -> int:
+    saved_sys_path = list(sys.path)
+    try:
+        config = load_config(pathlib.Path.cwd())
+        groups = discover_targets(argv, config)
+        failed = False
+        for module, names in groups:
+            for name, exc in run(module, names=names):
+                if exc is None:
+                    print(f'{name} ... ok')
+                else:
+                    print(f'{name} ... FAIL: {type(exc).__name__}: {exc}')
+                    failed = True
+        return 1 if failed else 0
+    finally:
+        sys.path[:] = saved_sys_path
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

testsweet/_catches.py

@@ -0,0 +1,47 @@
+import warnings
+
+
+class catch_exceptions:
+    def __init__(self) -> None:
+        self._excs: list[Exception] = []
+
+    def __enter__(self) -> list[Exception]:
+        return self._excs
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        if exc is None:
+            return False
+        if isinstance(exc, Exception):
+            self._excs.append(exc)
+            return True
+        return False
+
+
+class catch_warnings:
+    def __init__(self) -> None:
+        self._warns: list[Warning] = []
+        self._catcher: warnings.catch_warnings | None = None
+        self._records: list[warnings.WarningMessage] | None = None
+
+    def __enter__(self) -> list[Warning]:
+        self._catcher = warnings.catch_warnings(
+            record=True,
+            action='always',
+        )
+        self._records = self._catcher.__enter__()
+        return self._warns
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        try:
+            assert self._records is not None
+            for r in self._records:
+                # `WarningMessage.message` is typed `Warning | str` in
+                # the stdlib stubs (since `warnings.warn` accepts a
+                # bare string), but the warnings machinery normalizes
+                # to a Warning before recording. Narrow for mypy.
+                assert isinstance(r.message, Warning)
+                self._warns.append(r.message)
+        finally:
+            assert self._catcher is not None
+            self._catcher.__exit__(None, None, None)
+        return None

testsweet/_class_helpers.py

@@ -0,0 +1,16 @@
+def _public_methods(cls: type) -> list[str]:
+    seen: set[str] = set()
+    out: list[str] = []
+    for klass in cls.__mro__:
+        if klass is object:
+            continue
+        for name, value in vars(klass).items():
+            if name.startswith('_'):
+                continue
+            if not callable(value):
+                continue
+            if name in seen:
+                continue
+            seen.add(name)
+            out.append(name)
+    return out

testsweet/_classify.py

@@ -0,0 +1,48 @@
+import importlib
+from types import ModuleType
+
+
+def _resolve_dotted(
+    target: str,
+) -> tuple[ModuleType, list[str] | None]:
+    parts = target.split('.')
+    first_error: ModuleNotFoundError | None = None
+
+    # Try each prefix from longest to shortest.
+    for prefix_length in range(len(parts), 0, -1):
+        head = '.'.join(parts[:prefix_length])
+        tail_parts = parts[prefix_length:]
+        try:
+            module = importlib.import_module(head)
+        except ModuleNotFoundError as exc:
+            if not _is_missing_prefix_error(exc, head):
+                # The prefix exists but raised inside its own
+                # imports — propagate rather than mask as a bad
+                # selector.
+                raise
+            if first_error is None:
+                first_error = exc
+            continue
+        if not tail_parts:
+            return module, None
+        if len(tail_parts) > 2:
+            raise LookupError(
+                f'cannot resolve {target!r}: too many trailing '
+                f'segments after module {head!r}'
+            )
+        return module, ['.'.join(tail_parts)]
+
+    # No prefix imported. Re-raise the natural error.
+    assert first_error is not None
+    raise first_error
+
+
+def _is_missing_prefix_error(
+    exc: ModuleNotFoundError,
+    head: str,
+) -> bool:
+    # The prefix itself is what's missing, vs an unrelated import
+    # inside the prefix's module.
+    return exc.name is not None and (
+        exc.name == head or head.startswith(exc.name + '.')
+    )

testsweet/_config.py

@@ -0,0 +1,79 @@
+import pathlib
+import tomllib
+from dataclasses import dataclass, field
+
+
+_VALID_KEYS = frozenset({'include_paths', 'exclude_paths', 'test_files'})
+
+
+class ConfigurationError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class DiscoveryConfig:
+    include_paths: tuple[str, ...] = field(default=())
+    exclude_paths: tuple[str, ...] = field(default=())
+    test_files: tuple[str, ...] = field(default=())
+    project_root: pathlib.Path | None = field(default=None)
+
+
+def load_config(start: pathlib.Path) -> DiscoveryConfig:
+    pyproject = _find_pyproject(start)
+    if pyproject is None:
+        return DiscoveryConfig()
+    project_root = pyproject.parent.resolve()
+    raw = tomllib.loads(pyproject.read_text())
+    section = raw.get('tool', {}).get('testsweet', {}).get('discovery', {})
+    return _build_config(section, project_root)
+
+
+def _find_pyproject(start: pathlib.Path) -> pathlib.Path | None:
+    current = start.resolve()
+    while True:
+        candidate = current / 'pyproject.toml'
+        if candidate.exists():
+            return candidate
+        if current.parent == current:
+            return None
+        current = current.parent
+
+
+def _build_config(
+    section: dict,
+    project_root: pathlib.Path,
+) -> DiscoveryConfig:
+    unknown = set(section) - _VALID_KEYS
+    if unknown:
+        raise ConfigurationError(
+            f'unknown key {sorted(unknown)[0]!r} in '
+            f'[tool.testsweet.discovery]'
+        )
+    return DiscoveryConfig(
+        include_paths=_to_string_tuple(
+            section.get('include_paths', []),
+            'include_paths',
+        ),
+        exclude_paths=_to_string_tuple(
+            section.get('exclude_paths', []),
+            'exclude_paths',
+        ),
+        test_files=_to_string_tuple(
+            section.get('test_files', []),
+            'test_files',
+        ),
+        project_root=project_root,
+    )
+
+
+def _to_string_tuple(value: object, key: str) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        raise ConfigurationError(
+            f'tool.testsweet.discovery.{key} must be a list of strings'
+        )
+    for item in value:
+        if not isinstance(item, str):
+            raise ConfigurationError(
+                f'tool.testsweet.discovery.{key} must be a list of strings'
+            )
+    return tuple(value)

testsweet/_discover.py

@@ -0,0 +1,12 @@
+from types import ModuleType
+from typing import Callable
+
+from testsweet._markers import TEST_MARKER
+
+
+def discover(module: ModuleType) -> list[Callable]:
+    return [
+        value
+        for value in vars(module).values()
+        if callable(value) and getattr(value, TEST_MARKER, False) is True
+    ]

testsweet/_loaders.py

@@ -0,0 +1,48 @@
+import importlib
+import importlib.util
+import pathlib
+import sys
+from types import ModuleType
+
+
+def _exec_module_from_path(path: pathlib.Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f'cannot load {path} as a module')
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _load_path(target: str) -> ModuleType:
+    return _exec_module_from_path(pathlib.Path(target).resolve())
+
+
+def _load_path_for_walk(path: pathlib.Path) -> ModuleType:
+    info = _dotted_name_for_path(path)
+    if info is None:
+        return _exec_module_from_path(path)
+    dotted, rootdir = info
+    rootdir_str = str(rootdir)
+    if rootdir_str not in sys.path:
+        sys.path.insert(0, rootdir_str)
+    return importlib.import_module(dotted)
+
+
+def _dotted_name_for_path(
+    path: pathlib.Path,
+) -> tuple[str, pathlib.Path] | None:
+    # Walk up while __init__.py is present; collect names. The
+    # rootdir is the first ancestor that does NOT contain
+    # __init__.py.
+    parts: list[str] = [path.stem]
+    parent = path.parent
+    while (parent / '__init__.py').exists():
+        parts.insert(0, parent.name)
+        if parent.parent == parent:
+            break
+        parent = parent.parent
+    if len(parts) == 1:
+        # Loose file; caller falls back to spec_from_file_location.
+        return None
+    return '.'.join(parts), parent

testsweet/_markers.py

@@ -0,0 +1,15 @@
+TEST_MARKER = '__testsweet_test__'
+
+
+def test(target):
+    """Mark a function or class as a test unit.
+
+    Applied to a function, the function is discovered and run as a
+    standalone test. Applied to a class, the class is discovered and
+    its public methods are run as tests; if the class implements the
+    context-manager protocol (`__enter__`/`__exit__`, typically by
+    inheriting `contextlib.AbstractContextManager`), the runner enters
+    it for the duration of its method invocations.
+    """
+    setattr(target, TEST_MARKER, True)
+    return target

testsweet/_params.py

@@ -0,0 +1,26 @@
+from typing import Callable, Iterable
+
+from testsweet._markers import TEST_MARKER
+
+
+PARAMS_MARKER = '__testsweet_params__'
+
+
+def test_params(args_iterable: Iterable) -> Callable:
+    materialized = tuple(args_iterable)
+
+    def decorator(func: Callable) -> Callable:
+        setattr(func, TEST_MARKER, True)
+        setattr(func, PARAMS_MARKER, materialized)
+        return func
+
+    return decorator
+
+
+def test_params_lazy(args_iterable: Iterable) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        setattr(func, TEST_MARKER, True)
+        setattr(func, PARAMS_MARKER, args_iterable)
+        return func
+
+    return decorator

testsweet/_resolve.py

@@ -0,0 +1,105 @@
+import functools
+import itertools
+from contextlib import nullcontext
+from types import ModuleType
+from typing import Any, Callable, Iterator
+
+from testsweet._class_helpers import _public_methods
+from testsweet._discover import discover
+from testsweet._params import PARAMS_MARKER
+
+
+def resolve_units(
+    module: ModuleType,
+    names: list[str] | None = None,
+) -> Iterator[tuple[str, Callable[[], Any]]]:
+    # `_build_plan` runs synchronously here (above
+    # `chain.from_iterable`), so `LookupError` for unmatched names
+    # fires at call time, before any iteration. The returned chain
+    # advances units sequentially: each `_expand_unit` generator is
+    # exhausted (running its `with cm:` `__exit__`) before the next
+    # one's `__enter__` runs. Per-class fixture lifecycles are
+    # therefore non-overlapping, even though the chain looks flat.
+    units = discover(module)
+    if names is None:
+        return itertools.chain.from_iterable(
+            _expand_unit(unit, None) for unit in units
+        )
+    plan = _build_plan(units, names)
+    return itertools.chain.from_iterable(
+        _expand_unit(unit, plan[unit.__qualname__])
+        for unit in units
+        if unit.__qualname__ in plan
+    )
+
+
+def _expand_unit(
+    unit: Any,
+    method_filter: set[str] | None,
+) -> Iterator[tuple[str, Callable[[], Any]]]:
+    if isinstance(unit, type):
+        instance = unit()
+        cm = (
+            instance
+            if hasattr(instance, '__enter__')
+            else nullcontext(instance)
+        )
+        with cm:
+            for method_name in _public_methods(unit):
+                if (
+                    method_filter is not None
+                    and method_name not in method_filter
+                ):
+                    continue
+                bound = getattr(instance, method_name)
+                yield from _expand_callable(bound, bound.__qualname__)
+    else:
+        yield from _expand_callable(unit, unit.__qualname__)
+
+
+def _expand_callable(
+    func: Callable[..., Any],
+    qualname: str,
+) -> Iterator[tuple[str, Callable[[], Any]]]:
+    params = getattr(func, PARAMS_MARKER, None)
+    if params is None:
+        yield qualname, func
+        return
+    for i, args in enumerate(params):
+        yield f'{qualname}[{i}]', functools.partial(func, *args)
+
+
+def _build_plan(
+    units: list[Any],
+    names: list[str],
+) -> dict[str, set[str] | None]:
+    # plan[unit_qualname] = None  -> run as today (whole unit)
+    #                    = set    -> run only these method names
+    plan: dict[str, set[str] | None] = {}
+    discovered_unit_names = {u.__qualname__: u for u in units}
+    unmatched: list[str] = []
+    for name in names:
+        if '.' in name:
+            head, _, method = name.partition('.')
+            unit = discovered_unit_names.get(head)
+            if (
+                unit is None
+                or not isinstance(unit, type)
+                or method not in _public_methods(unit)
+            ):
+                unmatched.append(name)
+                continue
+            existing = plan.get(head, set())
+            if existing is None:
+                # already a whole-unit selector for this class — wins.
+                continue
+            existing.add(method)
+            plan[head] = existing
+        else:
+            if name not in discovered_unit_names:
+                unmatched.append(name)
+                continue
+            plan[name] = None  # whole unit; class form wins
+    if unmatched:
+        raise LookupError(f'no test units matched: {sorted(unmatched)}')
+    return plan

testsweet/_runner.py

@@ -0,0 +1,18 @@
+from types import ModuleType
+
+from testsweet._resolve import resolve_units
+
+
+def run(
+    module: ModuleType,
+    names: list[str] | None = None,
+) -> list[tuple[str, Exception | None]]:
+    results: list[tuple[str, Exception | None]] = []
+    for name, call in resolve_units(module, names):
+        try:
+            call()
+        except Exception as exc:
+            results.append((name, exc))
+        else:
+            results.append((name, None))
+    return results

testsweet/_targets.py

@@ -0,0 +1,96 @@
+import pathlib
+from types import ModuleType
+
+from testsweet._classify import _resolve_dotted
+from testsweet._config import DiscoveryConfig
+from testsweet._loaders import _load_path, _load_path_for_walk
+from testsweet._walk import (
+    _build_exclude_set,
+    _resolve_include_paths,
+    _walk_directory,
+)
+
+
+# A discovered test unit: a module, plus an optional list of selectors
+# (dotted-name tails like 'Foo.bar') narrowing what to run within it.
+# `None` means "run everything in this module".
+TargetGroup = tuple[ModuleType, list[str] | None]
+
+
+def discover_targets(
+    argv: list[str],
+    config: DiscoveryConfig,
+) -> list[TargetGroup]:
+    excluded = _build_exclude_set(config)
+    raw: list[TargetGroup] = []
+    if not argv:
+        raw.extend(_bare_invocation(config, excluded))
+    else:
+        for arg in argv:
+            raw.extend(parse_target(arg, config, excluded))
+
+    # Group by module identity, preserving first-seen order via dict
+    # insertion order. Whole-module entries (names is None) win over
+    # selectors for the same module.
+    #
+    # Keying by id(module) is safe because `raw` holds a strong
+    # reference to every module for the duration of the loop — id()
+    # is only guaranteed unique among live objects.
+    by_id: dict[int, TargetGroup] = {}
+    for module, names in raw:
+        key = id(module)
+        existing = by_id.get(key)
+        if existing is None:
+            by_id[key] = (module, names)
+            continue
+        _, existing_names = existing
+        if existing_names is None or names is None:
+            by_id[key] = (module, None)
+        else:
+            by_id[key] = (module, existing_names + names)
+    return list(by_id.values())
+
+
+def parse_target(
+    target: str,
+    config: DiscoveryConfig | None = None,
+    excluded: set[pathlib.Path] | None = None,
+) -> list[TargetGroup]:
+    if (
+        '/' in target
+        or target.endswith('.py')
+        or pathlib.Path(target).is_dir()
+    ):
+        path = pathlib.Path(target).resolve()
+        if path.is_dir():
+            return [
+                (_load_path_for_walk(p), None)
+                for p in _walk_directory(
+                    path,
+                    config=config,
+                    excluded=excluded,
+                )
+            ]
+        return [(_load_path(target), None)]
+    return [_resolve_dotted(target)]
+
+
+def _bare_invocation(
+    config: DiscoveryConfig,
+    excluded: set[pathlib.Path],
+) -> list[TargetGroup]:
+    roots = _resolve_include_paths(config)
+    if not roots:
+        roots = [pathlib.Path('.').resolve()]
+    out: list[TargetGroup] = []
+    for root in roots:
+        if root.is_file() and root.suffix == '.py':
+            out.append((_load_path_for_walk(root), None))
+        elif root.is_dir():
+            for path in _walk_directory(
+                root,
+                config=config,
+                excluded=excluded,
+            ):
+                out.append((_load_path_for_walk(path), None))
+    return out

testsweet/_walk.py

@@ -0,0 +1,96 @@
+import fnmatch
+import os
+import pathlib
+
+from testsweet._config import DiscoveryConfig
+
+
+_EXCLUDED_DIR_NAMES = frozenset({'__pycache__', 'node_modules'})
+
+
+def _resolve_include_paths(
+    config: DiscoveryConfig,
+) -> list[pathlib.Path]:
+    if not config.include_paths or config.project_root is None:
+        return []
+    out: list[pathlib.Path] = []
+    for pattern in config.include_paths:
+        for match in config.project_root.glob(pattern):
+            out.append(match)
+    return out
+
+
+def _build_exclude_set(
+    config: DiscoveryConfig,
+) -> set[pathlib.Path]:
+    # Glob each exclude pattern and add every match (file or
+    # directory) directly. The walker checks each entry against this
+    # set before recursing, so an excluded directory prunes its whole
+    # subtree without us having to walk into it here.
+    if not config.exclude_paths or config.project_root is None:
+        return set()
+    excluded: set[pathlib.Path] = set()
+    for pattern in config.exclude_paths:
+        for match in config.project_root.glob(pattern):
+            excluded.add(match.resolve())
+    return excluded
+
+
+def _walk_directory(
+    root: pathlib.Path,
+    config: DiscoveryConfig | None = None,
+    excluded: set[pathlib.Path] | None = None,
+) -> list[pathlib.Path]:
+    # Symlinks (both directory and file) are not followed: we only
+    # consider entries that are real files / real directories. This
+    # avoids cycles and prevents picking up source files outside the
+    # walked tree. A test file deliberately reached via a symlink
+    # will not be discovered — the user must pass it as an explicit
+    # target, or set up `__init__.py` to make it a real package
+    # module.
+    out: list[pathlib.Path] = []
+    with os.scandir(root) as it:
+        entries = sorted(it, key=lambda e: e.name)
+    for entry in entries:
+        entry_path = pathlib.Path(entry.path)
+        if excluded is not None and entry_path.resolve() in excluded:
+            continue
+        if entry.is_dir(follow_symlinks=False):
+            if _is_excluded_dir(entry.name):
+                continue
+            out.extend(
+                _walk_directory(
+                    entry_path,
+                    config=config,
+                    excluded=excluded,
+                )
+            )
+        elif entry.is_file(follow_symlinks=False) and entry.name.endswith(
+            '.py'
+        ):
+            if not _accepts_file(entry_path, config, excluded):
+                continue
+            out.append(entry_path)
+    return out
+
+
+def _accepts_file(
+    path: pathlib.Path,
+    config: DiscoveryConfig | None,
+    excluded: set[pathlib.Path] | None,
+) -> bool:
+    if excluded is not None and path.resolve() in excluded:
+        return False
+    if config is not None and config.test_files:
+        if not any(
+            fnmatch.fnmatch(path.name, pattern)
+            for pattern in config.test_files
+        ):
+            return False
+    return True
+
+
+def _is_excluded_dir(name: str) -> bool:
+    if name.startswith('.'):
+        return True
+    return name in _EXCLUDED_DIR_NAMES

testsweet-0.1.2.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: testsweet
+Version: 0.1.2
+Summary: Python testing for humans
+Project-URL: Homepage, https://github.com/kaapstorm/testsweet
+Project-URL: Source, https://github.com/kaapstorm/testsweet
+Project-URL: Documentation, https://github.com/kaapstorm/testsweet/blob/main/README.md
+Project-URL: Changelog, https://github.com/kaapstorm/testsweet/blob/main/CHANGELOG.md
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+Testsweet
+=========
+
+Python testing for humans
+
+
+Why?
+----
+
+Neither of the two most popular libraries for testing in Python,
+[unittest](https://docs.python.org/3/library/unittest.html) and
+[pytest](https://docs.pytest.org/), make it over the hurdle of the Zen
+of Python.
+
+```
+Beautiful is better than ugly.
+Explicit is better than implicit.
+```
+
+unittest is modeled closely on JUnit and the xUnit family of libraries.
+Its strength is its familiarity to people who are accustomed to them.
+Its weakness is its failure to take advantage of existing Python idioms
+and conventions. It's not beautiful.
+
+Pytest addresses a lot of the shortcomings of unittest, but the way that
+[its fixtures](https://docs.pytest.org/en/stable/how-to/fixtures.html)
+work is magical, especially when they are imported
+[invisibly](https://docs.pytest.org/en/stable/how-to/writing_plugins.html#localplugin).
+It doesn't make it past the second line of the Zen of Python.
+
+Testsweet intends to be a Python testing library that uses existing
+Python features and idioms: A kind and simple interface, explicit in its
+architecture, enabling the tests that use it to be beautiful.
+
+
+Examples
+--------
+
+A test function:
+
+```python
+from testsweet import test
+
+
+@test
+def or_dicts():
+    assert {'foo': 1} | {'bar': 2} == {'foo': 1, 'bar': 2}
+```
+
+A test class:
+
+```python
+from testsweet import test
+
+
+@test
+class OrThings:
+    def or_dicts(self):
+        assert {'foo': 1} | {'bar': 2} == {'foo': 1, 'bar': 2}
+```
+
+Running tests:
+
+```shell
+python -m testsweet tests.test_module.TestClass.test_method
+python -m testsweet tests/test_module.py
+python -m testsweet  # Discover tests
+```
+
+
+Documentation
+-------------
+
+* [Getting Started](https://github.com/kaapstorm/testsweet/blob/main/docs/getting-started.md)
+* [Reference](https://github.com/kaapstorm/testsweet/blob/main/docs/reference.md)
+* [Contributing](https://github.com/kaapstorm/testsweet/blob/main/docs/contributing.md)

testsweet-0.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+testsweet/__init__.py,sha256=l5Vjq8gGglUOKhm4LKQn0GboqdnLjUoulPyAxykBOh4,453
+testsweet/__main__.py,sha256=Wd2LbpY2TfR_sQdW3Lb0FBqwWUX0o_iymhWV0Tglztk,797
+testsweet/_catches.py,sha256=-7d3TBuIwlyGm4rV-Ez3nXBU04wHVP5L3WTpesafVww,1519
+testsweet/_class_helpers.py,sha256=h7Z1m-VWz4gjJajw3giBPN1QdPSdlH_1JfVa36j9Up8,471
+testsweet/_classify.py,sha256=pShc16D_dqL1Y0IbWl2Yq4QyFBHCXQRuDJMSpLhd3V4,1532
+testsweet/_config.py,sha256=iNNQnG2JNxNfQKkdhDToLg9PxonusQPMLkLjf_A_5T8,2317
+testsweet/_discover.py,sha256=M9VMSEh8zuSvkKm-K8DGpipAGVXSxkIKP9inTKKp3Kw,305
+testsweet/_loaders.py,sha256=zzo3B2qr-fGMFj-bqPBzkZqkPiXAgZi0hB_jdGjBJpI,1493
+testsweet/_markers.py,sha256=38b2n0ReJIxmZAuucAhteCU7kHQYGe5VSka73InGUgw,563
+testsweet/_params.py,sha256=d36VWRjnzhn-39FdKufCZExOjF-a1clVVn_2oMf_14Y,644
+testsweet/_resolve.py,sha256=FSk0xPl5LaibRxfDZy40IrQUi4ec0IYzrZ6HsioajP0,3574
+testsweet/_runner.py,sha256=Eb6waKC-FCz0YlpohWcfIX7uis91ZuyaAFIrOUIBt-s,471
+testsweet/_targets.py,sha256=Z4YWXR9n9PBOtSM_KYqsmx_JSCaDzKkFbBTCkln0TAg,2997
+testsweet/_walk.py,sha256=oeE4og1JooVyOoCSIA7OHTIBKdeMgBr1UgG1FtkU1pE,3086
+testsweet-0.1.2.dist-info/METADATA,sha256=6VIzT-Rg37-sk1uh5G1TQNRcupUWnhT7FAhHK1WjKoA,2836
+testsweet-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+testsweet-0.1.2.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+testsweet-0.1.2.dist-info/RECORD,,

testsweet-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

testsweet-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,175 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.