pytest-cov-container 0.0.1__py3-none-any.whl

pytest_cov_container/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026-present tomaDev <genins21@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.0.1"

pytest_cov_container/__init__.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2026-present tomaDev <genins21@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+import warnings
+from typing import Any
+
+_active_plugin: Any = None
+
+
+def collect_container_coverage():
+    """Flush and collect coverage from running containers.
+
+    Call this before stopping containers to capture mid-session coverage.
+
+    Example::
+
+        from pytest_cov_container import collect_container_coverage
+
+
+        @pytest.fixture(scope="session")
+        def sam_api():
+            proc = start_sam(...)
+            yield SAM_URL
+            collect_container_coverage()
+            proc.terminate()
+    """
+    if _active_plugin is None:
+        warnings.warn(
+            "pytest-cov-container is not active. "
+            "Ensure pytest-cov is running (--cov) and "
+            "[tool.pytest-cov-container] is configured.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return
+    _active_plugin.collect_from_running()

pytest_cov_container/config.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import tomllib
+
+from pytest_cov_container.models import DriverConfig
+
+
+@dataclass
+class PluginConfig:
+    image_pattern: str | None = None
+    label: str | None = None
+    language: str = "python"
+    enabled: bool = True
+    path_mapping: dict[str, str] = field(default_factory=dict)
+    driver_config: DriverConfig | None = None
+
+
+def load_config(pyproject_path: Path) -> PluginConfig | None:
+    if not pyproject_path.exists():
+        return None
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    tool_config = data.get("tool", {}).get("pytest-cov-container")
+    if tool_config is None:
+        return None
+
+    path_mapping = {str(k): str(v) for k, v in tool_config.get("path_mapping", {}).items()}
+
+    plugin_config = PluginConfig(
+        image_pattern=tool_config.get("image_pattern"),
+        label=tool_config.get("label"),
+        language=tool_config.get("language", "python"),
+        enabled=tool_config.get("enabled", True),
+        path_mapping=path_mapping,
+    )
+
+    driver_section = tool_config.get(plugin_config.language, {})
+    plugin_config.driver_config = DriverConfig(
+        build_dir=driver_section.get("build_dir", ".aws-sam/build/ApiFunction"),
+        entrypoint=driver_section.get("entrypoint", "uvicorn app:app --host 0.0.0.0 --port 8080"),
+        path_mapping=path_mapping,
+    )
+
+    return plugin_config

pytest_cov_container/docker_backend.py

@@ -0,0 +1,101 @@
+import fnmatch
+import io
+import tarfile
+import warnings
+from pathlib import Path
+
+import docker
+import docker.errors
+
+from pytest_cov_container.models import ContainerInfo
+
+_SIGNAL_CMD = [
+    "sh",
+    "-c",
+    "for p in /proc/[0-9]*/cmdline; do "
+    "pid=$(echo $p | cut -d/ -f3); "
+    "if grep -q _cov_wrapper $p 2>/dev/null; "
+    "then kill -USR1 $pid; break; fi; done",
+]
+
+
+class DockerBackend:
+    def __init__(self, client: docker.DockerClient | None = None):
+        self._client = client or docker.from_env()
+
+    def find_containers(
+        self,
+        image_pattern: str | None = None,
+        label: str | None = None,
+    ) -> list[ContainerInfo]:
+        filters: dict = {}
+        if label:
+            filters["label"] = label
+
+        containers = self._client.containers.list(all=True, filters=filters)
+
+        if image_pattern:
+            containers = [
+                c for c in containers if any(fnmatch.fnmatch(tag, image_pattern) for tag in (c.image.tags or []))
+            ]
+
+        return [self._to_info(c) for c in containers]
+
+    def send_signal(self, container_id: str) -> None:
+        try:
+            container = self._client.containers.get(container_id)
+            container.exec_run(_SIGNAL_CMD)
+        except docker.errors.APIError as exc:
+            warnings.warn(
+                f"Failed to send signal to container {container_id[:12]}: {exc}",
+                UserWarning,
+                stacklevel=2,
+            )
+
+    def extract_matching_files(
+        self,
+        container_id: str,
+        source_dir: str,
+        prefix: str,
+        dest: Path,
+    ) -> list[Path]:
+        try:
+            container = self._client.containers.get(container_id)
+            stream, _ = container.get_archive(source_dir)
+        except docker.errors.APIError as exc:
+            warnings.warn(
+                f"Failed to extract from container {container_id[:12]}: {exc}. Check that the container is accessible.",
+                UserWarning,
+                stacklevel=2,
+            )
+            return []
+
+        tar_bytes = b"".join(stream)
+        extracted: list[Path] = []
+        with tarfile.open(fileobj=io.BytesIO(tar_bytes)) as tar:
+            for member in tar.getmembers():
+                if not member.isfile():
+                    continue
+                name = Path(member.name).name
+                if not name.startswith(prefix):
+                    continue
+                member_file = tar.extractfile(member)
+                if member_file:
+                    target = dest / name
+                    target.write_bytes(member_file.read())
+                    extracted.append(target)
+        return extracted
+
+    def inspect(self, container_id: str) -> dict:
+        container = self._client.containers.get(container_id)
+        return container.attrs
+
+    @staticmethod
+    def _to_info(container) -> ContainerInfo:
+        return ContainerInfo(
+            id=container.id,
+            name=container.name,
+            image=container.image.tags[0] if container.image.tags else "",
+            labels=container.labels,
+            status=container.status,
+        )

pytest_cov_container/drivers/__init__.py

@@ -0,0 +1,21 @@
+from importlib.metadata import entry_points
+
+from pytest_cov_container.models import LanguageDriver
+
+
+def discover_drivers() -> dict[str, LanguageDriver]:
+    eps = entry_points(group="pytest_cov_container.drivers")
+    drivers: dict[str, LanguageDriver] = {}
+    for ep in eps:
+        driver_class = ep.load()
+        drivers[ep.name] = driver_class()
+    return drivers
+
+
+def get_driver(name: str) -> LanguageDriver:
+    found = discover_drivers()
+    if name not in found:
+        available = ", ".join(sorted(found.keys()))
+        msg = f"Unknown language driver '{name}'. Available: {available}"
+        raise ValueError(msg)
+    return found[name]

pytest_cov_container/drivers/python.py

@@ -0,0 +1,105 @@
+import stat
+import time
+import warnings
+from pathlib import Path
+
+from pytest_cov_container.models import ContainerInfo, DockerBackendProtocol, DriverConfig, InjectionResult
+
+_COVERAGERC_TEMPLATE = """\
+[run]
+data_file = /tmp/.coverage.container
+relative_files = true
+parallel = true
+sigterm = true
+include =
+    *.py
+omit =
+    _cov_wrapper.py
+"""
+
+_COV_WRAPPER_TEMPLATE = """\
+import os
+import signal
+import subprocess
+
+import coverage
+
+cov = coverage.Coverage(
+    config_file=os.environ.get("COVERAGE_PROCESS_START", "/var/task/.coveragerc")
+)
+cov.start()
+
+
+def _flush(*_):
+    cov.save()
+
+
+signal.signal(signal.SIGUSR1, _flush)
+
+proc = subprocess.Popen(
+    ["sh", "-c", os.environ.get("CONTAINER_COV_ENTRYPOINT", "{entrypoint}")]
+)
+proc.wait()
+cov.stop()
+cov.save()
+"""
+
+_RUN_SH_TEMPLATE = """\
+#!/bin/bash
+exec python /var/task/_cov_wrapper.py
+"""
+
+
+class PythonDriver:
+    name: str = "python"
+
+    def inject(self, target_dir: Path, config: DriverConfig) -> InjectionResult:
+        files_written: list[Path] = []
+
+        # .coveragerc
+        coveragerc = target_dir / ".coveragerc"
+        coveragerc.write_text(_COVERAGERC_TEMPLATE)
+        files_written.append(coveragerc)
+
+        # _cov_wrapper.py
+        wrapper = target_dir / "_cov_wrapper.py"
+        wrapper.write_text(_COV_WRAPPER_TEMPLATE.format(entrypoint=config.entrypoint))
+        files_written.append(wrapper)
+
+        # run.sh
+        run_sh = target_dir / "run.sh"
+        run_sh.write_text(_RUN_SH_TEMPLATE)
+        run_sh.chmod(run_sh.stat().st_mode | stat.S_IEXEC)
+        files_written.append(run_sh)
+
+        return InjectionResult(
+            files_written=files_written,
+            env_vars={"COVERAGE_PROCESS_START": "/var/task/.coveragerc"},
+        )
+
+    def collect(
+        self,
+        docker_backend: DockerBackendProtocol,
+        container: ContainerInfo,
+        dest: Path,
+        config: DriverConfig,  # noqa: ARG002
+    ) -> Path:
+        if container.status == "running":
+            docker_backend.send_signal(container.id)
+            time.sleep(1)
+
+        extracted = docker_backend.extract_matching_files(
+            container.id,
+            "/tmp",  # noqa: S108
+            ".coverage.container",
+            dest,
+        )
+
+        if not extracted:
+            warnings.warn(
+                f"No coverage data found in container {container.name} ({container.id[:12]})",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        return dest

pytest_cov_container/models.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class ContainerInfo:
+    id: str
+    name: str
+    image: str
+    labels: dict[str, str]
+    status: str
+
+
+@dataclass
+class DriverConfig:
+    build_dir: str
+    entrypoint: str
+    path_mapping: dict[str, str]
+
+
+@dataclass
+class InjectionResult:
+    files_written: list[Path]
+    env_vars: dict[str, str] = field(default_factory=dict)
+
+
+class DockerBackendProtocol(Protocol):
+    def send_signal(self, container_id: str) -> None: ...
+
+    def extract_matching_files(
+        self,
+        container_id: str,
+        source_dir: str,
+        prefix: str,
+        dest: Path,
+    ) -> list[Path]: ...
+
+
+@runtime_checkable
+class LanguageDriver(Protocol):
+    name: str
+
+    def inject(self, target_dir: Path, config: DriverConfig) -> InjectionResult: ...
+
+    def collect(
+        self,
+        docker_backend: DockerBackendProtocol,
+        container: ContainerInfo,
+        dest: Path,
+        config: DriverConfig,
+    ) -> Path: ...

pytest_cov_container/plugin.py

@@ -0,0 +1,117 @@
+import subprocess
+import sys
+import tempfile
+import warnings
+from pathlib import Path
+
+import pytest
+
+import pytest_cov_container
+from pytest_cov_container import config as config_module
+from pytest_cov_container import drivers
+from pytest_cov_container.docker_backend import DockerBackend
+from pytest_cov_container.resolver import SamBuildResolver
+
+
+class ContainerCovPlugin:
+    def __init__(self, plugin_config):
+        self.config = plugin_config
+        self.backend = DockerBackend()
+        self.driver = drivers.get_driver(plugin_config.language)
+        self.resolver = SamBuildResolver()
+        self.injection_result = None
+        self.coverage_dir = Path(tempfile.mkdtemp(prefix="cov_container_"))
+
+    def pytest_sessionstart(self, session):
+        target_dir = self.resolver.resolve_target_dir(
+            self.config.driver_config.build_dir,
+            session.config.rootpath,
+        )
+        if not target_dir.exists():
+            msg = f"Build directory {target_dir} does not exist. Run 'sam build' before running tests."
+            raise FileNotFoundError(msg)
+
+        self.injection_result = self.driver.inject(target_dir, self.config.driver_config)
+
+    @pytest.hookimpl(trylast=True)
+    def pytest_sessionfinish(self, session, exitstatus):  # noqa: ARG002
+        containers = self.backend.find_containers(
+            image_pattern=self.config.image_pattern,
+            label=self.config.label,
+        )
+
+        if not containers:
+            warnings.warn(
+                "No matching containers found for coverage collection",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        for container in containers:
+            self.driver.collect(self.backend, container, self.coverage_dir, self.config.driver_config)
+
+        self._combine_coverage(session.config.rootpath)
+
+    def collect_from_running(self):
+        containers = self.backend.find_containers(
+            image_pattern=self.config.image_pattern,
+            label=self.config.label,
+        )
+        running = [c for c in containers if c.status == "running"]
+        for container in running:
+            self.driver.collect(self.backend, container, self.coverage_dir, self.config.driver_config)
+
+    def _combine_coverage(self, root: Path):
+        rc_path = self.coverage_dir / ".coveragerc"
+        lines = ["[paths]"]
+        for i, (host_path, container_path) in enumerate(self.config.path_mapping.items()):
+            label = "source" if i == 0 else f"source{i}"
+            lines.append(f"{label} =")
+            lines.append(f"    {host_path}")
+            lines.append(f"    {container_path}")
+        rc_path.write_text("\n".join(lines) + "\n")
+
+        result = subprocess.run(
+            [sys.executable, "-m", "coverage", "combine", f"--rcfile={rc_path}", str(self.coverage_dir)],
+            check=False,
+            cwd=root,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            warnings.warn(
+                f"coverage combine failed: {result.stderr}",
+                UserWarning,
+                stacklevel=2,
+            )
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("cov-container")
+    group.addoption(
+        "--no-cov-container",
+        action="store_true",
+        default=False,
+        help="Disable container coverage collection",
+    )
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_configure(config):
+    if config.getoption("--no-cov-container", default=False):
+        return
+
+    if not config.pluginmanager.hasplugin("pytest_cov"):
+        return
+
+    cov_sources = config.getoption("--cov", default=[])
+    if not cov_sources:
+        return
+
+    plugin_config = config_module.load_config(config.rootpath / "pyproject.toml")
+    if plugin_config is None or not plugin_config.enabled:
+        return
+
+    plugin = ContainerCovPlugin(plugin_config)
+    config.pluginmanager.register(plugin, "cov_container")
+    pytest_cov_container._active_plugin = plugin  # noqa: SLF001

pytest_cov_container/resolver.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+
+class SamBuildResolver:
+    def resolve_target_dir(self, build_dir: str, project_root: Path) -> Path:
+        path = Path(build_dir)
+        if path.is_absolute():
+            return path
+        return project_root / path

pytest_cov_container-0.0.1.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: pytest-cov-container
+Version: 0.0.1
+Summary: Pytest plugin to collect code coverage from applications running inside Docker containers
+Project-URL: Documentation, https://github.com/tomaDev/pytest-cov-container#readme
+Project-URL: Issues, https://github.com/tomaDev/pytest-cov-container/issues
+Project-URL: Source, https://github.com/tomaDev/pytest-cov-container
+Author-email: tomaDev <genins21@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: containers,coverage,docker,pytest,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python
+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: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.11
+Requires-Dist: coverage>=7.2
+Requires-Dist: docker>=6.0
+Requires-Dist: pytest-cov>=4.0
+Requires-Dist: pytest>=7.0
+Description-Content-Type: text/markdown
+
+# pytest-cov-container
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pytest-cov-container.svg)](https://pypi.org/project/pytest-cov-container)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-cov-container.svg)](https://pypi.org/project/pytest-cov-container)
+[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+
+Collect code coverage from Python applications running inside Docker containers during integration tests. Works alongside [pytest-cov](https://github.com/pytest-dev/pytest-cov) to combine container coverage with your local test coverage.
+
+Built for projects using [AWS SAM](https://docs.aws.amazon.com/serverless-application-model/) local testing, but works with any Docker-based test workflow.
+
+## How It Works
+
+1. **Before tests** — injects a coverage wrapper, `.coveragerc`, and `run.sh` into your SAM build directory
+2. **During tests** — your containerized app runs under `coverage` via the injected wrapper
+3. **After tests** — extracts `.coverage.*` files from containers and runs `coverage combine` to merge them with local results
+
+## Installation
+
+```console
+pip install pytest-cov-container
+```
+
+Requires Python 3.11+.
+
+## Configuration
+
+Add to your `pyproject.toml`:
+
+```toml
+[tool.pytest-cov-container]
+image_pattern = "samcli/lambda*"
+label = "pytest-cov-container"
+
+[tool.pytest-cov-container.path_mapping]
+"src/api" = "/var/task"
+
+[tool.pytest-cov-container.python]
+build_dir = ".aws-sam/build/ApiFunction"
+entrypoint = "uvicorn app:app --host 0.0.0.0 --port 8080"
+```
+
+| Key | Description |
+|-----|-------------|
+| `image_pattern` | Glob pattern to match container image tags |
+| `label` | Docker label to filter containers |
+| `path_mapping` | Maps host source paths to container paths (used by `coverage combine`) |
+| `build_dir` | SAM build output directory where coverage files are injected |
+| `entrypoint` | The command your app runs inside the container |
+| `language` | Language driver to use (default: `"python"`) |
+| `enabled` | Set to `false` to disable (default: `true`) |
+
+## Usage
+
+Run your tests with `--cov` as usual:
+
+```console
+pytest --cov=src/api tests/
+```
+
+The plugin activates automatically when:
+- pytest-cov is active (`--cov` flag present)
+- `[tool.pytest-cov-container]` is configured in `pyproject.toml`
+
+Disable it for a run with:
+
+```console
+pytest --cov=src/api --no-cov-container tests/
+```
+
+### Mid-Session Collection
+
+If you need to collect coverage before containers stop (e.g., in a session-scoped fixture teardown), use the public API:
+
+```python
+from pytest_cov_container import collect_container_coverage
+
+@pytest.fixture(scope="session")
+def sam_api():
+    proc = start_sam(...)
+    yield SAM_URL
+    collect_container_coverage()
+    proc.terminate()
+```
+
+This sends `SIGUSR1` to running containers to flush coverage data, then extracts the files.
+
+## Pluggable Drivers
+
+Language support is pluggable via entry points. The built-in Python driver handles:
+
+- Writing `.coveragerc` with `parallel = true` and `sigterm = true`
+- Writing `_cov_wrapper.py` that starts coverage, handles `SIGTERM`/`SIGUSR1`, and runs your entrypoint
+- Writing `run.sh` to bootstrap the wrapper
+- Extracting `.coverage.*` files from `/tmp` in containers
+
+To add a driver for another language, register an entry point:
+
+```toml
+[project.entry-points."pytest_cov_container.drivers"]
+node = "my_package.drivers.node:NodeDriver"
+```
+
+Drivers must implement the `LanguageDriver` protocol from `pytest_cov_container.models`.
+
+## Development
+
+```console
+# Run tests
+hatch test
+
+# Run across all Python versions
+hatch test --all
+
+# Format and lint
+hatch fmt
+
+# Type check
+hatch run types:check
+
+# Security scan
+hatch run security:scan
+```
+
+## License
+
+`pytest-cov-container` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

pytest_cov_container-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+pytest_cov_container/__about__.py,sha256=_6K3JaHxGrAAf9QWvnngLAyAqs-pyQ0h7aHu_B2jDHE,123
+pytest_cov_container/__init__.py,sha256=g82W1-dF7joWQG0ONmDBj2Hm3LnCLcz97HBDXZF4dJA,963
+pytest_cov_container/config.py,sha256=O3gHl4ByejjgEB-nLzR-nH8sl_MpjvMZcvMXBB6ZS6o,1440
+pytest_cov_container/docker_backend.py,sha256=06i9AZqrjK6IXraNihsXEbW4J34nN12D9aaJ9MlfQWc,3148
+pytest_cov_container/models.py,sha256=liAkE_T9Dze7EuMWlhsHcwpTtACteuVh1SPXpYl5ptQ,1060
+pytest_cov_container/plugin.py,sha256=ej1PidjQGEPrlH_fLiC-GasxMTa2uNH8Ly9MAz48w4A,4017
+pytest_cov_container/resolver.py,sha256=nCg4e9UvmpphQ_CHicFt_dGpTMwSYPq5YPZ8Yve-y0s,250
+pytest_cov_container/drivers/__init__.py,sha256=t6JmIvT7HfPrjzqbmOHY7tX9ihcTjDLBQ1eJifBzzsw,656
+pytest_cov_container/drivers/python.py,sha256=U7XWmjnw2D3-LvuttJhl6dZGbtflqpwYY4mZbk06BHE,2484
+pytest_cov_container-0.0.1.dist-info/METADATA,sha256=EuLk-us-f9Z-udCRC1N7-2tyxWL_ohg6wqiKm9H-xbI,5056
+pytest_cov_container-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pytest_cov_container-0.0.1.dist-info/entry_points.txt,sha256=S1jaxS9MKAETKV2JLzIAnvRwUFQsJXnJ5B0f0yKS4ao,145
+pytest_cov_container-0.0.1.dist-info/licenses/LICENSE.txt,sha256=l-uCyVpFGHkbtBjhxUN2NnLtz05SMD9Np92H7SubkqE,1093
+pytest_cov_container-0.0.1.dist-info/RECORD,,

pytest_cov_container-0.0.1.dist-info/WHEEL

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

pytest_cov_container-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[pytest11]
+cov_container = pytest_cov_container.plugin
+
+[pytest_cov_container.drivers]
+python = pytest_cov_container.drivers.python:PythonDriver

pytest_cov_container-0.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026-present tomaDev <genins21@gmail.com>
+
+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, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+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.