portforward 0.4.5__cp310-cp310-win_amd64.whl → 0.7.3__cp310-cp310-win_amd64.whl

portforward/__init__.py

@@ -0,0 +1,253 @@
+"""
+Easy Kubernetes Port-Forward For Python
+"""
+
+__version__ = "0.7.3"
+
+import asyncio
+import contextlib
+import ipaddress
+import os
+from enum import Enum
+from pathlib import Path
+from typing import Generator, Optional, Union
+
+from portforward import _portforward
+
+
+class PortforwardError(Exception):
+    """Will be raised when something went wrong while the port-forward process."""
+
+
+class LogLevel(Enum):
+    DEBUG = 0
+    INFO = 1
+    WARN = 2
+    ERROR = 3
+    OFF = 4
+
+
+@contextlib.contextmanager
+def forward(
+    namespace: str,
+    pod_or_service: str,
+    from_port: int,
+    to_port: int,
+    config_path: Optional[str] = None,
+    waiting: float = 0.1,
+    log_level: LogLevel = LogLevel.INFO,
+    kube_context: str = "",
+    bind_ip: Union[ipaddress.IPv4Address, ipaddress.IPv6Address, str, None] = None,
+) -> Generator["PortForwarder", None, None]:
+    """
+    Connects to a **pod or service** and tunnels traffic from a local port to
+    this target. It uses the kubectl kube config from the home dir if no path
+    is provided.
+
+    The libary will figure out for you if it has to target a pod or service.
+
+    It will fall back to in-cluster-config in case no kube config file exists.
+
+    (Best consumed as context manager.)
+
+    Example:
+        >>> import portforward
+        >>> with portforward.forward("test", "web-svc", 9000, 80):
+        >>>     # Do work
+
+    :param namespace: Target namespace
+    :param pod_or_service: Name of target Pod or service
+    :param from_port: Local port, or 0 to use any free port
+    :param to_port: Port inside the pod
+    :param config_path: Path for loading kube config
+    :param waiting: Delay in seconds
+    :param log_level: Level of logging
+    :param kube_context: Target kubernetes context (fallback is current context)
+    :param bind_ip: To which IP shall the portforward be bind
+    :return: forwarder to manual stop the forwarding
+    """
+
+    forwarder = PortForwarder(
+        namespace,
+        pod_or_service,
+        from_port,
+        to_port,
+        config_path,
+        waiting,
+        log_level,
+        kube_context,
+        bind_ip,
+    )
+
+    try:
+        forwarder.forward()
+
+        yield forwarder
+
+    except RuntimeError as err:
+        # Suppress extension exception
+        raise PortforwardError(err) from None
+
+    finally:
+        forwarder.stop()
+
+
+class PortForwarder:
+    """Use the same args as the `portforward.forward` method."""
+
+    def __init__(
+        self,
+        namespace: str,
+        pod_or_service: str,
+        from_port: int,
+        to_port: int,
+        config_path: Optional[str] = None,
+        waiting: float = 0.1,
+        log_level: LogLevel = LogLevel.INFO,
+        kube_context: str = "",
+        bind_ip: Union[ipaddress.IPv4Address, ipaddress.IPv6Address, str, None] = None,
+    ) -> None:
+        self._async_forwarder = AsyncPortForwarder(
+            namespace,
+            pod_or_service,
+            from_port,
+            to_port,
+            config_path,
+            waiting,
+            log_level,
+            kube_context,
+            bind_ip,
+        )
+
+    def forward(self):
+        asyncio.run(self._async_forwarder.forward())
+
+    def stop(self):
+        asyncio.run(self._async_forwarder.stop())
+
+    @property
+    def is_stopped(self):
+        return self._async_forwarder.is_stopped
+
+    @property
+    def from_port(self):
+        """The local port that was actually used for the portforward."""
+        return self._async_forwarder.from_port
+
+
+class AsyncPortForwarder:
+    """Use the same args as the `portforward.forward` method."""
+
+    def __init__(
+        self,
+        namespace: str,
+        pod_or_service: str,
+        from_port: int,
+        to_port: int,
+        config_path: Optional[str] = None,
+        waiting: float = 0.1,
+        log_level: LogLevel = LogLevel.INFO,
+        kube_context: str = "",
+        bind_ip: Union[ipaddress.IPv4Address, ipaddress.IPv6Address, str, None] = None,
+    ) -> None:
+        self.namespace: str = _validate_str("namespace", namespace)
+        self.pod_or_service: str = _validate_str("pod_or_service", pod_or_service)
+        self.to_port: int = _validate_port("to_port", to_port)
+        self.log_level: LogLevel = _validate_log(log_level)
+        self.waiting: float = waiting
+
+        self.config_path: str = _config_path(config_path)
+        self.kube_context: str = _kube_context(kube_context)
+
+        _validate_port("from_port", from_port)
+        bind_ip = _validate_ip_address(bind_ip)
+
+        self.actual_pod_name: str = ""
+        self.from_port: int = 0
+        self._is_stopped: bool = False
+        self.bind_address: str = f"{bind_ip}:{from_port}"
+
+    async def forward(self):
+        (self.actual_pod_name, self.from_port) = await _portforward.forward(
+            self.namespace,
+            self.pod_or_service,
+            self.bind_address,
+            self.to_port,
+            self.config_path,
+            self.log_level.value,
+            self.kube_context,
+        )
+        self._is_stopped = False
+
+    async def stop(self):
+        await _portforward.stop(
+            self.namespace, self.actual_pod_name, self.to_port, self.log_level.value
+        )
+        self._is_stopped = True
+
+    def is_stopped(self):
+        return self._is_stopped
+
+
+# ===== PRIVATE =====
+
+
+def _validate_str(arg_name, arg) -> str:
+    if arg is None or not isinstance(arg, str):
+        raise ValueError(f"{arg_name}={arg} is not a valid str")
+
+    if len(arg) == 0:
+        raise ValueError(f"{arg_name} cannot be an empty str")
+
+    return arg
+
+
+def _validate_port(arg_name, arg) -> int:
+    in_range = arg is not None and 0 <= arg < 65536
+    if arg is None or not isinstance(arg, int) or not in_range:
+        raise ValueError(f"{arg_name}={arg} is not a valid port")
+
+    return arg
+
+
+def _validate_log(log_level):
+    if not isinstance(log_level, LogLevel):
+        raise ValueError(f"log_level={log_level} is not a valid LogLevel")
+
+    return log_level
+
+
+def _validate_ip_address(ip_address):
+    if not ip_address:
+        return "127.0.0.1"
+
+    if isinstance(ip_address, ipaddress.IPv4Address) or isinstance(
+        ip_address, ipaddress.IPv4Address
+    ):
+        return str(ip_address)
+
+    return str(ipaddress.ip_address(ip_address))
+
+
+def _config_path(config_path_arg) -> str:
+    if config_path_arg and not isinstance(config_path_arg, str):
+        raise ValueError(f"config_path={config_path_arg} is not a valid str")
+
+    elif config_path_arg:
+        return config_path_arg
+
+    alt_path = str(Path.home() / ".kube" / "config")
+
+    config_path = os.environ.get("KUBECONFIG", alt_path)
+
+    return config_path if os.path.isfile(config_path) else ""
+
+
+def _kube_context(context):
+    if not context:
+        return ""
+
+    if not isinstance(context, str):
+        raise ValueError(f"kube_context={context} is not a valid str")
+
+    return context

portforward/_portforward.pyi

@@ -0,0 +1,17 @@
+"""
+Rust native module / Python C Extension
+"""
+
+async def forward(
+    namespace: str,
+    pod_or_service: str,
+    bind_address: str,
+    to_port: int,
+    config_path: str,
+    log_level: int,
+    kube_context: str,
+) -> None:
+    pass
+
+async def stop(namespace: str, actual_pod: str, to_port: int, log_level: int) -> None:
+    pass

portforward-0.7.3.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: portforward
+Version: 0.7.3
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+License-File: LICENSE
+License-File: AUTHORS.rst
+Summary: Easy Kubernetes Port-Forward For Python
+Keywords: portforward,kubernetes,k8s
+Author-email: Sebastian Ziemann <corka149@mailbox.org>
+License: MIT License
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst; charset=UTF-8
+Project-URL: Documentation, https://portforward.readthedocs.io
+Project-URL: Repository, https://github.com/pytogo/portforward.git
+Project-URL: Changelog, https://github.com/pytogo/portforward/blob/main/HISTORY.rst
+
+===========
+portforward
+===========
+
+
+.. image:: https://img.shields.io/pypi/v/portforward.svg
+        :target: https://pypi.python.org/pypi/portforward
+
+.. image:: https://img.shields.io/pypi/status/portforward.svg
+        :target: https://pypi.python.org/pypi/portforward
+
+.. image:: https://img.shields.io/pypi/dm/portforward
+        :alt: PyPI - Downloads
+
+.. image:: https://readthedocs.org/projects/portforward/badge/?version=latest
+        :target: https://portforward.readthedocs.io/en/latest/?version=latest
+        :alt: Documentation Status
+
+.. image:: https://github.com/pytogo/portforward/actions/workflows/python-app.yml/badge.svg
+        :target: https://github.com/pytogo/portforward/actions
+        :alt: Build status
+
+
+
+Easy Kubernetes Port-Forward For Python
+
+
+* Free software: MIT license
+* Documentation: https://portforward.readthedocs.io.
+
+
+Installation
+-----------------------------
+
+Wheels are available for:
+
+* **Windows** (architectures: ``x64``, ``x86``)
+* **macOS**   (architectures: ``x86_64``, ``aarch64``)
+* **Linux**   (architectures: ``x86_64``, ``x86``, ``aarch64``, ``armv7``, ``s390x``, ``ppc64le``)
+
+Musllinux wheels (Alpine‑compatible) are provided for ``x86_64``, ``x86``, ``aarch64`` and ``armv7``.
+
+with Python versions:
+
+* 3.9
+* 3.10
+* 3.11
+* 3.12
+* 3.13
+
+**Requirements for installation from source**
+
+The following things are required when there is no wheel available for the target system.
+
+* `Rust` installed and available in the path (https://www.rust-lang.org/tools/install)
+* `Python` (at least v3.7 - below was never tested but might work)
+
+Pip knows how to install ``portforward``.
+
+.. code-block::
+
+    pip install portforward
+
+
+Quickstart
+----------
+
+.. code-block:: Python
+
+    import requests
+
+    import portforward
+
+
+    def main():
+        namespace = "test"
+        pod_name = "web"  # You can also use a service name instead
+        local_port = 9000  # from port
+        pod_port = 80  # to port
+
+        # No path to kube config provided - will use default from $HOME/.kube/config
+        with portforward.forward(namespace, pod_name, local_port, pod_port):
+            response = requests.get("http://localhost:9000")
+            print(f"Done: \n'{response.status_code}'\n'{response.text[:20]}...'")
+
+
+    if __name__ == "__main__":
+        main()
+
+
+Features
+--------
+
+* Native Kubernetes port-forwarding with the ``.kube/config`` from the home dir
+  or any other path to config.
+* Portforward for pods and services - the lib will first look for a pod with matching name then for
+  a service
+* Waiting for a pod to become ready
+* Multiple forwards per pod or service
+* As context manager, sync or async client
+
+
+Development
+-----------
+
+In case you want to develop on this library itself please take a look at the CONTRIBUTING page.
+
+Credits
+-------
+
+This project is enabled by PyO3_.
+
+.. _PyO3: https://pyo3.rs
+

portforward-0.7.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+portforward-0.7.3.dist-info/METADATA,sha256=fg1fMNa7rbi-Z19mWoBvQ0GpmyJL9c6OT63ZZmvV72w,4029
+portforward-0.7.3.dist-info/WHEEL,sha256=77DqkvxB4HqZitBRK_M49NRS207JKb0MotMEjnxEWQ8,96
+portforward-0.7.3.dist-info/licenses/LICENSE,sha256=_-nf_xCZIwUkKBXXiYR-fjbXGhmx6V-7b3jSKoolnO4,1096
+portforward-0.7.3.dist-info/licenses/AUTHORS.rst,sha256=mskf9O-AvJL9NxWUYX0nJRuLfBw7SH-T-H-pPYLW-xI,176
+portforward/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+portforward/_portforward.pyi,sha256=UDGuRjzq4fFH2vyVMKGpsBQvYq8MK0LfFsM1FxljTX4,353
+portforward/__init__.py,sha256=vnkQ8n7alOiNHEjhxcRQTfZlZBkashXrRv74NpDwexA,7125
+portforward/_portforward.cp310-win_amd64.pyd,sha256=4D8s-t167eK14DE42J4sSqn4Nw60QkYHekqssCnbXJM,11387904
+portforward-0.7.3.dist-info/RECORD,,

{portforward-0.4.5.dist-info → portforward-0.7.3.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: maturin (1.8.3)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64
-

_portforward.h

@@ -1,83 +0,0 @@
-/* Code generated by cmd/cgo; DO NOT EDIT. */
-
-/* package github.com/pytogo/portforward */
-
-
-#line 1 "cgo-builtin-export-prolog"
-
-#include <stddef.h> /* for ptrdiff_t below */
-
-#ifndef GO_CGO_EXPORT_PROLOGUE_H
-#define GO_CGO_EXPORT_PROLOGUE_H
-
-#ifndef GO_CGO_GOSTRING_TYPEDEF
-typedef struct { const char *p; ptrdiff_t n; } _GoString_;
-#endif
-
-#endif
-
-/* Start of preamble from import "C" comments.  */
-
-
-#line 3 "main.go"
- #include <Python.h>
- int PyArg_ParseTuple_ssiisis(PyObject* args, char** a, char** b, int* c, int* d, char** e, int* f, char** g);
- int PyArg_ParseTuple_ss(PyObject*, char**, char**);
- void raise_exception(char *msg);
-
-#line 1 "cgo-generated-wrapper"
-
-
-/* End of preamble from import "C" comments.  */
-
-
-/* Start of boilerplate cgo prologue.  */
-#line 1 "cgo-gcc-export-header-prolog"
-
-#ifndef GO_CGO_PROLOGUE_H
-#define GO_CGO_PROLOGUE_H
-
-typedef signed char GoInt8;
-typedef unsigned char GoUint8;
-typedef short GoInt16;
-typedef unsigned short GoUint16;
-typedef int GoInt32;
-typedef unsigned int GoUint32;
-typedef long long GoInt64;
-typedef unsigned long long GoUint64;
-typedef GoInt64 GoInt;
-typedef GoUint64 GoUint;
-typedef __SIZE_TYPE__ GoUintptr;
-typedef float GoFloat32;
-typedef double GoFloat64;
-typedef float _Complex GoComplex64;
-typedef double _Complex GoComplex128;
-
-/*
-  static assertion to make sure the file is being used on architecture
-  at least with matching size of GoInt.
-*/
-typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
-
-#ifndef GO_CGO_GOSTRING_TYPEDEF
-typedef _GoString_ GoString;
-#endif
-typedef void *GoMap;
-typedef void *GoChan;
-typedef struct { void *t; void *v; } GoInterface;
-typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
-
-#endif
-
-/* End of boilerplate cgo prologue.  */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern __declspec(dllexport) PyObject* forward(PyObject* self, PyObject* args);
-extern __declspec(dllexport) PyObject* stop(PyObject* self, PyObject* args);
-
-#ifdef __cplusplus
-}
-#endif

portforward-0.4.5.dist-info/METADATA

@@ -1,253 +0,0 @@
-Metadata-Version: 2.1
-Name: portforward
-Version: 0.4.5
-Summary: Kubernetes Port-Forward Go-Edition For Python 
-Home-page: https://github.com/pytogo/portforward
-Author: Sebastian Ziemann
-Author-email: corka149@mailbox.org
-License: MIT license
-Keywords: portforward
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.6
-License-File: LICENSE
-License-File: AUTHORS.rst
-
-===========
-portforward
-===========
-
-
-.. image:: https://img.shields.io/pypi/v/portforward.svg
-        :target: https://pypi.python.org/pypi/portforward
-
-.. image:: https://img.shields.io/pypi/status/portforward.svg
-        :target: https://pypi.python.org/pypi/portforward
-
-.. image:: https://img.shields.io/pypi/dm/portforward
-        :alt: PyPI - Downloads
-
-.. image:: https://readthedocs.org/projects/portforward/badge/?version=latest
-        :target: https://portforward.readthedocs.io/en/latest/?version=latest
-        :alt: Documentation Status
-
-.. image:: https://github.com/pytogo/portforward/actions/workflows/python-app.yml/badge.svg
-        :target: https://github.com/pytogo/portforward/actions
-        :alt: Build status
-
-
-
-Kubernetes Port-Forward Go-Edition For Python
-
-
-* Free software: MIT license
-* Documentation: https://portforward.readthedocs.io.
-
-
-Installation
------------------------------
-
-Wheels are available for:
-
-* Windows
-* MacOS X
-* Linux
-
-with Python versions:
-
-* 3.6
-* 3.7
-* 3.8
-* 3.9
-* 3.10
-* 3.11
-
-and architectures:
-
-* x84_64
-* arm64 (known as M1/Apple Chip - MacOS only)
-
-**Requirements for installation from source**
-
-The following things are required when there is no wheel available for the target system.
-
-* `Go` installed and available in the path (at least v1.16 / https://go.dev)
-* `Python` (at least v3.6 - below was never tested but might work)
-* `gcc` (for Windows available via MinGW)
-
-Pip knows how to install ``portforward``.
-
-.. code-block::
-
-    pip install portforward
-
-
-Quickstart
-----------
-
-.. code-block:: Python
-
-    import requests
-
-    import portforward
-
-
-    def main():
-        namespace = "test"
-        pod_name = "web"  # You can also use a service name instead
-        local_port = 9000  # from port
-        pod_port = 80  # to port
-
-        # No path to kube config provided - will use default from $HOME/.kube/config
-        with portforward.forward(namespace, pod_name, local_port, pod_port):
-            response = requests.get("http://localhost:9000")
-            print(f"Done: \n'{response.status_code}'\n'{response.text[:20]}...'")
-
-
-    if __name__ == "__main__":
-        main()
-
-
-Features
---------
-
-* Go native Kubernetes port-forwarding with the ``.kube/config`` from the home dir
-  or any other path to config.
-* Portforward for pods and services - the lib will first look for a pod with matching name then for
-  a service
-* Waiting for a pod to become ready
-
-
-Development
------------
-
-In case you want to develop on this library itself please take a look at the CONTRIBUTING page.
-
-Credits
--------
-
-This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template.
-
-.. _Cookiecutter: https://github.com/audreyr/cookiecutter
-.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage
-
-This project is enabled by setuptools-golang_.
-
-.. _setuptools-golang: https://github.com/asottile/setuptools-golang
-
-
-=======
-History
-=======
-
-unreleased
-----------
-* Move pytogo Go code into portforward
-
-0.4.5 (2023-03-06)
-------------------
-* Fix panic when logging an error
-* Change default log level to INFO
-
-0.4.4 (2023-02-28)
-------------------
-* Fix endless waiting
-
-0.4.3 (2023-02-27)
-------------------
-* Throw error instead of panic when port is in usage
-
-0.4.2 (2023-02-06)
-------------------
-* Use in-cluster-config when no kube config file is available
-
-0.4.1 (2023-02-01)
-------------------
-* Bump pytogo/portforward version
-
-0.4.0 (2023-01-31)
-------------------
-* Respect environment variable KUBECONFIG
-* Wait if a pod is not ready yet
-* Be able to use service as targets
-
-0.3.1 (2022-12-26)
-------------------
-* Allow selecting kubernetes target context
-
-0.3.0 (2022-10-08)
-------------------
-* Introduction of logging level as replacement for verbose mode
-
-
-0.2.8 (2022-08-22)
-------------------
-* Added verbose mode
-
-
-0.2.7 (2021-10-05)
-------------------
-* Added missing import
-* Added type hint
-
-
-0.2.6 (2021-10-05)
-------------------
-* Fixed type hint
-
-
-0.2.5 (2021-09-09)
-------------------
-* Moved the actual portforward to own module
-
-
-0.2.4 (2021-08-23)
-------------------
-* Added adal import for Azure AD
-* Fixed host IPs with paths
-* Made timeout flexible
-
-
-0.2.3 (2021-08-23)
-------------------
-* Fixed case when hostIP contains a path
-* Added common and cloud provider auth plugins
-
-
-0.2.2 (2021-08-23)
-------------------
-* Fixed missing module ``portforward``
-
-
-0.2.1 (2021-08-19)
-------------------
-* Decrease binary size if pre-compile wheels
-  (Improvement of setuptools-golang)
-
-
-0.2.0 (2021-08-14)
-------------------
-
-* First Release on PyPI.
-* Made path to kube config variable.
-* Port-forwarding became non-blocking.
-* Fixed verification bug when port was None.
-* Added throwing own error.
-
-
-0.1.0 (2021-08-09)
-------------------
-
-* First release on Test PyPI.
-* Blocking port-forward with fixed path for kube config.
-
-

portforward-0.4.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-_portforward.h,sha256=wn0Tm3bPAOHG6L557oNDRHT_UA4BKVVsGABd6I3UFRA,2000
-_portforward.pyd,sha256=odPiw0p-bx5tP9xvlRPHOMM30nSwtKIwtrCH0uKeOHA,29420544
-portforward.py,sha256=DfewcHuSNi1wJxt-VWL7NrfqwXZeInyFEEvxx_0qV_k,4160
-portforward-0.4.5.dist-info/AUTHORS.rst,sha256=mskf9O-AvJL9NxWUYX0nJRuLfBw7SH-T-H-pPYLW-xI,176
-portforward-0.4.5.dist-info/LICENSE,sha256=_-nf_xCZIwUkKBXXiYR-fjbXGhmx6V-7b3jSKoolnO4,1096
-portforward-0.4.5.dist-info/METADATA,sha256=SDIreNr1wiRqPoFZ2Z7rwMUMzG-MrSxrt-VmYFyYuqY,5720
-portforward-0.4.5.dist-info/WHEEL,sha256=W26pYN7HLsBT1jrDSL9udgf_mdNKJmYmL23sIP-FcgM,102
-portforward-0.4.5.dist-info/top_level.txt,sha256=exoD3EZ-bCCtxQBQLSjSOZet0334F_dpAGxXr8XhWUA,25
-portforward-0.4.5.dist-info/RECORD,,

portforward-0.4.5.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-_portforward
-portforward

portforward.py

@@ -1,150 +0,0 @@
-"""
-Kubernetes Port-Forward Go-Edition For Python
-"""
-
-__version__ = "0.4.5"
-
-import contextlib
-import os
-import time
-from enum import Enum
-from pathlib import Path
-from typing import Generator, Optional
-
-import _portforward
-
-
-class PortforwardError(Exception):
-    """Will be raised when something went wrong while the port-forward process."""
-
-
-class LogLevel(Enum):
-    DEBUG = 0
-    INFO = 1
-    WARN = 2
-    ERROR = 3
-    OFF = 4
-
-
-@contextlib.contextmanager
-def forward(
-    namespace: str,
-    pod_or_service: str,
-    from_port: int,
-    to_port: int,
-    config_path: Optional[str] = None,
-    waiting: float = 0.1,
-    log_level: LogLevel = LogLevel.INFO,
-    kube_context: str = "",
-) -> Generator[None, None, None]:
-    """
-    Connects to a **pod or service** and tunnels traffic from a local port to this target.
-    It uses the kubectl kube config from the home dir if no path is provided.
-
-    The libary will figure out for you if it has to target a pod or service.
-
-    It will fall back to in-cluster-config in case no kube config file exists.
-
-    Caution: Go and the port-forwarding needs some ms to be ready. ``waiting``
-    can be used to wait until the port-forward is ready.
-
-    (Best consumed as context manager.)
-
-    Example:
-        >>> import portforward
-        >>> with portforward.forward("test", "web-svc", 9000, 80):
-        >>>     # Do work
-
-    :param namespace: Target namespace
-    :param pod_or_service: Name of target Pod or service
-    :param from_port: Local port
-    :param to_port: Port inside the pod
-    :param config_path: Path for loading kube config
-    :param waiting: Delay in seconds
-    :param log_level: Level of logging
-    :param kube_context: Target kubernetes context (fallback is current context)
-    :return: None
-    """
-
-    _validate_str("namespace", namespace)
-    _validate_str("pod_or_service", pod_or_service)
-
-    _validate_port("from_port", from_port)
-    _validate_port("to_port", to_port)
-
-    _validate_log(log_level)
-
-    config_path = _config_path(config_path)
-
-    kube_context = kube_context if kube_context else ""
-    _kube_context(kube_context)
-
-    try:
-        _portforward.forward(
-            namespace,
-            pod_or_service,
-            from_port,
-            to_port,
-            config_path,
-            log_level.value,
-            kube_context,
-        )
-
-        # Go and the port-forwarding needs some ms to be ready
-        time.sleep(waiting)
-
-        yield None
-
-    except RuntimeError as err:
-        # Suppress extension exception
-        raise PortforwardError(err) from None
-
-    finally:
-        _portforward.stop(namespace, pod_or_service)
-
-
-# ===== PRIVATE =====
-
-
-def _validate_str(arg_name, arg):
-    if arg is None or not isinstance(arg, str):
-        raise ValueError(f"{arg_name}={arg} is not a valid str")
-
-    if len(arg) == 0:
-        raise ValueError(f"{arg_name} cannot be an empty str")
-
-    if "/" in arg:
-        raise ValueError(f"{arg_name} contains illegal character '/'")
-
-
-def _validate_port(arg_name, arg):
-    in_range = arg and 0 < arg < 65536
-    if arg is None or not isinstance(arg, int) or not in_range:
-        raise ValueError(f"{arg_name}={arg} is not a valid port")
-
-
-def _validate_log(log_level):
-    if not isinstance(log_level, LogLevel):
-        raise ValueError(f"log_level={log_level} is not a valid LogLevel")
-
-
-def _config_path(config_path_arg) -> str:
-    if config_path_arg and not isinstance(config_path_arg, str):
-        raise ValueError(f"config_path={config_path_arg} is not a valid str")
-
-    elif config_path_arg:
-        return config_path_arg
-
-    alt_path = str(Path.home() / ".kube" / "config")
-
-    config_path = os.environ.get("KUBECONFIG", alt_path)
-
-    return config_path if os.path.isfile(config_path) else ""
-
-
-def _kube_context(arg):
-    if arg is None or not isinstance(arg, str):
-        raise ValueError(f"kube_context={arg} is not a valid str")
-
-    if "/" in arg:
-        raise ValueError(f"kube_context contains illegal character '/'")