pepe-http 0.35.1__tar.gz

pepe_http-0.35.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omar MHAIMDAT
+
+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.

pepe_http-0.35.1/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: pepe-http
+Version: 0.35.1
+Summary: HTTP load generator and latency tool: a load test, a ping split into phases, a ramp to the capacity, an OpenAPI spec, a flow, an access log
+License-Expression: MIT
+Project-URL: Homepage, https://pepe.mhaimdat.com
+Project-URL: Documentation, https://pepe.mhaimdat.com/docs/
+Project-URL: Source, https://github.com/omarmhaimdat/pepe
+Project-URL: Changelog, https://github.com/omarmhaimdat/pepe/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/omarmhaimdat/pepe/issues
+Keywords: http,load-testing,benchmark,latency,ping,openapi,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Testing :: Traffic Generation
+Classifier: Topic :: System :: Benchmark
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pepe
+
+HTTP load generator and latency tool, one binary: a load test with a live
+dashboard, `pepe ping` (a request a second, split into DNS, connect, TLS,
+first byte and download), `pepe ramp` (find the capacity), `pepe api` (an
+OpenAPI spec), `pepe flow` (a sequence of requests), `pepe replay` (an
+access log), `pepe compare` (two reports). The documentation is at
+[pepe.mhaimdat.com/docs](https://pepe.mhaimdat.com/docs/).
+
+```bash
+pipx install pepe-http    # or: pip install pepe-http
+pepe https://example.com
+```
+
+pepe is written in Rust, and this package is the `pepe` command that
+fetches it: the first run downloads the release of the same version for
+your platform (macOS, Linux, Windows) from
+[GitHub releases](https://github.com/omarmhaimdat/pepe/releases), checks
+it against the SHA-256 the release carries, keeps it in your cache
+directory (`~/.cache/pepe-http`, `~/Library/Caches/pepe-http` on macOS,
+`%LOCALAPPDATA%\pepe-http\Cache` on Windows; `PEPE_HTTP_CACHE_DIR` moves
+it) and runs it; every later run only runs it. There are no dependencies.
+`python -m pepe_http` is the same command.
+
+Upgrade with `pipx upgrade pepe-http` or `pip install -U pepe-http`: each
+version of the package runs the pepe of that version, so `pepe
+self-update` does not apply here. The other ways to install, with tab
+completion and man pages, are on the
+[install page](https://pepe.mhaimdat.com/docs/install.html).

pepe_http-0.35.1/README.md

@@ -0,0 +1,29 @@
+# pepe
+
+HTTP load generator and latency tool, one binary: a load test with a live
+dashboard, `pepe ping` (a request a second, split into DNS, connect, TLS,
+first byte and download), `pepe ramp` (find the capacity), `pepe api` (an
+OpenAPI spec), `pepe flow` (a sequence of requests), `pepe replay` (an
+access log), `pepe compare` (two reports). The documentation is at
+[pepe.mhaimdat.com/docs](https://pepe.mhaimdat.com/docs/).
+
+```bash
+pipx install pepe-http    # or: pip install pepe-http
+pepe https://example.com
+```
+
+pepe is written in Rust, and this package is the `pepe` command that
+fetches it: the first run downloads the release of the same version for
+your platform (macOS, Linux, Windows) from
+[GitHub releases](https://github.com/omarmhaimdat/pepe/releases), checks
+it against the SHA-256 the release carries, keeps it in your cache
+directory (`~/.cache/pepe-http`, `~/Library/Caches/pepe-http` on macOS,
+`%LOCALAPPDATA%\pepe-http\Cache` on Windows; `PEPE_HTTP_CACHE_DIR` moves
+it) and runs it; every later run only runs it. There are no dependencies.
+`python -m pepe_http` is the same command.
+
+Upgrade with `pipx upgrade pepe-http` or `pip install -U pepe-http`: each
+version of the package runs the pepe of that version, so `pepe
+self-update` does not apply here. The other ways to install, with tab
+completion and man pages, are on the
+[install page](https://pepe.mhaimdat.com/docs/install.html).

pepe_http-0.35.1/pepe_http/__init__.py

@@ -0,0 +1,186 @@
+"""pepe from PyPI.
+
+pepe is a Rust binary; this package is the `pepe` command that fetches it.
+The first run downloads the release archive of this package's version for
+the running platform from GitHub, checks it against the SHA-256 the release
+carries, keeps the binary in a per-user cache directory, and runs it with
+the arguments given; every later run only runs it. Nothing but the standard
+library is used.
+
+    PEPE_HTTP_CACHE_DIR   where the binary is kept (default: the user's
+                          cache directory, under pepe-http/)
+"""
+
+import hashlib
+import io
+import os
+import platform
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+import zipfile
+
+# pepe's version: the release this package downloads. The publish job
+# (the publish-pypi job in .github/workflows/release.yml) sets it from the release tag.
+__version__ = "0.35.1"
+
+REPO = "omarmhaimdat/pepe"
+RELEASE_URL = "https://github.com/" + REPO + "/releases/download/v{version}/{asset}"
+INSTALL_DOCS = "https://pepe.mhaimdat.com/docs/install.html"
+
+
+class Problem(Exception):
+    """Something this package could not do; the message says what."""
+
+
+def target():
+    """The release target for this machine: (triple, archive extension)."""
+    system = platform.system()
+    machine = platform.machine().lower()
+    arm = machine in ("arm64", "aarch64")
+    x86 = machine in ("x86_64", "amd64")
+    if system == "Darwin" and arm:
+        return "aarch64-apple-darwin", "tar.xz"
+    if system == "Darwin" and x86:
+        return "x86_64-apple-darwin", "tar.xz"
+    if system == "Linux" and x86:
+        return "x86_64-unknown-linux-musl", "tar.xz"
+    if system == "Linux" and arm:
+        return "aarch64-unknown-linux-musl", "tar.xz"
+    if system == "Windows" and (x86 or arm):
+        # Windows on ARM runs the x86_64 build through its emulation
+        return "x86_64-pc-windows-msvc", "zip"
+    raise Problem(
+        "there is no pepe build for %s %s; the other ways to install are at %s"
+        % (system, machine, INSTALL_DOCS)
+    )
+
+
+def cache_dir():
+    """Where the binary is kept: the user's cache directory, as the platform
+    has it, unless PEPE_HTTP_CACHE_DIR says otherwise."""
+    override = os.environ.get("PEPE_HTTP_CACHE_DIR")
+    if override:
+        return override
+    home = os.path.expanduser("~")
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA") or os.path.join(home, "AppData", "Local")
+        return os.path.join(base, "pepe-http", "Cache")
+    if sys.platform == "darwin":
+        return os.path.join(home, "Library", "Caches", "pepe-http")
+    base = os.environ.get("XDG_CACHE_HOME") or os.path.join(home, ".cache")
+    return os.path.join(base, "pepe-http")
+
+
+def binary_path():
+    """The binary of this version for this machine, in the cache (it may not
+    be there yet)."""
+    triple, _ = target()
+    name = "pepe.exe" if sys.platform == "win32" else "pepe"
+    return os.path.join(cache_dir(), "v" + __version__, triple, name)
+
+
+def fetch(url):
+    """The bytes at a URL, or a Problem that says why not."""
+    request = urllib.request.Request(url, headers={"User-Agent": "pepe-http/" + __version__})
+    try:
+        with urllib.request.urlopen(request, timeout=60) as response:
+            return response.read()
+    except urllib.error.HTTPError as error:
+        if error.code == 404:
+            raise Problem(
+                "release v%s has no %s; the releases are at https://github.com/%s/releases"
+                % (__version__, url.rsplit("/", 1)[-1], REPO)
+            )
+        raise Problem("could not download %s: HTTP %s" % (url, error.code))
+    except (urllib.error.URLError, OSError) as error:
+        raise Problem("could not download %s: %s" % (url, error.reason if hasattr(error, "reason") else error))
+
+
+def verify(archive, checksum_file, asset):
+    """The archive's SHA-256 must be the one the release says."""
+    expected = checksum_file.decode("utf-8", "replace").split()
+    if not expected or len(expected[0]) != 64:
+        raise Problem("the checksum file for %s is not one: %r" % (asset, checksum_file[:80]))
+    actual = hashlib.sha256(archive).hexdigest()
+    if actual != expected[0].lower():
+        raise Problem(
+            "%s does not match its checksum (expected %s, got %s); not installing it"
+            % (asset, expected[0], actual)
+        )
+
+
+def binary_from(archive, extension, name):
+    """The bytes of the binary inside a release archive. Only that member is
+    read; the archive's own paths are not used for anything."""
+    if extension == "zip":
+        with zipfile.ZipFile(io.BytesIO(archive)) as zf:
+            for member in zf.infolist():
+                if member.filename.rsplit("/", 1)[-1] == name and not member.is_dir():
+                    return zf.read(member)
+    else:
+        with tarfile.open(fileobj=io.BytesIO(archive), mode="r:xz") as tf:
+            for member in tf:
+                if member.isfile() and member.name.rsplit("/", 1)[-1] == name:
+                    return tf.extractfile(member).read()
+    raise Problem("the release archive has no %s in it" % name)
+
+
+def download(path):
+    """Download, verify and keep this version's binary at `path`."""
+    triple, extension = target()
+    asset = "pepe-%s.%s" % (triple, extension)
+    url = RELEASE_URL.format(version=__version__, asset=asset)
+    sys.stderr.write("pepe-http: downloading pepe v%s for %s\n" % (__version__, triple))
+    sys.stderr.flush()
+    archive = fetch(url)
+    verify(archive, fetch(url + ".sha256"), asset)
+    binary = binary_from(archive, extension, os.path.basename(path))
+
+    # Written beside its place and moved in, so a run that starts meanwhile
+    # sees either nothing or the whole binary
+    directory = os.path.dirname(path)
+    os.makedirs(directory, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(prefix=".pepe-", dir=directory)
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(binary)
+        os.chmod(temporary, 0o755)
+        os.replace(temporary, path)
+    except BaseException:
+        try:
+            os.unlink(temporary)
+        except OSError:
+            pass
+        raise
+
+
+def ensure():
+    """The path of the binary, downloaded if it isn't there."""
+    path = binary_path()
+    if not os.path.isfile(path):
+        download(path)
+    return path
+
+
+def main(argv=None):
+    """Run pepe with the arguments given (the process's own by default).
+    Returns pepe's exit code, or 1 when the binary could not be had."""
+    args = list(sys.argv[1:] if argv is None else argv)
+    try:
+        exe = ensure()
+    except Problem as problem:
+        sys.stderr.write("pepe-http: %s\n" % problem)
+        return 1
+    if os.name == "posix":
+        os.execv(exe, [exe] + args)
+    # Windows has no exec: run it and pass its exit code on. Ctrl+C reaches
+    # both processes; let pepe finish its own handling of it
+    process = subprocess.Popen([exe] + args)
+    try:
+        return process.wait()
+    except KeyboardInterrupt:
+        return process.wait()

pepe_http-0.35.1/pepe_http/__main__.py

@@ -0,0 +1,8 @@
+"""`python -m pepe_http ...` is `pepe ...`."""
+
+import sys
+
+from pepe_http import main
+
+if __name__ == "__main__":
+    sys.exit(main())

pepe_http-0.35.1/pepe_http.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: pepe-http
+Version: 0.35.1
+Summary: HTTP load generator and latency tool: a load test, a ping split into phases, a ramp to the capacity, an OpenAPI spec, a flow, an access log
+License-Expression: MIT
+Project-URL: Homepage, https://pepe.mhaimdat.com
+Project-URL: Documentation, https://pepe.mhaimdat.com/docs/
+Project-URL: Source, https://github.com/omarmhaimdat/pepe
+Project-URL: Changelog, https://github.com/omarmhaimdat/pepe/blob/master/CHANGELOG.md
+Project-URL: Issues, https://github.com/omarmhaimdat/pepe/issues
+Keywords: http,load-testing,benchmark,latency,ping,openapi,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Testing :: Traffic Generation
+Classifier: Topic :: System :: Benchmark
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pepe
+
+HTTP load generator and latency tool, one binary: a load test with a live
+dashboard, `pepe ping` (a request a second, split into DNS, connect, TLS,
+first byte and download), `pepe ramp` (find the capacity), `pepe api` (an
+OpenAPI spec), `pepe flow` (a sequence of requests), `pepe replay` (an
+access log), `pepe compare` (two reports). The documentation is at
+[pepe.mhaimdat.com/docs](https://pepe.mhaimdat.com/docs/).
+
+```bash
+pipx install pepe-http    # or: pip install pepe-http
+pepe https://example.com
+```
+
+pepe is written in Rust, and this package is the `pepe` command that
+fetches it: the first run downloads the release of the same version for
+your platform (macOS, Linux, Windows) from
+[GitHub releases](https://github.com/omarmhaimdat/pepe/releases), checks
+it against the SHA-256 the release carries, keeps it in your cache
+directory (`~/.cache/pepe-http`, `~/Library/Caches/pepe-http` on macOS,
+`%LOCALAPPDATA%\pepe-http\Cache` on Windows; `PEPE_HTTP_CACHE_DIR` moves
+it) and runs it; every later run only runs it. There are no dependencies.
+`python -m pepe_http` is the same command.
+
+Upgrade with `pipx upgrade pepe-http` or `pip install -U pepe-http`: each
+version of the package runs the pepe of that version, so `pepe
+self-update` does not apply here. The other ways to install, with tab
+completion and man pages, are on the
+[install page](https://pepe.mhaimdat.com/docs/install.html).

pepe_http-0.35.1/pepe_http.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+pepe_http/__init__.py
+pepe_http/__main__.py
+pepe_http.egg-info/PKG-INFO
+pepe_http.egg-info/SOURCES.txt
+pepe_http.egg-info/dependency_links.txt
+pepe_http.egg-info/entry_points.txt
+pepe_http.egg-info/top_level.txt

pepe_http-0.35.1/pepe_http.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pepe_http-0.35.1/pepe_http.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pepe = pepe_http:main

pepe_http-0.35.1/pepe_http.egg-info/top_level.txt

@@ -0,0 +1 @@
+pepe_http

pepe_http-0.35.1/pyproject.toml

@@ -0,0 +1,48 @@
+# pepe on PyPI (`pip install pepe-http`; `pepe-cli` is taken there). The
+# package is a few lines of Python that download the pepe release of the
+# same version from GitHub on first run and run it: see pepe_http/__init__.py.
+# The version is pepe's, read from pepe_http.__version__; the publish job
+# (the publish-pypi job in .github/workflows/release.yml) sets it from the release tag, so a
+# published package always fetches its own release.
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pepe-http"
+dynamic = ["version"]
+description = "HTTP load generator and latency tool: a load test, a ping split into phases, a ramp to the capacity, an OpenAPI spec, a flow, an access log"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+keywords = ["http", "load-testing", "benchmark", "latency", "ping", "openapi", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Rust",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Testing :: Traffic Generation",
+    "Topic :: System :: Benchmark",
+]
+
+[project.urls]
+Homepage = "https://pepe.mhaimdat.com"
+Documentation = "https://pepe.mhaimdat.com/docs/"
+Source = "https://github.com/omarmhaimdat/pepe"
+Changelog = "https://github.com/omarmhaimdat/pepe/blob/master/CHANGELOG.md"
+Issues = "https://github.com/omarmhaimdat/pepe/issues"
+
+[project.scripts]
+pepe = "pepe_http:main"
+
+[tool.setuptools]
+packages = ["pepe_http"]
+
+[tool.setuptools.dynamic]
+version = {attr = "pepe_http.__version__"}

pepe_http-0.35.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+