pypsrp 0.8.1__py3-none-any.whl → 0.9.0rc2__py3-none-any.whl

pypsrp/_pool_manager.py

@@ -0,0 +1,142 @@
+# Copyright: (c) 2026, Jordan Borean (@jborean93) <jborean93@gmail.com>
+# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
+
+from __future__ import annotations
+
+import contextvars
+import functools
+import types
+import typing as t
+
+import requests.adapters
+from requests.packages.urllib3.util.retry import Retry
+
+T = t.TypeVar("T")
+
+
+class NewConnectionDisabled(Exception):
+    """Raised when new connections are being made but have been disabled in the current context."""
+
+
+class DisableNewConnectionsContext:
+    """Context manager to disable new connections from being created."""
+
+    __slots__ = "_contextvar_token"
+
+    _contextvar: t.ClassVar[contextvars.ContextVar] = contextvars.ContextVar("NewConnectionContext")
+    _contextvar_token: contextvars.Token
+
+    @classmethod
+    def current(cls) -> DisableNewConnectionsContext | None:
+        """Returns the current context or None if not set."""
+        try:
+            return cls._contextvar.get()
+        except LookupError:
+            return None
+
+    def __enter__(self) -> DisableNewConnectionsContext:
+        self._contextvar_token = self.__class__._contextvar.set(self)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        self.__class__._contextvar.reset(self._contextvar_token)
+        del self._contextvar_token
+
+        return None
+
+
+class HTTPSAdapterWithKeyPassword(requests.adapters.HTTPAdapter):
+
+    def __init__(
+        self,
+        *args: t.Any,
+        _pypsrp_key_password: str | None = None,
+        **kwargs: t.Any,
+    ) -> None:
+        self.__key_password = _pypsrp_key_password
+        super().__init__(*args, **kwargs)
+
+    def init_poolmanager(
+        self,
+        connections,
+        maxsize,
+        block=False,
+        **pool_kwargs,
+    ):
+        return super().init_poolmanager(
+            connections,
+            maxsize,
+            block,
+            key_password=self.__key_password,
+            **pool_kwargs,
+        )
+
+
+def _wrap(
+    func: t.Callable[..., T],
+    *,
+    before: t.Callable[[], None] | None = None,
+    after: t.Callable[[T], None] | None = None,
+) -> t.Callable[..., T]:
+    """Wraps a function with before and after callables."""
+
+    @functools.wraps(func)
+    def wrapper(*args: t.Any, **kwargs: t.Any) -> T:
+        if before:
+            before()
+
+        res = func(*args, **kwargs)
+
+        if after:
+            after(res)
+
+        return res
+
+    return wrapper
+
+
+def _raise_if_connections_disabled():
+    if DisableNewConnectionsContext.current() is not None:
+        raise NewConnectionDisabled()
+
+
+def _create_new_connection_with_failure(connection):
+    connection.connect = _wrap(connection.connect, before=_raise_if_connections_disabled)
+
+
+def _create_connection_pool(pool):
+    # This is called in the urllib3 pool when a new connection is needed. We
+    # wrap it so we can wrap the connect method when a new connection is
+    # created.
+    pool.ConnectionCls = _wrap(pool.ConnectionCls, after=_create_new_connection_with_failure)
+
+
+def create_request_adapter(  # type: ignore[no-any-unimported]  # requests does not have typing stubs for urllib3
+    *,
+    max_retries: Retry,
+    key_password: str | None = None,
+) -> requests.adapters.HTTPAdapter:
+    """Creates a HTTPAdapter with support for disabling new connections via context."""
+    adapter: requests.adapters.HTTPAdapter
+    if key_password is not None:
+        adapter = HTTPSAdapterWithKeyPassword(
+            max_retries=max_retries,
+            _pypsrp_key_password=key_password,
+        )
+    else:
+        adapter = requests.adapters.HTTPAdapter(max_retries=max_retries)
+
+    # pool_classes_by_scheme stores the urllib3 pool types used when creating
+    # the connection pool for http/https. We wrap the __init__ method so we can
+    # inject our custom ConnectionCls that wraps the connect method when
+    # created.
+    pool_classes = adapter.poolmanager.pool_classes_by_scheme
+    for scheme, pool_cls in list(pool_classes.items()):
+        pool_classes[scheme] = _wrap(pool_cls, after=_create_connection_pool)
+
+    return adapter

pypsrp/_utils.py

@@ -107,7 +107,6 @@ def get_pwsh_script(name: str) -> str:
     block_comment = False
     new_lines = []
     for line in script.splitlines():
-
         line = line.strip()
         if block_comment:
             block_comment = not line.endswith("#>")

pypsrp/client.py

@@ -15,7 +15,6 @@ import warnings
 import xml.etree.ElementTree as ET
 
 from pypsrp._utils import get_pwsh_script, to_bytes, to_unicode
-from pypsrp.complex_objects import ComplexObject
 from pypsrp.exceptions import WinRMError
 from pypsrp.powershell import (
     DEFAULT_CONFIGURATION_NAME,

pypsrp/complex_objects.py

@@ -139,7 +139,7 @@ class Enum(ComplexObject):
         self.value = kwargs.get("value")
 
     @property  # type: ignore[override]
-    def _to_string(self) -> str:  # type: ignore[override]
+    def _to_string(self) -> str:
         try:
             return self._string_map[self.value or 0]
         except KeyError as err:
@@ -378,7 +378,7 @@ class RemoteStreamOptions(Enum):
         )
 
     @property  # type: ignore[override]
-    def _to_string(self) -> str:  # type: ignore[override]
+    def _to_string(self) -> str:
         if self.value == 15:
             return "AddInvocationInfo"
 
@@ -1149,7 +1149,7 @@ class CommandType(Enum):
         super(CommandType, self).__init__("System.Management.Automation.CommandTypes", {}, **kwargs)
 
     @property  # type: ignore[override]
-    def _to_string(self) -> str:  # type: ignore[override]
+    def _to_string(self) -> str:
         if self.value == 0x01FF:
             return "All"
 

pypsrp/encryption.py

@@ -10,7 +10,6 @@ log = logging.getLogger(__name__)
 
 
 class WinRMEncryption(object):
-
     SIXTEEN_KB = 16384
     MIME_BOUNDARY = "--Encrypted Boundary"
     CREDSSP = "application/HTTP-CredSSP-session-encrypted"

pypsrp/messages.py

@@ -127,7 +127,8 @@ class Message(object):
         ):
             msg = ET.Element("S")
         else:
-            msg = self._serializer.serialize(self.data) or b""
+            serialized_msg = self._serializer.serialize(self.data)
+            msg = serialized_msg if serialized_msg is not None else b""
 
         if not isinstance(msg, bytes):
             message_data = ET.tostring(msg, encoding="utf-8", method="xml")
@@ -155,7 +156,7 @@ class Message(object):
         rpid = str(uuid.UUID(bytes_le=data[8:24]))
         pid = str(uuid.UUID(bytes_le=data[24:40]))
 
-        if data[40:43] == b"\xEF\xBB\xBF":
+        if data[40:43] == b"\xef\xbb\xbf":
             # 40-43 is the UTF-8 BOM which we don't care about
             message_data = to_string(data[43:])
         else:

pypsrp/negotiate.py

@@ -11,7 +11,6 @@ import spnego
 import spnego.channel_bindings
 from cryptography import x509
 from cryptography.exceptions import UnsupportedAlgorithm
-from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes
 from requests.auth import AuthBase
 from requests.packages.urllib3.response import HTTPResponse
@@ -37,7 +36,7 @@ class HTTPNegotiateAuth(AuthBase):
         password: typing.Optional[str] = None,
         auth_provider: str = "negotiate",
         send_cbt: bool = True,
-        service: str = "WSMAN",
+        service: str = "host",
         delegate: bool = False,
         hostname_override: typing.Optional[str] = None,
         wrap_required: bool = False,
@@ -61,7 +60,7 @@ class HTTPNegotiateAuth(AuthBase):
         :param send_cbt: Try to bind the channel token (HTTPS only) to the auth
             process, default is True
         :param service: The service part of the SPN to authenticate with,
-            defaults to HTTP
+            defaults to host
         :param delegate: Whether to get an auth token that allows the token to
             be delegated to other servers, this is only used with Kerberos and
             defaults to False
@@ -257,9 +256,7 @@ class HTTPNegotiateAuth(AuthBase):
         :return: The byte string containing the hash of the server's
             certificate
         """
-        backend = default_backend()
-
-        cert = x509.load_der_x509_certificate(certificate_der, backend)
+        cert = x509.load_der_x509_certificate(certificate_der)
 
         hash_algorithm = None
         try:
@@ -273,9 +270,9 @@ class HTTPNegotiateAuth(AuthBase):
         # If the cert signature algorithm is unknown, md5, or sha1 then use sha256 otherwise use the signature
         # algorithm of the cert itself.
         if not hash_algorithm or hash_algorithm.name in ["md5", "sha1"]:
-            digest = hashes.Hash(hashes.SHA256(), backend)
+            digest = hashes.Hash(hashes.SHA256())
         else:
-            digest = hashes.Hash(hash_algorithm, backend)
+            digest = hashes.Hash(hash_algorithm)
 
         digest.update(certificate_der)
         certificate_hash = digest.finalize()

pypsrp/powershell.py

@@ -1,6 +1,8 @@
 # Copyright: (c) 2018, Jordan Borean (@jborean93) <jborean93@gmail.com>
 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
 
+from __future__ import annotations
+
 import base64
 import logging
 import struct
@@ -11,10 +13,11 @@ import uuid
 import warnings
 import xml.etree.ElementTree as ET
 
-from cryptography.hazmat.backends import default_backend
+import requests.exceptions
 from cryptography.hazmat.primitives.asymmetric import padding, rsa
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 
+from pypsrp import _pool_manager
 from pypsrp._utils import version_equal_or_newer
 from pypsrp.complex_objects import (
     ApartmentState,
@@ -103,6 +106,9 @@ class RunspacePool(object):
         min_runspaces: int = 1,
         max_runspaces: int = 1,
         session_key_timeout_ms: int = 60000,
+        *,
+        no_profile: bool = False,
+        idle_timeout: int | None = None,
     ) -> None:
         """
         Represents a Runspace pool on a remote host. This pool can contain
@@ -129,6 +135,11 @@ class RunspacePool(object):
             hold
         :param session_key_timeout_ms: The maximum time to wait for a session
             key transfer from the server
+        :param no_profile: If True, the user profile will not be loaded and
+            will use the machine defaults.
+        :param idle_timeout: The idle timeout, in seconds, for the runspace. The
+            runspace will be closed if no operations are performed in the time
+            specified. If None the server default will be used.
         """
         log.info("Initialising RunspacePool object for configuration %s" % configuration_name)
         # The below are defined in some way at
@@ -138,7 +149,13 @@ class RunspacePool(object):
         self.connection = connection
         resource_uri = "http://schemas.microsoft.com/powershell/%s" % configuration_name
         self.shell = WinRS(
-            connection, resource_uri=resource_uri, id=self.id, input_streams="stdin pr", output_streams="stdout"
+            connection,
+            resource_uri=resource_uri,
+            id=self.id,
+            input_streams="stdin pr",
+            output_streams="stdout",
+            no_profile=no_profile,
+            idle_time_out=idle_timeout,
         )
         self.ci_table: typing.Dict = {}
         self.pipelines: typing.Dict[str, "PowerShell"] = {}
@@ -569,7 +586,6 @@ class RunspacePool(object):
         self._exchange_key = rsa.generate_private_key(
             public_exponent=65537,
             key_size=2048,
-            backend=default_backend(),
         )
         public_numbers = self._exchange_key.public_key().public_numbers()
         exponent = struct.pack("<I", public_numbers.e)
@@ -652,6 +668,47 @@ class RunspacePool(object):
         """
         return self._serializer.serialize(obj, metadata=metadata)
 
+    def is_alive(
+        self,
+        *,
+        timeout: int | None = None,
+    ) -> bool:
+        """Checks whether the RunspacePool is still alive.
+
+        :param timeout: Override the connection timeout defaults for the
+            request. The WSMan operation timeout will be set to this value
+            and the HTTP connect/read timeouts will be this value + 2 seconds.
+        :return: A bool True if the pool is still alive, False otherwise.
+        """
+        is_closed = False
+
+        try:
+            # We don't want to try and open a new connection if the socket
+            # was closed, we treat it as the pool is not alive.
+            with _pool_manager.DisableNewConnectionsContext():
+                state = self.shell._get_shell(timeout=timeout)
+
+            is_closed = state.get("State", "") == "Disconnected"
+        except WSManFaultError as exc:
+            if exc.code in [
+                0x80338029,  # ERROR_WSMAN_OPERATION_TIMEDOUT
+                0x8033805B,  # ERROR_WSMAN_UNEXPECTED_SELECTORS
+            ]:
+                is_closed = True
+            else:
+                raise
+
+        except (_pool_manager.NewConnectionDisabled, TimeoutError, requests.exceptions.ConnectionError):
+            # If a timeout or connection error occurs, treat the pool as closed.
+            is_closed = True
+
+        if is_closed:
+            # Ensures that close() doesn't try and close an already closed pool
+            self.state = RunspacePoolState.CLOSED
+            return False
+
+        return True
+
     def _receive(
         self,
         id: typing.Optional[str] = None,
@@ -861,7 +918,7 @@ class RunspacePool(object):
         iv = b"\x00" * 16  # PSRP doesn't use an IV
         algorithm = algorithms.AES(decrypted_key)
         mode = modes.CBC(iv)
-        cipher = Cipher(algorithm, mode, default_backend())
+        cipher = Cipher(algorithm, mode)
 
         self._serializer.cipher = cipher
         self._key_exchanged = True
@@ -907,7 +964,16 @@ class PowerShell(object):
         # CommandID that is created and we need to reference in the WSMan msgs
         self._command_id: typing.Optional[str] = None
 
-        runspace_pool.pipelines[self.id] = self
+    def __enter__(self) -> "PowerShell":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]],
+        value: typing.Optional[BaseException],
+        traceback: typing.Optional[types.TracebackType],
+    ) -> None:
+        self.close()
 
     def add_argument(
         self,
@@ -1042,6 +1108,33 @@ class PowerShell(object):
         self.commands = []
         return self
 
+    def clear_streams(self) -> None:
+        """
+        Clears all the data streams of the current PowerShell object.
+        """
+        self.streams = PSDataStreams()
+        self.output = []
+
+    def close(self) -> None:
+        """
+        Closes the PowerShell pipeline and cleans up server resources.
+
+        This method must be called to reuse a PowerShell object for multiple
+        invocations. It sends a TERMINATE signal to the server and removes
+        the pipeline from the runspace pool's pipeline registry.
+
+        :raises InvalidPipelineStateError: If the pipeline is not in a terminal
+            state (COMPLETED, STOPPED, or FAILED)
+        """
+        valid_states = [PSInvocationState.COMPLETED, PSInvocationState.STOPPED, PSInvocationState.FAILED]
+        if self.state == PSInvocationState.NOT_STARTED:
+            return
+        elif self.state not in valid_states:
+            raise InvalidPipelineStateError(self.state, valid_states, "close a PowerShell pipeline")
+
+        self.runspace_pool.shell.signal(SignalCode.TERMINATE, command_id=self._command_id or self.id)
+        self.runspace_pool.pipelines.pop(self.id, None)
+
     def connect(self):
         """
         Connects to a running command on a remote server, waits until the
@@ -1124,8 +1217,14 @@ class PowerShell(object):
             values. Will default to returning the invocation info on all
         """
         log.info("Beginning remote Pipeline invocation")
-        if self.state != PSInvocationState.NOT_STARTED:
-            raise InvalidPipelineStateError(self.state, PSInvocationState.NOT_STARTED, "start a PowerShell pipeline")
+        valid_states = [
+            PSInvocationState.NOT_STARTED,
+            PSInvocationState.STOPPED,
+            PSInvocationState.COMPLETED,
+            PSInvocationState.FAILED,
+        ]
+        if self.state not in valid_states:
+            raise InvalidPipelineStateError(self.state, valid_states, "start a PowerShell pipeline")
 
         if len(self.commands) == 0:
             raise InvalidPSRPOperation("Cannot invoke PowerShell without any commands being set")
@@ -1414,7 +1513,7 @@ class PowerShell(object):
         self.state = PSInvocationState.STOPPING
         self.runspace_pool.shell.signal(SignalCode.PS_CTRL_C, str(self.id).upper())
         self.state = PSInvocationState.STOPPED
-        del self.runspace_pool.pipelines[self.id]
+        self.runspace_pool.pipelines.pop(self.id, None)
 
     def _invoke(
         self,
@@ -1422,6 +1521,8 @@ class PowerShell(object):
     ) -> None:
         fragments = self.runspace_pool._fragmenter.fragment(msg, self.runspace_pool.id, self.id)
 
+        self.runspace_pool.pipelines[self.id] = self
+
         # send first fragment as Command message
         first_frag = base64.b64encode(fragments.pop(0)).decode("utf-8")
         resp = self.runspace_pool.shell.command("", arguments=[first_frag], command_id=self.id)

pypsrp/serializer.py

@@ -62,7 +62,7 @@ class Serializer(object):
         self.cipher: typing.Any = None
         # Finds C0, C1 and surrogate pairs in a unicode string for us to
         # encode according to the PSRP rules
-        self._serial_str = re.compile("[\u0000-\u001F\u007F-\u009F\U00010000-\U0010FFFF]")
+        self._serial_str = re.compile("[\u0000-\u001f\u007f-\u009f\U00010000-\U0010ffff]")
 
         # to support surrogate UTF-16 pairs we need to use a UTF-16 regex
         # so we can replace the UTF-16 string representation with the actual
@@ -615,7 +615,7 @@ class Serializer(object):
         element: ET.Element,
         metadata: ObjectMeta,
     ) -> typing.Any:
-        obj = metadata.object()  # type: ignore[misc] # Caller always sets object
+        obj = metadata.object()
         self.obj[element.attrib["RefId"]] = obj
 
         to_string_value = element.find("ToString")
@@ -669,7 +669,7 @@ class Serializer(object):
         element: ET.Element,
         metadata: ObjectMeta,
     ) -> typing.Any:
-        obj = metadata.object()  # type: ignore[misc] # Caller always sets object
+        obj = metadata.object()
         self.obj[element.attrib["RefId"]] = obj
 
         for obj_property in element:
@@ -703,13 +703,9 @@ class Serializer(object):
         element: ET.Element,
         metadata: typing.Optional[ObjectMeta] = None,
     ) -> typing.List:
-        list_value = []
         value_meta = getattr(metadata, "list_value_meta", None)
 
-        entries = element.find("LST")
-        for entry in entries or []:
-            entry_value = self.deserialize(entry, value_meta, clear=False)
-            list_value.append(entry_value)
+        list_value = list(self._deserialize_list_values(element, "LST", value_meta=value_meta))
 
         return list_value
 
@@ -719,10 +715,8 @@ class Serializer(object):
     ) -> Queue:
         queue: Queue = Queue()
 
-        entries = element.find("QUE")
-        for entry in entries or []:
-            entry_value = self.deserialize(entry, clear=False)
-            queue.put(entry_value)
+        for entry in self._deserialize_list_values(element, "QUE"):
+            queue.put(entry)
 
         return queue
 
@@ -731,15 +725,24 @@ class Serializer(object):
         element: ET.Element,
     ) -> typing.List:
         # no native Stack object in Python so just use a list
-        stack = []
-
-        entries = element.find("STK")
-        for entry in entries or []:
-            entry_value = self.deserialize(entry, clear=False)
-            stack.append(entry_value)
+        stack = list(self._deserialize_list_values(element, "STK"))
 
         return stack
 
+    def _deserialize_list_values(
+        self,
+        element: ET.Element,
+        list_type: str,
+        value_meta: typing.Optional[ObjectMeta] = None,
+    ) -> typing.Iterable[typing.Any]:
+        entries = element.find(list_type)
+        if entries is None:
+            return
+
+        for entry in entries:
+            entry_value = self.deserialize(entry, metadata=value_meta, clear=False)
+            yield entry_value
+
     def _deserialize_dct(
         self,
         element: ET.Element,

pypsrp/shell.py

@@ -1,6 +1,8 @@
 # Copyright: (c) 2018, Jordan Borean (@jborean93) <jborean93@gmail.com>
 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
 
+from __future__ import annotations
+
 import base64
 import logging
 import types
@@ -67,7 +69,7 @@ class WinRS(object):
         :param lifetime: The total lifetime of the shell
         :param name: The name (description) of the shell
         :param no_profile: Whether to create the shell with the user profile
-            active or not
+            active or not. This may not work on newer hosts like Server 2012+.
         :param working_directory: The default working directory of the created
             shell
         """
@@ -197,8 +199,8 @@ class WinRS(object):
         # inherit the base options if it was passed in, otherwise use an empty
         # option set
         options = OptionSet() if base_options is None else base_options
-        if self.no_profile is not None:
-            options.add_option("WINRS_NOPROFILE", str(self.no_profile))
+        if self.no_profile:
+            options.add_option("WINRS_NOPROFILE", "TRUE", {"MustComply": "true"})
         if self.codepage is not None:
             options.add_option("WINRS_CODEPAGE", str(self.codepage))
 
@@ -315,6 +317,42 @@ class WinRS(object):
         ET.SubElement(signal, "{%s}Code" % rsp).text = code
         return self.wsman.signal(self.resource_uri, signal, selector_set=self._selector_set)
 
+    def _get_shell(
+        self,
+        *,
+        timeout: int | None = None,
+    ) -> dict[str, str | None]:
+        """Queries the WSMan host for the current shell state.
+
+        Returns the WSMan GetResponse fields as a dictionary.
+
+        The timeout parameter can be used to override the default WSMan timeout
+        for this operation. If set the HTTP connect and read timeout will be
+        set to this value + 2 seconds to ensure the request does not block for
+        a longer time.
+
+        :param timeout: Sets the WSMan operational timeout to this value in
+            seconds. Overrides the default timeout set on the WSMan instance.
+        :return: A dictionary containing the shell state fields from the raw XML
+        response.
+        """
+        rsp = NAMESPACES["rsp"]
+
+        resp = self.wsman.get(
+            "http://schemas.microsoft.com/wbem/wsman/1/windows/shell",
+            selector_set=self._selector_set,
+            timeout=timeout,
+        )
+
+        state = {}
+        shell_items = resp.find("rsp:Shell", namespaces=NAMESPACES)
+        if shell_items is not None:
+            for child in shell_items:
+                field_name = child.tag.replace(f"{{{rsp}}}", "")
+                state[field_name] = child.text
+
+        return state
+
     def _parse_shell_create(
         self,
         response: ET.Element,

pypsrp/wsman.py

@@ -1,20 +1,21 @@
 # Copyright: (c) 2018, Jordan Borean (@jborean93) <jborean93@gmail.com>
 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
 
-from __future__ import division
+from __future__ import annotations
 
 import ipaddress
 import logging
 import re
+import time
 import typing
 import uuid
 import warnings
 import xml.etree.ElementTree as ET
-from xml.dom.minidom import Element
 
 import requests
 from requests.packages.urllib3.util.retry import Retry
 
+from pypsrp import _pool_manager
 from pypsrp._utils import get_hostname, to_string, to_unicode
 from pypsrp.encryption import WinRMEncryption
 from pypsrp.exceptions import (
@@ -40,7 +41,7 @@ log = logging.getLogger(__name__)
 SUPPORTED_AUTHS = ["basic", "certificate", "credssp", "kerberos", "negotiate", "ntlm"]
 
 AUTH_KWARGS: typing.Dict[str, typing.List[str]] = {
-    "certificate": ["certificate_key_pem", "certificate_pem"],
+    "certificate": ["certificate_key_pem", "certificate_pem", "certificate_key_password"],
     "credssp": ["credssp_auth_mechanism", "credssp_disable_tlsv1_2", "credssp_minimum_version"],
     "negotiate": ["negotiate_delegate", "negotiate_hostname_override", "negotiate_send_cbt", "negotiate_service"],
 }
@@ -364,7 +365,18 @@ class WSMan(object):
         selector_set: typing.Optional["SelectorSet"] = None,
         timeout: typing.Optional[int] = None,
     ) -> ET.Element:
-        res = self.invoke(WSManAction.RECEIVE, resource_uri, resource, option_set, selector_set, timeout)
+        # Receiving data can sometimes timeout if the server has bounced the
+        # network adapter. Luckily just sending the exact same request again
+        # will return the same data so we can safely retry
+        res = self.invoke(
+            WSManAction.RECEIVE,
+            resource_uri,
+            resource,
+            option_set,
+            selector_set,
+            timeout,
+            retries_on_read_timeout=5,
+        )
         return res.find("s:Body", namespaces=NAMESPACES)  # type: ignore[return-value] # WSMan always has this present
 
     def reconnect(
@@ -437,6 +449,8 @@ class WSMan(object):
         option_set: typing.Optional["OptionSet"] = None,
         selector_set: typing.Optional["SelectorSet"] = None,
         timeout: typing.Optional[int] = None,
+        *,
+        retries_on_read_timeout: int = 0,
     ) -> ET.Element:
         """
         Send a generic WSMan request to the host.
@@ -451,11 +465,21 @@ class WSMan(object):
         :param selector_set: a wsman.SelectorSet to add to the request
         :param timeout: Override the default wsman:OperationTimeout value for
             the request, this should be an int in seconds.
+        :param retries_on_read_timeout: The number of retries to attempt if the
+            request fails due to a read timeout.
         :return: The ET Element of the response XML from the server
         """
         s = NAMESPACES["s"]
         envelope = ET.Element("{%s}Envelope" % s)
 
+        http_timeout = None
+        if timeout:
+            # Failsafe if the operation timeout exceeds we don't want the
+            # request to hang indefinitely. The HTTP timeout needs to be more
+            # than the WSMan timeout as we cannot guarantee a WSMan response
+            # until the operation timeout is hit.
+            http_timeout = timeout + 2
+
         message_id, header = self._create_header(action, resource_uri, option_set, selector_set, timeout)
         message_id = f"uuid:{message_id}"
         envelope.append(header)
@@ -467,7 +491,11 @@ class WSMan(object):
         xml = ET.tostring(envelope, encoding="utf-8", method="xml")
 
         try:
-            response = self.transport.send(xml)
+            response = self.transport.send(
+                xml,
+                retries_on_read_timeout=retries_on_read_timeout,
+                timeout=http_timeout,
+            )
         except WinRMTransportError as err:
             try:
                 # try and parse the XML and get the WSManFault
@@ -570,9 +598,9 @@ class WSMan(object):
         ET.SubElement(header, "{%s}OperationTimeout" % wsman).text = "PT%sS" % str(timeout or self.operation_timeout)
 
         reply_to = ET.SubElement(header, "{%s}ReplyTo" % wsa)
-        ET.SubElement(
-            reply_to, "{%s}Address" % wsa, attrib={"{%s}mustUnderstand" % s: "true"}
-        ).text = "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous"
+        ET.SubElement(reply_to, "{%s}Address" % wsa, attrib={"{%s}mustUnderstand" % s: "true"}).text = (
+            "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous"
+        )
 
         ET.SubElement(header, "{%s}ResourceURI" % wsman, attrib={"{%s}mustUnderstand" % s: "true"}).text = resource_uri
 
@@ -617,7 +645,7 @@ class WSMan(object):
             if reason_info is not None:
                 reason = reason_info.text
 
-        wsman_fault = fault.find("s:Detail/wsmanfault:WSManFault", namespaces=NAMESPACES) if fault else None
+        wsman_fault = fault.find("s:Detail/wsmanfault:WSManFault", namespaces=NAMESPACES) if fault is not None else None
         if wsman_fault is not None:
             code = wsman_fault.attrib.get("Code", code)
             machine = wsman_fault.attrib.get("Machine")
@@ -772,6 +800,7 @@ class _TransportHTTP(object):
 
         self.certificate_key_pem: typing.Optional[str] = None
         self.certificate_pem: typing.Optional[str] = None
+        self.certificate_key_password: typing.Optional[str] = None
         for kwarg_list in AUTH_KWARGS.values():
             for kwarg in kwarg_list:
                 setattr(self, kwarg, kwargs.get(kwarg, None))
@@ -790,17 +819,35 @@ class _TransportHTTP(object):
         if self.session:
             self.session.close()
 
-    def send(self, message: bytes) -> bytes:
+    def send(
+        self,
+        message: bytes,
+        *,
+        retries_on_read_timeout: int = 0,
+        timeout: int | float | tuple[int | float, int | float] | None = None,
+    ) -> bytes:
         hostname = get_hostname(self.endpoint)
         if self.session is None:
             self.session = self._build_session()
 
+        attempt = 0
+        while True:
             # need to send an initial blank message to setup the security
             # context required for encryption
-            if self.wrap_required:
+            if self.wrap_required and not self.encryption:
                 request = requests.Request("POST", self.endpoint, data=None)
                 prep_request = self.session.prepare_request(request)
-                self._send_request(prep_request)
+
+                try:
+                    self._send_request(prep_request, timeout=timeout)
+                except (requests.ReadTimeout, requests.ConnectTimeout) as e:
+                    log.exception("%s during initial authentication request - attempt %d", type(e).__name__, attempt)
+                    if attempt == retries_on_read_timeout:
+                        raise
+
+                    attempt += 1
+                    time.sleep(self.reconnection_backoff * (2**attempt))
+                    continue
 
                 protocol = WinRMEncryption.SPNEGO
                 if isinstance(self.session.auth, HttpCredSSPAuth):
@@ -811,33 +858,55 @@ class _TransportHTTP(object):
 
                 self.encryption = WinRMEncryption(self.session.auth.contexts[hostname], protocol)  # type: ignore[union-attr] # This should not happen
 
-        if log.isEnabledFor(logging.DEBUG):
-            log.debug("Sending message: %s" % message.decode("utf-8"))
-        # for testing, keep commented out
-        # self._test_messages.append({"request": message.decode('utf-8'),
-        #                             "response": None})
-
-        headers = self.session.headers
-        if self.wrap_required:
-            content_type, payload = self.encryption.wrap_message(message)  # type: ignore[union-attr] # This should not happen
-            protocol = self.encryption.protocol if self.encryption else WinRMEncryption.SPNEGO
-            type_header = '%s;protocol="%s";boundary="Encrypted Boundary"' % (content_type, protocol)
-            headers.update(
-                {
-                    "Content-Type": type_header,
-                    "Content-Length": str(len(payload)),
-                }
-            )
-        else:
-            payload = message
-            headers["Content-Type"] = "application/soap+xml;charset=UTF-8"
+            if log.isEnabledFor(logging.DEBUG):
+                log.debug("Sending message on attempt %d: %s" % (attempt, message.decode("utf-8")))
+            # for testing, keep commented out
+            # self._test_messages.append({"request": message.decode('utf-8'),
+            #                             "response": None})
 
-        request = requests.Request("POST", self.endpoint, data=payload, headers=headers)
-        prep_request = self.session.prepare_request(request)
-        return self._send_request(prep_request)
+            headers = self.session.headers.copy()  # type: ignore[attr-defined] # We cannot use copy.copy as it still is a ref to the original.
+            if self.wrap_required:
+                content_type, payload = self.encryption.wrap_message(message)  # type: ignore[union-attr] # This should not happen
+                protocol = self.encryption.protocol if self.encryption else WinRMEncryption.SPNEGO
+                type_header = '%s;protocol="%s";boundary="Encrypted Boundary"' % (content_type, protocol)
+                headers.update(
+                    {
+                        "Content-Type": type_header,
+                        "Content-Length": str(len(payload)),
+                    }
+                )
+            else:
+                payload = message
+                headers["Content-Type"] = "application/soap+xml;charset=UTF-8"
+
+            request = requests.Request("POST", self.endpoint, data=payload, headers=headers)
+            prep_request = self.session.prepare_request(request)
+            try:
+                return self._send_request(
+                    prep_request,
+                    timeout=timeout,
+                )
+            except (requests.ReadTimeout, requests.ConnectTimeout) as e:
+                log.exception("%s during WSMan request - attempt %d", type(e).__name__, attempt)
+                if attempt == retries_on_read_timeout:
+                    raise
 
-    def _send_request(self, request: requests.PreparedRequest) -> bytes:
-        response = self.session.send(request, timeout=(self.connection_timeout, self.read_timeout))  # type: ignore[union-attr] # This should not happen
+                # On a failure the encryption state is invalidated and needs to
+                # be recreated after authentication is done.
+                self.encryption = None
+
+                attempt += 1
+                time.sleep(self.reconnection_backoff * (2**attempt - 1))
+
+    def _send_request(
+        self,
+        request: requests.PreparedRequest,
+        timeout: int | float | tuple[int | float, int | float] | None = None,
+    ) -> bytes:
+        response = self.session.send(  # type: ignore[union-attr] # This should not happen
+            request,
+            timeout=timeout if timeout is not None else (self.connection_timeout, self.read_timeout),
+        )
 
         content_type = response.headers.get("content-type", "")
         if content_type.startswith("multipart/encrypted;") or content_type.startswith("multipart/x-multi-encrypted;"):
@@ -878,7 +947,7 @@ class _TransportHTTP(object):
 
         # get the env requests settings
         session.trust_env = True
-        settings = session.merge_environment_settings(  # type: ignore[no-untyped-call] # Not in types-requests
+        settings = session.merge_environment_settings(
             url=self.endpoint, proxies={}, stream=None, verify=None, cert=None
         )
 
@@ -915,8 +984,14 @@ class _TransportHTTP(object):
             del retry_kwargs["status"]
             retries = Retry(**retry_kwargs)
 
-        session.mount("http://", requests.adapters.HTTPAdapter(max_retries=retries))
-        session.mount("https://", requests.adapters.HTTPAdapter(max_retries=retries))
+        session.mount(
+            "http://",
+            _pool_manager.create_request_adapter(max_retries=retries),
+        )
+        session.mount(
+            "https://",
+            _pool_manager.create_request_adapter(max_retries=retries, key_password=self.certificate_key_password),
+        )
 
         # set cert validation config
         session.verify = self.cert_validation
@@ -954,6 +1029,9 @@ class _TransportHTTP(object):
         if self.ssl is False:
             raise ValueError("For certificate auth, SSL must be used")
 
+        # requests does not expose the password through the cert tuple. If set
+        # it'll be passed to urllib3 through the custom adapter created for the
+        # session.
         session.cert = (self.certificate_pem, self.certificate_key_pem)
         session.headers["Authorization"] = "http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/https/mutual"
 

{pypsrp-0.8.1.dist-info → pypsrp-0.9.0rc2.dist-info}/METADATA

@@ -1,30 +1,44 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pypsrp
-Version: 0.8.1
+Version: 0.9.0rc2
 Summary: PowerShell Remoting Protocol and WinRM for Python
-Home-page: https://github.com/jborean93/pypsrp
-Author: Jordan Borean
-Author-email: jborean93@gmail.com
-License: MIT
+Author-email: Jordan Borean <jborean93@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/jborean93/pypsrp
 Keywords: winrm,psrp,winrs,windows,powershell
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
-Classifier: License :: OSI Approved :: MIT License
 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
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cryptography
-Requires-Dist: pyspnego (<1.0.0)
-Requires-Dist: requests (>=2.9.1)
+Requires-Dist: cryptography>=3.1
+Requires-Dist: pyspnego<1.0.0,>=0.7.0
+Requires-Dist: requests>=2.27.0
 Provides-Extra: credssp
-Requires-Dist: requests-credssp (>=2.0.0) ; extra == 'credssp'
+Requires-Dist: requests-credssp>=2.0.0; extra == "credssp"
 Provides-Extra: kerberos
-Requires-Dist: pyspnego[kerberos] ; extra == 'kerberos'
+Requires-Dist: pyspnego[kerberos]; extra == "kerberos"
+Provides-Extra: dev
+Requires-Dist: black==25.11.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: isort==6.1.0; extra == "dev"
+Requires-Dist: mypy==1.19.0; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyspnego[kerberos]; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: PyYAML; extra == "dev"
+Requires-Dist: requests-credssp; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: xmldiff; extra == "dev"
+Dynamic: license-file
 
 # pypsrp - Python PowerShell Remoting Protocol Client library
 
@@ -69,7 +83,7 @@ libraries to be installed.
 
 See `How to Install` for more details
 
-* CPython 3.6+
+* CPython 3.10+
 * [cryptography](https://github.com/pyca/cryptography)
 * [pyspnego](https://github.com/jborean93/pyspnego)
 * [requests](https://github.com/requests/requests)
@@ -155,7 +169,19 @@ pip install pypsrp[credssp]
 ```
 
 If that fails you may need to update pip and setuptools to a newer version
-`pip install -U pip setuptools`.
+`pip install -U pip setuptools`, otherwise the following system package may be
+required;
+
+```bash
+# For Debian/Ubuntu
+apt-get install gcc python-dev
+
+# For RHEL/Centos
+yum install gcc python-devel
+
+# For Fedora
+dnf install gcc python-devel
+```
 
 
 ## How to Use
@@ -198,7 +224,8 @@ These are the options that can be used to setup `WSMan`;
 * `data_locale`: The `wsmv:DataLocale` value to set on each WSMan request. This specifies the format in which numerical data is presented in the response text, default is the value of `locale`
 * `reconnection_retries`: Number of retries on a connection problem, default is `0`
 * `reconnection_backoff`: Number of seconds to backoff in between reconnection attempts (first sleeps X, then sleeps 2*X, 4*X, 8*X, ...), default is `2.0`
-* `certificate_key_pem`: The path to the certificate key used in `certificate` authentication
+* `certificate_key_pem`: The path to the certificate key used in `certificate` authentication. The key can be in either a `PKCS#1` or `PKCS#8` format
+* `certificate_key_password`: The password for `certificate_key_pem` if it is encrypted
 * `certificate_pem`: The path to the certificate used in `certificate` authentication
 * `credssp_auth_mechanism`: The sub-auth mechanism used in CredSSP, default is `auto`, choices are `auto`, `ntlm`, or `kerberos`
 * `credssp_disable_tlsv1_2`: Whether to used CredSSP auth over the insecure TLSv1.0, default is `False`
@@ -235,7 +262,7 @@ configure a `WinRS` shell;
 * `idle_time_out`: THe idle timeout in seconds of the shell
 * `lifetime`: The total lifetime of the shell
 * `name`: The name (description only) of the shell
-* `no_profile`: Whether to create the shell with the user profile loaded or not
+* `no_profile`: Whether to create the shell with the user profile loaded or not. This no longer works on Server 2012/Windows 8 or newer
 * `working_directory`: The default working directory of the created shell
 
 `RunspacePool` is a shell used by the PSRP protocol, it is designed to be a
@@ -252,6 +279,7 @@ Here are the options that can be used to configure a `RunspacePool` shell;
 * `min_runspaces`: The minimuum number of runspaces that a pool can hold, default is 1
 * `max_runspaces`: The maximum number of runspaces that a pool can hold. Each PowerShell pipeline is run in a single Runspace, default is 1
 * `session_key_timeout_ms`: The maximum time to wait for a session key transfer from the server
+* `no_profile`: Do not load the user profile on the remote Runspace Pool
 
 ### Process
 
@@ -357,9 +385,8 @@ from pypsrp.wsman import WSMan
 # creates a https connection with explicit kerberos auth and implicit credentials
 wsman = WSMan("server", auth="kerberos", cert_validation=False))
 
-with wsman, RunspacePool(wsman) as pool:
+with wsman, RunspacePool(wsman) as pool, PowerShell(pool) as ps:
     # execute 'Get-Process | Select-Object Name'
-    ps = PowerShell(pool)
     ps.add_cmdlet("Get-Process").add_cmdlet("Select-Object").add_argument("Name")
     output = ps.invoke()
 
@@ -390,6 +417,19 @@ with wsman, RunspacePool(wsman) as pool:
     ps.invoke(["string", 1])
     print(ps.output)
     print(ps.streams.debug)
+
+    # It is possible to run the PowerShell pipeline again with invoke() but it
+    # needs to be explicitly closed first and the commands/streams optionally
+    # cleared if desired.
+    ps.close()
+
+    # Clears out ps.output and ps.streams to a blank value. Not required but
+    # nice if the output should be separate from a previous run
+    ps.clear_streams()
+
+    # Removes all existing commands. Not required but needed if re-using the
+    # same pipeline with a different set of commands
+    ps.clear_commands()
 ```
 
 
@@ -443,17 +483,18 @@ information and should only be used for debugging purposes._
 ## Testing
 
 Any changes are more than welcome in pull request form, you can run the current
-test suite with tox like so;
+test suite with:
 
 ```bash
-# make sure tox is installed
-pip install tox
-
-# run the tox suite
-tox
-
-# or run the test manually for the current Python environment
-py.test -v --pep8 --cov pypsrp --cov-report term-missing
+pip install -e .[dev]
+
+python -m pytest \
+    tests/tests_pypsrp \
+    --verbose \
+    --junitxml junit/test-results.xml \
+    --cov pypsrp \
+    --cov-report xml \
+    --cov-report term-missing
 ```
 
 A lot of the tests either simulate a remote Windows host but you can also run a
@@ -523,5 +564,3 @@ tests.
 * Add Ansible playbook for better integration tests
 * Improved serialization between Python and .NET objects
 * Live interactive console for PSRP
-
-

pypsrp-0.9.0rc2.dist-info/RECORD

@@ -0,0 +1,23 @@
+pypsrp/__init__.py,sha256=9aButMuBNIEph0LfHsodNd8uSS7XKZj9IPHJsPd8hjY,958
+pypsrp/_pool_manager.py,sha256=yKUzdzkE4hEo2mqIC-kKPL9uWpIk9mixCQ1AP5rgn_o,4222
+pypsrp/_utils.py,sha256=y9sezXQPl0vXnr1beyZ8xcn-Q_zdg_7cg_lPk9QmjVQ,3540
+pypsrp/client.py,sha256=iJERbEXwwE4wswpqAL0Dcz8ACqLvXUT9Dcl_Qqa3830,13892
+pypsrp/complex_objects.py,sha256=PkJ1F1Byw5RI_Vpfy1KfcMFJdOfioOSsIbi50S_fZ3g,62666
+pypsrp/encryption.py,sha256=4wOontH-eF8BBxTyHTX9iAF0uIM6m-z3N9poatspP1A,3870
+pypsrp/exceptions.py,sha256=SWdQ9UAPOIwr7B4twGqDoXLCEtXFK_5u3PYIVLvEIbA,4034
+pypsrp/host.py,sha256=XQgnkwzsZprNmAr1TPJpEBmj3xRSWFrYQFSIi870aNE,45065
+pypsrp/messages.py,sha256=mCuie1ywOQmkXltISPvrb6ITS6GUA0oSld2jfNLdBf4,34169
+pypsrp/negotiate.py,sha256=iVX2J-slABamesMajjTfmfqucDS4n5vVTTde_IDqpuE,10951
+pypsrp/powershell.py,sha256=NRDoFtOsYjIrJHMQ6r6vRq6uL2EtPhhem5ZA_bWoDnw,69296
+pypsrp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypsrp/serializer.py,sha256=49rBxfo3fh511mU3uzoK9vFvIOrBtyX3J-CUugbezc0,33767
+pypsrp/shell.py,sha256=80mh35c-UXjsy_MFG9J3GGYLYqvk2FppUgrFHkWh6xg,18065
+pypsrp/wsman.py,sha256=KkRg9UDDq1yxY4TKK9mGI-vS6px6ftQDPhmeojjItKg,48728
+pypsrp/pwsh_scripts/__init__.py,sha256=VckRBWWDUdh_LTwPspE2FXSo8TaT50QnZ1aZ-yvxJmU,139
+pypsrp/pwsh_scripts/copy.ps1,sha256=sTy4jcnh0cV5Y0l2-dd1znc-eM_kgE-okk51xZzdIQk,5374
+pypsrp/pwsh_scripts/fetch.ps1,sha256=7gvPxURnksZetYgjWRjbIDIWSJYv2xGXZjRymvNUj6w,1989
+pypsrp-0.9.0rc2.dist-info/licenses/LICENSE,sha256=8uJLgs8Wb_Us_8XaTvOOn7Yf0dwzFi9pcFHVxfgJKoE,1079
+pypsrp-0.9.0rc2.dist-info/METADATA,sha256=_zCveXjKqq1_OiCmjLtge2Zr3v1G-S2EFrF33PTd6QA,23630
+pypsrp-0.9.0rc2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pypsrp-0.9.0rc2.dist-info/top_level.txt,sha256=9sFQD0PMIG07xbaR4j-1Fq7NaD9kwInn_HTc3Gqznq0,7
+pypsrp-0.9.0rc2.dist-info/RECORD,,

{pypsrp-0.8.1.dist-info → pypsrp-0.9.0rc2.dist-info}/WHEEL

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

pypsrp-0.8.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-pypsrp/__init__.py,sha256=9aButMuBNIEph0LfHsodNd8uSS7XKZj9IPHJsPd8hjY,958
-pypsrp/_utils.py,sha256=BKXpmraKuyWt5N89ViuC91wsF7AB1XPyViE_1_Cl4w0,3541
-pypsrp/client.py,sha256=sp9rgNwAGJXXaMgdYdJ7yMd_q1FjYg1nlpVwT_yncSw,13941
-pypsrp/complex_objects.py,sha256=D2y7IaxN3_n72Er6vJxFFlui9yHORVopGxIVManlCDg,62744
-pypsrp/encryption.py,sha256=elgz6Fph6ZYsvN7ZT1FFSH7Q05UYS8Nh5kiJvSyWy-o,3871
-pypsrp/exceptions.py,sha256=SWdQ9UAPOIwr7B4twGqDoXLCEtXFK_5u3PYIVLvEIbA,4034
-pypsrp/host.py,sha256=XQgnkwzsZprNmAr1TPJpEBmj3xRSWFrYQFSIi870aNE,45065
-pypsrp/messages.py,sha256=GBKv2Ilm0oDV8lHVbYDkx41AckoOGIhQG-HovbLnvbA,34093
-pypsrp/negotiate.py,sha256=ZS1NL2U17CFiDE3B_U2AprRz_BfBO7iFC5jkSO_bi1E,11073
-pypsrp/powershell.py,sha256=10TpFRSvMi8VVtkkSklQCBftcagzLpN2ZginSbnyDVA,65595
-pypsrp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypsrp/serializer.py,sha256=KhT1l0ay2wQfncAXY-KY9ZQfVMKhjCWgjL7O1bywEhA,33759
-pypsrp/shell.py,sha256=DA-yj80PdtfxpOAmJrs6k5BmjqjE5-ZeDU2C9rgli6k,16697
-pypsrp/wsman.py,sha256=v2ZkKGfKY502VhA8XFdXKyEPbEoc3bTWJ486SRbW2do,45641
-pypsrp/pwsh_scripts/__init__.py,sha256=VckRBWWDUdh_LTwPspE2FXSo8TaT50QnZ1aZ-yvxJmU,139
-pypsrp/pwsh_scripts/copy.ps1,sha256=sTy4jcnh0cV5Y0l2-dd1znc-eM_kgE-okk51xZzdIQk,5374
-pypsrp/pwsh_scripts/fetch.ps1,sha256=7gvPxURnksZetYgjWRjbIDIWSJYv2xGXZjRymvNUj6w,1989
-pypsrp-0.8.1.dist-info/LICENSE,sha256=8uJLgs8Wb_Us_8XaTvOOn7Yf0dwzFi9pcFHVxfgJKoE,1079
-pypsrp-0.8.1.dist-info/METADATA,sha256=lB6x7GQTrp8L1flRqu7Np2XScvrS43pjj7mmR8LyEQU,22012
-pypsrp-0.8.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-pypsrp-0.8.1.dist-info/top_level.txt,sha256=9sFQD0PMIG07xbaR4j-1Fq7NaD9kwInn_HTc3Gqznq0,7
-pypsrp-0.8.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pypsrp-0.8.1.dist-info/RECORD,,

pypsrp-0.8.1.dist-info/zip-safe

@@ -1 +0,0 @@
-