iripau 0.1.0__tar.gz → 1.1.0__tar.gz

{iripau-0.1.0 → iripau-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iripau
-Version: 0.1.0
+Version: 1.1.0
 Summary: Python utilities focused on command execution
 Author: Ricardo Quezada
 Maintainer: Ricardo Quezada
@@ -9,11 +9,12 @@ Project-URL: Repository, https://github.com/ricardo-galo/iripau
 Project-URL: Bug Tracker, https://github.com/ricardo-galo/iripau/issues
 Project-URL: Changelog, https://github.com/ricardo-galo/iripau/blob/master/CHANGELOG.md
 Keywords: subprocess,command,local,remote,ssh,Linux,real-time,log,logging,threading,utilities
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: curlify
 Requires-Dist: psutil
 Dynamic: license-file
 

iripau-1.1.0/iripau/requests.py

@@ -0,0 +1,81 @@
+"""
+Utilities for the requests module
+"""
+
+import requests
+
+from curlify import to_curl
+
+from iripau.subprocess import TeeStreams, Popen
+
+
+def curlify(
+    response, compressed=False, verify=True, pretty=False,
+    hide_output=False, headers_to_hide=[], headers_to_omit=[],
+    stdout_tees: TeeStreams = [], add_global_stdout_tees=True,
+    stderr_tees: TeeStreams = [], add_global_stderr_tees=True,
+    prompt_tees: TeeStreams = [], add_global_prompt_tees=True,
+    echo=None
+):
+    """ Simulate the request was executed by a curl subprocess.
+        The command and output can be echoed and/or sent to files as described
+        in subprocess.run
+    """
+    request = response.request
+    if headers_to_hide or headers_to_omit:
+        request = request.copy()
+
+        for header in headers_to_omit:
+            if header in request.headers:
+                del request.headers[header]
+
+        for header in headers_to_hide:
+            if header in request.headers:
+                request.headers[header] = "***"
+
+    stdout = hide_output and b"***" or response.content
+    if not stdout.endswith(b"\n"):
+        stdout += b"\n"
+    stderr = ""
+
+    Popen.simulate(
+        cmd=to_curl(request, compressed, verify, pretty),
+        stdout=stdout,
+        stderr=stderr,
+        comment=f"{response.status_code} - {response.reason}",
+        stdout_tees=stdout_tees,
+        stderr_tees=stderr_tees,
+        prompt_tees=prompt_tees,
+        add_global_stdout_tees=add_global_stdout_tees,
+        add_global_stderr_tees=add_global_stderr_tees,
+        add_global_prompt_tees=add_global_prompt_tees,
+        echo=echo
+    )
+
+
+class Session(requests.Session):
+    """ A requests.Session that accepts curlify arguments in the request method """
+
+    def request(
+        self, *args, compressed=False, pretty=False,
+        hide_output=False, headers_to_hide=[], headers_to_omit=[],
+        stdout_tees: TeeStreams = [], add_global_stdout_tees=True,
+        stderr_tees: TeeStreams = [], add_global_stderr_tees=True,
+        prompt_tees: TeeStreams = [], add_global_prompt_tees=True,
+        echo=None, **kwargs
+    ):
+        response = super().request(*args, **kwargs)
+
+        verify = kwargs.get("verify")
+        if verify is None:
+            verify = self.verify
+
+        curlify(
+            response, compressed, verify, pretty,
+            hide_output, headers_to_hide, headers_to_omit,
+            stdout_tees, add_global_stdout_tees,
+            stderr_tees, add_global_stderr_tees,
+            prompt_tees, add_global_prompt_tees,
+            echo
+        )
+        return response

{iripau-0.1.0 → iripau-1.1.0}/iripau/subprocess.py

@@ -5,7 +5,6 @@ This module relies on the following system utilities being installed:
 * bash
 * kill
 * pstree
-* sudo
 * tee
 """
 
@@ -38,6 +37,7 @@ GLOBAL_PROMPTS = set()
 
 
 TeeStream = Union[io.IOBase, Callable[[], io.IOBase]]
+TeeStreams = Iterable[TeeStream]
 
 
 class PipeFile(SpooledTemporaryFile):
@@ -124,27 +124,21 @@ class Popen(subprocess.Popen):
 
     def __init__(
         self, args, *, cwd=None, env=None, encoding=None, errors=None, text=None,
-        stdout_tees: Iterable[TeeStream] = [], add_global_stdout_tees=True,
-        stderr_tees: Iterable[TeeStream] = [], add_global_stderr_tees=True,
-        prompt_tees: Iterable[TeeStream] = [], add_global_prompt_tees=True,
+        stdout_tees: TeeStreams = [], add_global_stdout_tees=True,
+        stderr_tees: TeeStreams = [], add_global_stderr_tees=True,
+        prompt_tees: TeeStreams = [], add_global_prompt_tees=True,
         echo=None, alias=None, comment=None, **kwargs
     ):
         stdout = kwargs.get("stdout")
         stderr = kwargs.get("stderr")
 
-        stdout_tees, stderr_tees, prompt_tees = self._get_tee_sets(
+        stdout_tees, stderr_tees, prompt_tees, err2out = self._get_tee_sets(
             stdout_tees, add_global_stdout_tees,
             stderr_tees, add_global_stderr_tees,
             prompt_tees, add_global_prompt_tees,
             echo, stdout, stderr
         )
 
-        if stderr is STDOUT:
-            err2out = True
-            stderr_tees = set()
-        else:
-            err2out = False
-
         stdout_fds = {tee.fileno() for tee in stdout_tees}
         stderr_fds = {tee.fileno() for tee in stderr_tees}
         prompt_fds = {tee.fileno() for tee in prompt_tees}
@@ -176,7 +170,7 @@ class Popen(subprocess.Popen):
         self.stderr_process = stderr_process
 
     @staticmethod
-    def _get_tee_files(tees: Iterable[TeeStream]):
+    def _get_tee_files(tees: TeeStreams):
         return set(callable(tee) and tee() or tee for tee in tees)
 
     @classmethod
@@ -218,12 +212,52 @@ class Popen(subprocess.Popen):
             if stderr_tees:
                 stderr_tees.add(sys.stderr)
 
+        if stderr is STDOUT:
+            err2out = True
+            stderr_tees = set()
+        else:
+            err2out = False
+
         return (
             cls._get_tee_files(stdout_tees),
             cls._get_tee_files(stderr_tees),
-            cls._get_tee_files(prompt_tees)
+            cls._get_tee_files(prompt_tees),
+            err2out
+        )
+
+    @classmethod
+    def simulate(
+        cls, cmd, stdout, stderr, encoding=None, errors=None, text=None, comment=None,
+        stdout_tees: TeeStreams = [], add_global_stdout_tees=True,
+        stderr_tees: TeeStreams = [], add_global_stderr_tees=True,
+        prompt_tees: TeeStreams = [], add_global_prompt_tees=True,
+        echo=None
+    ):
+        stdout_tees, stderr_tees, prompt_tees, err2out = cls._get_tee_sets(
+            stdout_tees, add_global_stdout_tees,
+            stderr_tees, add_global_stderr_tees,
+            prompt_tees, add_global_prompt_tees,
+            echo, DEVNULL, DEVNULL
         )
 
+        if not (stdout_tees or stderr_tees or prompt_tees):
+            return
+
+        stdout_fds = {tee.fileno() for tee in stdout_tees}
+        stderr_fds = {tee.fileno() for tee in stderr_tees}
+        prompt_fds = {tee.fileno() for tee in prompt_tees}
+
+        if prompt_fds:
+            stream_prompts(prompt_fds, cmd, None, None, err2out, comment)
+
+        if stdout_fds:
+            with Tee(PIPE, stdout_fds, DEVNULL, encoding, errors, text) as tee:
+                tee.communicate(stdout)
+
+        if stderr_fds:
+            with Tee(PIPE, stderr_fds, DEVNULL, encoding, errors, text) as tee:
+                tee.communicate(stderr)
+
     def get_pids(self):
         """ Return the pid for all of the processes in the tree """
         output = run(
@@ -239,13 +273,13 @@ class Popen(subprocess.Popen):
 
     def terminate_tree(self):
         run(
-            ["sudo", "kill"] + self.get_pids(),
+            ["kill"] + self.get_pids(),
             stdin=DEVNULL, stdout=DEVNULL, stderr=DEVNULL,
         )
 
     def kill_tree(self):
         run(
-            ["sudo", "kill", "-9"] + self.get_pids(),
+            ["kill", "-9"] + self.get_pids(),
             stdin=DEVNULL, stdout=DEVNULL, stderr=DEVNULL,
         )
 
@@ -383,7 +417,7 @@ if subprocess.run(
         stderr=DEVNULL
     ).stdout.splitlines()[-2:]
 
-    def stream_prompts(fds: Iterable[str], cmd, cwd=None, env=None, err2out=False, comment=None):
+    def stream_prompts(fds: Iterable[int], cmd, cwd=None, env=None, err2out=False, comment=None):
         """ Write shell prompt and command into file descriptors fds """
         fds = normalize_outerr_fds(fds)
         custom_env = {"CPS1": PS1, "CPS2": PS2}
@@ -393,7 +427,7 @@ if subprocess.run(
             "(\n"
             "    IFS= read -r \"line\"\n"
             "    echo \"${CPS1@P}${line}\"\n"
-            "    while IFS= read line; do\n"
+            "    while IFS= read -r \"line\"; do\n"
             "        echo \"${CPS2@P}${line}\"\n"
             "    done\n"
             ") | " + quote(Tee.get_cmd(fds - {1}))
@@ -401,7 +435,7 @@ if subprocess.run(
         subprocess.run(
             ["bash", "-c", script],
             text=True,
-            input=shellify(cmd, err2out, comment),
+            input=shellify(cmd, err2out, comment) + "\n",
             stdout=None if 1 in fds else DEVNULL,
             stderr=None if 2 in fds else DEVNULL,
             pass_fds=fds - {1, 2},
@@ -410,7 +444,7 @@ if subprocess.run(
             check=True
         )
 else:  # Use hard-coded PS1 and PS2 strings
-    def stream_prompts(fds: Iterable[str], cmd, cwd=None, env=None, err2out=False, comment=None):
+    def stream_prompts(fds: Iterable[int], cmd, cwd=None, env=None, err2out=False, comment=None):
         """ Write shell prompt and command into file descriptors fds """
         cmd = shellify(cmd, err2out, comment) + "\n"
         input = "$ " + "> ".join(cmd.splitlines(keepends=True))
@@ -450,7 +484,7 @@ def _output_context(kwargs, key, encoding, errors, text):
 
 def run(
     args, *, input=None, capture_output=False, timeout=None, check=False,
-    encoding=None, errors=None, text=None, sigterm_timeout=10, **kwargs
+    encoding=None, errors=None, text=None, sigterm_timeout=10, comment=None, **kwargs
 ):
     """ A subprocess.run that instantiates this module's Popen """
     if input is not None:
@@ -464,7 +498,7 @@ def run(
         kwargs["stdout"] = FILE
         kwargs["stderr"] = FILE
 
-    comment = f"timeout={timeout}" if timeout else None
+    comment = " ".join((comment or "", f"timeout={timeout}" if timeout else "")).strip()
     with (
         _output_context(kwargs, "stdout", encoding, errors, text) as stdout_file,
         _output_context(kwargs, "stderr", encoding, errors, text) as stderr_file,

{iripau-0.1.0 → iripau-1.1.0}/iripau.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iripau
-Version: 0.1.0
+Version: 1.1.0
 Summary: Python utilities focused on command execution
 Author: Ricardo Quezada
 Maintainer: Ricardo Quezada
@@ -9,11 +9,12 @@ Project-URL: Repository, https://github.com/ricardo-galo/iripau
 Project-URL: Bug Tracker, https://github.com/ricardo-galo/iripau/issues
 Project-URL: Changelog, https://github.com/ricardo-galo/iripau/blob/master/CHANGELOG.md
 Keywords: subprocess,command,local,remote,ssh,Linux,real-time,log,logging,threading,utilities
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: curlify
 Requires-Dist: psutil
 Dynamic: license-file
 

{iripau-0.1.0 → iripau-1.1.0}/iripau.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ iripau/executable.py
 iripau/functools.py
 iripau/logging.py
 iripau/random.py
+iripau/requests.py
 iripau/shutil.py
 iripau/subprocess.py
 iripau/threading.py
@@ -19,6 +20,7 @@ tests/test_executable.py
 tests/test_functools.py
 tests/test_logging.py
 tests/test_random.py
+tests/test_requests.py
 tests/test_shutil.py
 tests/test_subprocess.py
 tests/test_threading.py

iripau-1.1.0/iripau.egg-info/requires.txt

@@ -0,0 +1,2 @@
+curlify
+psutil

{iripau-0.1.0 → iripau-1.1.0}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iripau"
-version = "0.1.0"
+version = "1.1.0"
 dependencies = [
+  "curlify",
   "psutil"
 ]
 requires-python = ">=3.7"
@@ -21,7 +22,7 @@ license = "MPL-2.0"
 license-files = ["LICENSE"]
 keywords = ["subprocess", "command", "local", "remote", "ssh", "Linux", "real-time", "log", "logging", "threading", "utilities"]
 classifiers = [
-  "Development Status :: 4 - Beta",
+  "Development Status :: 5 - Production/Stable",
   "Programming Language :: Python"
 ]
 

iripau-1.1.0/tests/test_requests.py

@@ -0,0 +1,72 @@
+"""
+Tests to validate iripau.requests module
+"""
+
+import pytest
+
+from iripau.requests import Session
+
+
+class TestRequests:
+
+    @pytest.mark.parametrize("hide_output", [False, True], ids=["show_output", "hide_output"])
+    @pytest.mark.parametrize("session_verify", [False, True], ids=["request", "session"])
+    @pytest.mark.parametrize("verify", [False, True], ids=["insecure", "secure"])
+    def test_curlify(self, verify, session_verify, hide_output, capfd):
+        session = Session()
+
+        if session_verify:
+            session.verify = verify
+
+        response = session.post(
+            "https://dummyjson.com/test",
+            verify=None if session_verify else verify,
+            headers={
+                "API-Key": "QWERTY123",
+                "Accept": "application/json",
+                "Authorization": "Bearer 23U746F5R23745RG78345EDR3"
+            },
+            data={
+                "name": "The Name",
+                "status": "Old$"
+            },
+            hide_output=hide_output,
+            headers_to_hide=["API-Key", "Authorization"],
+            headers_to_omit=["User-Agent", "Accept-Encoding", "Connection"],
+            echo=True
+        )
+
+        out, err = capfd.readouterr()
+        if verify:
+            assert "--insecure" not in out
+        else:
+            assert "--insecure" in out
+
+        if hide_output:
+            assert out.endswith("***\n")
+        else:
+            assert not out.endswith("***\n")
+
+        # Omitted headers
+        assert "-H 'Accept: application/json'" in out
+        assert "-H 'API-Key: ***'" in out
+        assert "-H 'Authorization: ***'" in out
+
+        # Hidden headers
+        assert "-H 'Accept-Encoding: gzip, deflate'" not in out
+        assert "-H 'Connection: keep-alive'" not in out
+        assert "-H 'User-Agent: python-requests/2.32.3'" not in out
+
+        # Because of using data argument in the request
+        assert "-H 'Content-Type: application/x-www-form-urlencoded'" in out
+        assert "-d 'name=The+Name&status=Old%24'" in out
+
+        assert not err
+
+        # The request object was not touched
+        assert "Accept-Encoding" in response.request.headers
+        assert "Connection" in response.request.headers
+        assert "User-Agent" in response.request.headers
+
+        assert response.request.headers["API-Key"] != "***"
+        assert response.request.headers["Authorization"] != "***"

{iripau-0.1.0 → iripau-1.1.0}/tests/test_subprocess.py

@@ -292,7 +292,8 @@ class TestSubprocess:
     @pytest.mark.parametrize("stderr", [None, STDOUT], ids=["no_redirect", "redirect"])
     @pytest.mark.parametrize("stdout", [None, PIPE, FILE], ids=["no_capture", "pipe", "file"])
     @pytest.mark.parametrize("echo", [False, True], ids=["no_echo", "echo"])
-    def test_run_tee(self, echo, stdout, stderr, extra_tees, manual_echo, capfd):
+    @pytest.mark.parametrize("simulation", [False, True], ids=["reality", "simulation"])
+    def test_run_tee(self, simulation, echo, stdout, stderr, extra_tees, manual_echo, capfd):
         redirect = stderr is STDOUT
         stdout_command = "echo This goes to stdout"
         stderr_command = "echo This goes to stderr >&2"
@@ -314,9 +315,6 @@ class TestSubprocess:
             stderr_tees.add(sys.stderr)
 
         kwargs = {
-            "stdout": stdout,
-            "stderr": stderr,
-            "shell": True,
             "text": True,
             "echo": echo,
             "stdout_tees": stdout_tees | all_tees,
@@ -324,21 +322,6 @@ class TestSubprocess:
             "prompt_tees": prompt_tees | all_tees
         }
 
-        expected_stdout_1 = expected_stderr_1 = expected_stdout_2 = expected_stderr_2 = None
-        if stdout is not None:
-            expected_stdout_1 = "This goes to stdout\n"
-            expected_stdout_2 = "This goes to stderr\n" if redirect else ""
-
-        count = 30
-        for _ in range(count):
-            output = run(stdout_command, **kwargs)
-            assert expected_stdout_1 == output.stdout
-            assert expected_stderr_1 == output.stderr
-
-            output = run(stderr_command, **kwargs)
-            assert expected_stdout_2 == output.stdout
-            assert expected_stderr_2 == output.stderr
-
         expected_stdout_command_prompt = get_prompt_and_command(stdout_command, redirect) + "\n"
         expected_stderr_command_prompt = get_prompt_and_command(stderr_command, redirect) + "\n"
         expected_prompt = expected_stdout_command_prompt + expected_stderr_command_prompt
@@ -352,8 +335,11 @@ class TestSubprocess:
             expected_stderr = ""
             if echo or manual_echo:
                 expected_captured_stdout = expected_output
+            elif stdout is None:
+                expected_captured_stdout = "" if simulation else expected_stdout
             else:
-                expected_captured_stdout = expected_stdout if stdout is None else ""
+                expected_captured_stdout = ""
+            expected_captured_stderr = ""
         else:
             expected_stdout = "This goes to stdout\n"
             expected_stderr = "This goes to stderr\n"
@@ -362,8 +348,48 @@ class TestSubprocess:
                     expected_stdout_command_prompt + "This goes to stdout\n" +
                     expected_stderr_command_prompt
                 )
+                expected_captured_stderr = expected_stderr
+            elif stdout is None:
+                if simulation:
+                    expected_captured_stdout = ""
+                    expected_captured_stderr = ""
+                else:
+                    expected_captured_stdout = expected_stdout
+                    expected_captured_stderr = expected_stderr
             else:
-                expected_captured_stdout = expected_stdout if stdout is None else ""
+                expected_captured_stdout = ""
+                expected_captured_stderr = "" if simulation else expected_stderr
+
+        count = 1
+        if simulation:
+            fake_stdout_command = stdout_command
+            fake_stderr_command = stderr_command
+            fake_stdout_1 = "This goes to stdout\n"
+            fake_stderr_1 = ""
+            fake_stdout_2 = ""
+            fake_stderr_2 = "This goes to stderr\n"
+            if redirect:  # Simulate redirection
+                fake_stdout_command += " 2>&1"
+                fake_stderr_command += " 2>&1"
+                fake_stdout_2, fake_stderr_2 = fake_stderr_2, fake_stdout_2
+
+            for _ in range(count):
+                Popen.simulate(fake_stdout_command, fake_stdout_1, fake_stderr_1, **kwargs)
+                Popen.simulate(fake_stderr_command, fake_stdout_2, fake_stderr_2, **kwargs)
+        else:
+            expected_stdout_1 = expected_stderr_1 = expected_stdout_2 = expected_stderr_2 = None
+            if stdout is not None:
+                expected_stdout_1 = "This goes to stdout\n"
+                expected_stdout_2 = "This goes to stderr\n" if redirect else ""
+
+            for _ in range(count):
+                output = run(stdout_command, stdout=stdout, stderr=stderr, shell=True, **kwargs)
+                assert expected_stdout_1 == output.stdout
+                assert expected_stderr_1 == output.stderr
+
+                output = run(stderr_command, stdout=stdout, stderr=stderr, shell=True, **kwargs)
+                assert expected_stdout_2 == output.stdout
+                assert expected_stderr_2 == output.stderr
 
         expected_content = expected_stdout * count
         for file in stdout_tees - {sys.stdout}:
@@ -383,7 +409,7 @@ class TestSubprocess:
 
         out, err = capfd.readouterr()
         assert expected_captured_stdout * count == out
-        assert expected_stderr * count == err
+        assert expected_captured_stderr * count == err
 
     @pytest.mark.parametrize("echo", [False, True], ids=["no_echo", "echo"])
     def test_run_alias(self, echo, capfd):

iripau-0.1.0/iripau.egg-info/requires.txt

@@ -1 +0,0 @@
-psutil