emtest 0.0.9__py3-none-any.whl

_auto_run_with_pytest/__init__.py

@@ -0,0 +1,32 @@
+"""Rerun the orignially executed python script in pytest instead of python."""
+
+import os
+import sys
+
+from emtest import run_pytest
+
+# Configuration for standalone execution
+
+path_parts = sys.argv[0].split(os.sep)
+if not (
+    path_parts[-1] == "pytest"
+    or (
+        len(path_parts) > 1
+        and path_parts[-2] == "pytest"
+        and path_parts[-1] == "__main__.py"
+    )
+):
+    test_file = os.path.abspath(sys.argv[0])
+    pytest_args = sys.argv[1:]
+    # print("RERUNNING IN PYTEST:", test_file)
+
+    # Use emtest's custom test runner with specific settings:
+    run_pytest(
+        test_path=test_file,  # Run tests in this file
+        pytest_args=pytest_args,
+    )
+
+    sys.exit(-1)
+else:
+    # print("ALREADY RUNNING IN PYTEST")
+    pass

emtest/__init__.py

@@ -0,0 +1,20 @@
+from .pytest_utils import (
+    run_pytest,
+    configure_pytest_reporter,
+    env_vars,
+    get_pytest_report_dirs,
+    get_pytest_report_files,
+)
+from .testing_utils import (
+    add_path_to_python,
+    assert_is_loaded_from_source,
+    polite_wait,
+    await_thread_cleanup,
+    get_thread_names,
+    set_env_var,
+    are_we_in_docker,
+    make_dir,
+    delete_path,
+    ensure_dirs_exist,
+    ensure_dir_exists,
+)

emtest/log_recording.py

@@ -0,0 +1,154 @@
+"""In-memory log recording utilities for Python's logging framework.
+
+This module provides a `RecordingHandler` and helper methods to
+dynamically attach and detach in-memory log recorders to standard
+`logging.Logger` instances. It allows recording log output programmatically
+for testing, debugging, or analysis without relying on files or streams.
+
+Example:
+    >>> import logging
+    >>> import emtest.log_recording
+    >>> logger = logging.getLogger("demo")
+    >>> logger.setLevel(logging.INFO)
+    >>> logger.start_recording()  # Start recording logs
+    >>> logger.info("Hello world")
+    >>> logs = logger.get_recording()
+    >>> print(logs)
+    ['2025-10-18 10:00:00,000 [INFO] Hello world']
+    >>> logger.stop_recording()  # Stop and remove recorder
+"""
+
+import logging
+
+
+class RecordingHandler(logging.Handler):
+    """A logging handler that buffers formatted log records in memory.
+
+    This handler captures each emitted log record, formats it,
+    and stores the resulting string in an internal list.
+    It is useful for unit tests or scenarios where log output
+    needs to be inspected programmatically.
+
+    Attributes:
+        formatter (logging.Formatter): The formatter used to format log messages.
+        _records (list[str]): Internal buffer of recorded log messages.
+    """
+
+    def __init__(self, formatter: logging.Formatter):
+        """Initialize the handler with a specific formatter.
+
+        Args:
+            formatter (logging.Formatter): Formatter to apply to each log record.
+        """
+        super().__init__()
+        self.formatter = formatter
+        self._records: list[str] = []
+
+    def emit(self, record: logging.LogRecord):
+        """Store a formatted log record in the internal buffer.
+
+        Args:
+            record (logging.LogRecord): The log record to handle.
+        """
+        self._records.append(self.format(record))
+
+    def get_records(self) -> list[str]:
+        """Retrieve the recorded log messages.
+
+        Returns:
+            list[str]: A copy of the list of formatted log messages.
+        """
+        return list(self._records)
+
+    def clear(self):
+        """Clear all recorded log messages from the buffer."""
+        self._records.clear()
+
+
+def start_recording(self: logging.Logger, name: str | None = None):
+    """Start recording logs to a named recorder.
+
+    This function dynamically attaches a `RecordingHandler` to the logger.
+    If a recorder with the given name already exists, it does nothing.
+
+    The recorder uses the formatter from the first existing handler
+    if available, or falls back to a default formatter.
+
+    Args:
+        self (logging.Logger): The logger instance.
+        name (str | None): Optional name of the recorder. Defaults to `"__default__"`.
+
+    Example:
+        >>> logger.start_recording("test")
+        >>> logger.info("Message")
+    """
+    if name is None:
+        name = "__default__"
+
+    # Ensure the logger has a dict of recording handlers attached
+    if not hasattr(self, "_recording_handlers"):
+        self._recording_handlers = {}
+    if name in self._recording_handlers:
+        return  # already recording under this name
+
+    # Use same formatter as first handler, or fallback
+    if self.handlers:
+        formatter = self.handlers[0].formatter
+    else:
+        formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
+
+    handler = RecordingHandler(formatter)
+    self.addHandler(handler)
+    self._recording_handlers.update({name: handler})
+
+
+def stop_recording(self: logging.Logger, name: str | None = None):
+    """Stop and remove a named recorder from the logger.
+
+    If no recorder exists for the given name, the function does nothing.
+
+    Args:
+        self (logging.Logger): The logger instance.
+        name (str | None): Optional name of the recorder to stop.
+            Defaults to `"__default__"`.
+
+    Example:
+        >>> logger.stop_recording("test")
+    """
+    if name is None:
+        name = "__default__"
+
+    handler = self._recording_handlers.get(name, None)
+    if handler:
+        self.removeHandler(handler)
+
+
+def get_recording(self: logging.Logger, name: str | None = None) -> list[str]:
+    """Retrieve the recorded log messages for a named recorder.
+
+    Args:
+        self (logging.Logger): The logger instance.
+        name (str | None): Optional name of the recorder. Defaults to `"__default__"`.
+
+    Returns:
+        list[str]: A list of formatted log messages recorded so far.
+            Returns an empty list if no handler is found for the name.
+
+    Raises:
+        KeyError: If the recorder with the specified name does not exist.
+
+    Example:
+        >>> messages = logger.get_recording("test")
+        >>> print(messages)
+    """
+    if name is None:
+        name = "__default__"
+
+    handler = self._recording_handlers[name]
+    return handler.get_records() if handler else []
+
+
+# Monkey-patch Logger with recording methods
+logging.Logger.start_recording = start_recording
+logging.Logger.stop_recording = stop_recording
+logging.Logger.get_recording = get_recording

emtest/log_utils.py

@@ -0,0 +1,29 @@
+import os
+import appdirs
+
+
+def get_app_log_dir(app_name: str, app_family: str = ""):
+    """Get the directory to store this app's logs in.
+
+    If an environment variable APP_NAME_LOG_DIR is set, returns that.
+    If APP_FAMILY_LOG_DIR is set in env, returns APP_FAMILY_LOG_DIR/APP_NAME.
+    Otherwise, returns the standard user log dir (e.g. ~/.local/log/APP_NAME.).
+    """
+    # check environment variables
+    env_app_log_dir = os.environ.get(f"{app_name.upper()}_LOG_DIR", None)
+    env_family_log_dir = os.environ.get(f"{app_family.upper()}_LOG_DIR", None)
+
+    # decide which log dir to use
+    log_dir = ""
+    if env_app_log_dir:
+        log_dir = env_app_log_dir
+    elif env_family_log_dir and app_family:
+        log_dir = os.path.join(env_family_log_dir, app_name)
+    else:
+        log_dir = os.path.join(appdirs.user_log_dir(), app_name)
+
+    # ensure log dir exists
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+
+    return log_dir

emtest/pytest_utils.py

@@ -0,0 +1,176 @@
+from pathlib import Path
+import pytest
+from .testing_utils import set_env_var
+import os
+import sys
+from typing import Any, Optional
+from _pytest.terminal import TerminalReporter
+from _pytest.config import Config
+from _pytest.reports import TestReport
+from termcolor import colored
+
+from environs import Env
+
+env_vars = Env()
+
+
+class MinimalReporter(TerminalReporter):
+    """Custom pytest reporter that provides clean, minimal output with colored symbols.
+
+    This reporter suppresses most default pytest output and displays only:
+    - ✓ for passed tests (green)
+    - ✗ for failed tests (red)
+    - - for skipped tests (yellow)
+    """
+
+    def __init__(self, config: Config, print_errors: bool = True) -> None:
+        super().__init__(config)
+        self._tw.hasmarkup = True  # enables colored output safely
+        self.print_errors = print_errors
+        self.current_test_file = ""
+
+    def report_collect(self, final: bool = False) -> None:
+        pass
+
+    def pytest_collection(self) -> None:
+        pass
+
+    def pytest_sessionstart(self, session: Any) -> None:
+        """Override session start to suppress 'collected x items' message."""
+        # print("pytest_sessionstart")
+        pass  # suppress "collected x items"
+
+    def pytest_runtest_logstart(self, nodeid: str, location: Any) -> None:
+        """Override test start logging to suppress it."""
+        # print("pytest_runtest_logstart")
+        current_test_file = os.path.basename(location[0]).strip(".py")
+        if current_test_file != self.current_test_file:
+            self.current_test_file = current_test_file
+            print(f"\n{self.current_test_file}")
+        pass  # suppress test start lines
+
+    def pytest_runtest_logreport(self, report: TestReport) -> None:
+        """Display minimal test results with colored symbols."""
+        if report.when != "call":
+            return
+
+        test_name = report.nodeid.split("::")[-1]
+        if report.passed:
+            self.write("✓", green=True)
+            # symbol = colored("✓", "green")
+        elif report.failed:
+            self.write("✗", red=True)
+            # symbol = colored("✗", "red")
+        elif report.skipped:
+            self.write("-", yellow=True)
+            # symbol = colored("-", "yellow")
+        # self.write(f"{symbol} {test_name}")
+
+        self.write(f" {test_name}\n")
+
+        if self.print_errors and report.failed:
+            print(colored(report.longreprtext, "red"))
+
+    def summary_stats(self) -> None:
+        """Override result counts to suppress them."""
+        pass  # suppress result counts
+
+    def pytest_terminal_summary(
+        self, terminalreporter: Any, exitstatus: int, config: Config
+    ) -> None:
+        """Override final summary output to suppress it."""
+        pass  # suppress final summary output
+
+
+# Environment Variable and CLI option to deactivate MinimalReporter
+PYTEST_STANDARD_OUTPUT_ENV = "DEFAULT_TERMINAL_REPORTER"
+PYTEST_STANDARD_OUTPUT_OPT = "--default-terminal-reporter"
+if PYTEST_STANDARD_OUTPUT_OPT in sys.argv:
+    set_env_var(PYTEST_STANDARD_OUTPUT_ENV, "1", True)
+
+
+def configure_pytest_reporter(config: Config, print_errors=True) -> None:
+    """Configure the minimal reporter if terminalreporter plugin is disabled.
+
+    Args:
+        config: Pytest configuration object
+    """
+    if env_vars.bool(PYTEST_STANDARD_OUTPUT_ENV, default=False):
+        return
+    minimal_reporter = MinimalReporter(config, print_errors=print_errors)
+    # if terminalreporter plugin is disabled
+    if "no:terminalreporter" in config.option.plugins:
+        pluginmanager = config.pluginmanager
+        pluginmanager.register(minimal_reporter, "minimal-reporter")
+
+    if config.pluginmanager.has_plugin("terminalreporter"):
+        reporter = config.pluginmanager.get_plugin("terminalreporter")
+        config.pluginmanager.unregister(reporter, "terminalreporter")
+        config.pluginmanager.register(minimal_reporter, "terminalreporter")
+
+
+def run_pytest(
+    test_path: str,
+    breakpoints: bool = False,
+    enable_print: bool = False,
+    pytest_args: list[str] | None = None,
+) -> None:
+    """Run pytest with customizable options for output control and debugging.
+
+    Args:
+        test_path: Path to the test file or directory to run
+        breakpoints: If True, enables pytest debugger (--pdb) on failures
+        deactivate_pytest_output: If True, uses minimal reporter instead of default output
+        enable_print: If True, enables print statements in tests (-s flag)
+    """
+    if pytest_args:
+        args = pytest_args
+        if PYTEST_STANDARD_OUTPUT_OPT in args:
+            args.remove(PYTEST_STANDARD_OUTPUT_OPT)
+    else:
+        args = []
+    if enable_print:
+        args.append("-s")  # -s disables output capturing
+    if breakpoints:
+        args.append("--pdb")
+    os.system(f"{sys.executable} -m pytest {test_path} {' '.join(args)}")
+
+
+def get_pytest_report_files(config: pytest.Config) -> set[Path]:
+    """
+    Collect all pytest report output files.
+    """
+    paths: set[Path] = set()
+
+    # JUnit XML
+    junitxml = config.getoption("--junitxml", default=None)
+    if junitxml:
+        paths.add(Path(junitxml).resolve())
+
+    # pytest-html
+    htmlpath = getattr(config.option, "htmlpath", None)
+    if htmlpath:
+        paths.add(Path(htmlpath).resolve())
+
+    # pytest-json-report
+    json_report_file = getattr(config.option, "json_report_file", None)
+    if json_report_file:
+        paths.add(Path(json_report_file).resolve())
+    return paths
+
+
+def get_pytest_report_dirs(
+    config: pytest.Config, fallback_to_cwd: bool = False
+) -> set[Path]:
+    """
+    Collect all pytest report output directories, deduplicated.
+    """
+    dirs: set[Path] = set(
+        [report_path.parent for report_path in get_pytest_report_files(config)]
+    )
+
+    # Fallback if no reports were configured
+    if fallback_to_cwd and not dirs:
+        dirs.add(Path.cwd())
+
+    return dirs

emtest/testing_utils.py

@@ -0,0 +1,159 @@
+import os
+import sys
+import shutil
+import threading
+import time
+from time import sleep
+from typing import List
+from tqdm import TMonitor, tqdm
+
+from types import ModuleType
+
+
+def are_we_in_docker() -> bool:
+    """Check if this code is running in a docker container."""
+    return os.path.exists("/.dockerenv")
+
+
+def add_path_to_python(src_path: str) -> None:
+    """Add a directory to the Python path for importing modules.
+
+    Removes the path if it already exists, then inserts it at the beginning
+    of sys.path to ensure it takes priority over installed packages.
+
+    Args:
+        src_path: Directory path to add to Python path
+
+    Raises:
+        FileNotFoundError: If the path doesn't exist
+        NotADirectoryError: If the path is not a directory
+    """
+    src_path = os.path.abspath(src_path)
+    if not os.path.exists(src_path):
+        raise FileNotFoundError(f"The path doesn't exist: {src_path}")
+    if not os.path.isdir(src_path):
+        raise NotADirectoryError(f"The path doesn't exist: {src_path}")
+
+    if src_path in sys.path:
+        sys.path.remove(src_path)
+    sys.path.insert(0, src_path)
+
+
+def assert_is_loaded_from_source(
+    source_dir: str, module: ModuleType, print_confirmation=False
+) -> None:
+    """Assert a module is loaded from source code, not an installation.
+
+    Asserts that the loaded module's source code is located within the given
+    directory, regardless of whether it's file is located in that folder or is
+    nested in subfolders.
+
+    Args:
+        source_dir: a directory in which the module's source should be
+        module: the module to check
+    """
+    module_path = os.path.abspath(module.__file__)
+    source_path = os.path.abspath(source_dir)
+    assert source_path in module_path, (
+        f"The module `{module.__name__}` has been loaded from an installion, "
+        "not this source code!\n"
+        f"Desired source dir: {source_path}\n"
+        f"Loaded module path: {module_path}\n"
+    )
+    if print_confirmation:
+        print(f"Using module {module.__name__} from {module_path}")
+
+
+def polite_wait(n_sec: int) -> None:
+    """Wait for the given duration, displaying a progress bar.
+
+    Args:
+        n_sec: Number of seconds to wait
+    """
+    # print(f"{n_sec}s patience...")
+    for i in tqdm(range(n_sec), leave=False):
+        time.sleep(1)
+
+
+def await_thread_cleanup(
+    timeout: int = 5, print_remaining_threads: bool = True
+) -> bool:
+    """Wait for all threads to exit, with a timeout and progress bar.
+
+    Args:
+        timeout: Maximum seconds to wait for thread cleanup
+
+    Returns:
+        True if only the main thread remains, False if other threads persist
+    """
+
+    def get_threads() -> List[threading.Thread]:
+        """Get all active threads except tqdm monitor threads."""
+        return [x for x in threading.enumerate() if not isinstance(x, TMonitor)]
+
+    for i in tqdm(range(timeout), leave=False):
+        if len(get_threads()) == 1:
+            break
+        sleep(1)
+    if print_remaining_threads and len(get_threads()) > 1:
+        print("Remaining threads:")
+        for tn in get_thread_names():
+            print(f"- {tn}")
+
+    return len(get_threads()) == 1
+
+
+def get_thread_names():
+    """Get a list of the names of all active threads."""
+    return [thread.name for thread in threading.enumerate()]
+
+
+def set_env_var(name: str, value: str | bool | int, override: bool = True):
+    """
+    Set an environment variable with optional overriding behavior.
+
+    Args:
+        name (str): The name of the environment variable to set.
+        value (str): The value to assign to the environment variable.
+        override (bool, optional): Whether to overwrite the variable if it is already set.
+                                   Defaults to False.
+
+    Behavior:
+        - If 'override' is True, the environment variable will always be set to 'value'.
+        - If 'override' is False, the variable will only be set if it is not already defined.
+    """
+    if isinstance(value, bool):
+        value = int(value)
+    if isinstance(value, int):
+        value = str(value)
+    if override or name not in os.environ:
+        os.environ[name] = value
+
+
+def make_dir(dir_path: str, clear_existing: bool = False) -> str:
+    """Create a directory, handling the case where it already exists."""
+    if clear_existing and os.path.exists(dir_path):
+        shutil.rmtree(dir_path)
+    if not os.path.isdir(dir_path):
+        os.makedirs(dir_path)
+    return dir_path
+
+
+def delete_path(path: bool) -> bool:
+    """Delete the specified file or folder."""
+    if os.path.isdir(path):
+        shutil.rmtree(path)
+    elif os.path.exists(path):
+        os.remove(path)
+
+
+def ensure_dirs_exist(*dirs):
+    """Ensure that all directories in the list exist."""
+    for dir in dirs:
+        os.makedirs(dir, exist_ok=True)
+
+
+def ensure_dir_exists(dir_path):
+    if not os.path.exists(dir_path):
+        os.makedirs(dir_path)
+    return dir_path

emtest-0.0.9.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: emtest
+Version: 0.0.9
+Summary: Testing utilities which I find useful.
+Author-email: Emendir <dev@emendir.tech>
+License-Expression: MIT-0 OR CC0-1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-CC0
+Requires-Dist: appdirs
+Requires-Dist: environs
+Requires-Dist: pytest
+Requires-Dist: termcolor
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# emtest - Python Testing Utilities
+
+A Python package providing testing utilities.
+
+## Features
+
+### 🎨 Clean Test Output for Pytest
+- **MinimalReporter**: Custom pytest reporter with clean, colored output using simple symbols (✓/✗/-)
+- **Configurable Output**: Toggle between minimal and standard pytest output modes
+
+### 🔧 Development Utilities  
+- **Source Path Management**: Dynamically add directories to Python path for testing source code
+- **Module Source Validation**: Ensure modules are loaded from source directories (not installed packages)
+- **Thread Cleanup Monitoring**: Wait for and verify proper thread cleanup in tests
+
+### ⚡ Enhanced Test Execution
+- **Dual Execution Pattern**: Run tests both as pytest tests and standalone Python scripts
+- **Breakpoint Integration**: Easy debugging with pytest's `--pdb` integration
+- **Progress Indicators**: Visual progress bars for waiting operations
+
+## Installation
+
+```sh
+pip install emtest
+```
+
+## Usage
+
+See the [Usage docs](docs/Usage/PytestUtils.md) for explanations and a complete working example showing:
+- Basic test setup with `conftest.py`
+- Showing and hiding logs
+- Dual execution pattern implementation
+- Source loading validation
+- Thread cleanup testing
+- Options like minising output, python-debugger breakpoints and more
+
+## Documentation
+
+- [Full Documentation](docs/README.md):
+  - [API-Reference](docs/API-Reference/README.html)
+  - Usage:
+    - [PytestUtils](docs/Usage/PytestUtils.md)
+    - [LogRecording](docs/Usage/LogRecording.md)
+
+## Roadmap
+
+## Contributing
+
+### Get Involved
+
+- GitHub Discussions: if you want to share ideas
+- GitHub Issues: if you find bugs, other issues, or would like to submit feature requests
+- GitHub Merge Requests: if you think you know what you're doing, you're very welcome!
+
+### Donate
+
+To support me in my work on this and other projects, you can make donations with the following currencies:
+
+- **Bitcoin:** `BC1Q45QEE6YTNGRC5TSZ42ZL3MWV8798ZEF70H2DG0`
+- **Ethereum:** `0xA32C3bBC2106C986317f202B3aa8eBc3063323D4`
+- [Credit Card, Debit Card, Bank Transfer, Apple Pay, Google Pay, Revolut Pay)](https://checkout.revolut.com/pay/4e4d24de-26cf-4e7d-9e84-ede89ec67f32)
+
+Donations help me:
+- dedicate more time to developing and maintaining open-source projects
+- cover costs for IT resources
+
+## About the Developer
+
+This project is developed by a human one-man team, publishing under the name _Emendir_.  
+I build open technologies trying to improve our world;
+learning, working and sharing under the principle:
+
+> _Freely I have received, freely I give._
+
+Feel welcome to join in with code contributions, discussions, ideas and more!
+
+## Open-Source in the Public Domain
+
+I dedicate this project to the public domain.
+It is open source and free to use, share, modify, and build upon without restrictions or conditions.
+
+I make no patent or trademark claims over this project.  
+
+Formally, you may use this project under either the: 
+- [MIT No Attribution (MIT-0)](https://choosealicense.com/licenses/mit-0/) or
+- [Creative Commons Zero (CC0)](https://choosealicense.com/licenses/cc0-1.0/)
+licence at your choice.  
+
+

emtest-0.0.9.dist-info/RECORD

@@ -0,0 +1,12 @@
+_auto_run_with_pytest/__init__.py,sha256=P2Tgn9TbVJvNiyOygCrBso4uAd7Og9suuHmKE0-CEtU,753
+emtest/__init__.py,sha256=TnZFKkEnSSI1yBhtT1NvllRXLCCv0RK63kIQNaKLpmw,418
+emtest/log_recording.py,sha256=vNBRHmjTbYPv2JNj8QPbWzLKabDHZI7G5JDXOG79FnI,5062
+emtest/log_utils.py,sha256=HlsHxLYbg1k0BT2AjdykvOGNVpj7fPWlUeWGsR4LYAE,967
+emtest/pytest_utils.py,sha256=UUcNAgKJoNwGWe0x2hSHX70tekKi1wO2K4j1LZKWPek,5943
+emtest/testing_utils.py,sha256=Cv1IWrTL7pKvUccL2bRKvCZlUM2pX9EWdVkiwUxOIrQ,4951
+emtest-0.0.9.dist-info/licenses/LICENSE,sha256=i720OgyQLs68DSskm7ZLzaGKMnfskBIIHOuPWfwT2q4,907
+emtest-0.0.9.dist-info/licenses/LICENSE-CC0,sha256=kXBMw0w0VVXQAbLjqMKmis4OngrPaK4HY9ScH6MdtxM,7038
+emtest-0.0.9.dist-info/METADATA,sha256=u8IMqdTrajS0W0JwHYdxrwIlXeb0YBiWf7g8fQrsBbI,3663
+emtest-0.0.9.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+emtest-0.0.9.dist-info/top_level.txt,sha256=sfToBhqMjk35PDheZ42yiMGYNYatT3V5Mwhb79fp5dE,29
+emtest-0.0.9.dist-info/RECORD,,

emtest-0.0.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

emtest-0.0.9.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+MIT No Attribution
+
+Copyright [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

emtest-0.0.9.dist-info/licenses/LICENSE-CC0

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

emtest-0.0.9.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_auto_run_with_pytest
+emtest