py2docfx 0.1.16.dev2064350__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/msal/individual_cache.py

@@ -59,6 +59,10 @@ class _ExpiringMapping(MutableMapping):
         self._expires_in = expires_in
         self._lock = Lock() if lock is None else lock
 
+    def _peek(self):
+        # Returns (sequence, timestamps) without triggering maintenance
+        return self._mapping.get(self._INDEX, ([], {}))
+
     def _validate_key(self, key):
         if key == self._INDEX:
             raise ValueError("key {} is a reserved keyword in {}".format(
@@ -85,7 +89,7 @@ class _ExpiringMapping(MutableMapping):
         # This internal implementation powers both set() and __setitem__(),
         # so that they don't depend on each other.
         self._validate_key(key)
-        sequence, timestamps = self._mapping.get(self._INDEX, ([], {}))
+        sequence, timestamps = self._peek()
         self._maintenance(sequence, timestamps)  # O(logN)
         now = int(time.time())
         expires_at = now + expires_in
@@ -136,7 +140,7 @@ class _ExpiringMapping(MutableMapping):
         self._validate_key(key)
         with self._lock:
             # Skip self._maintenance(), because it would need O(logN) time
-            sequence, timestamps = self._mapping.get(self._INDEX, ([], {}))
+            sequence, timestamps = self._peek()
             expires_at, created_at = timestamps[key]  # Would raise KeyError accordingly
             now = int(time.time())
             if not created_at <= now < expires_at:
@@ -155,14 +159,14 @@ class _ExpiringMapping(MutableMapping):
         with self._lock:
             # Skip self._maintenance(), because it would need O(logN) time
             self._mapping.pop(key, None)  # O(1)
-            sequence, timestamps = self._mapping.get(self._INDEX, ([], {}))
+            sequence, timestamps = self._peek()
             del timestamps[key]  # O(1)
             self._mapping[self._INDEX] = sequence, timestamps
 
     def __len__(self):  # O(logN)
         """Drop all expired items and return the remaining length"""
         with self._lock:
-            sequence, timestamps = self._mapping.get(self._INDEX, ([], {}))
+            sequence, timestamps = self._peek()
             self._maintenance(sequence, timestamps)  # O(logN)
             self._mapping[self._INDEX] = sequence, timestamps
             return len(timestamps)  # Faster than iter(self._mapping) when it is on disk
@@ -170,7 +174,7 @@ class _ExpiringMapping(MutableMapping):
     def __iter__(self):
         """Drop all expired items and return an iterator of the remaining items"""
         with self._lock:
-            sequence, timestamps = self._mapping.get(self._INDEX, ([], {}))
+            sequence, timestamps = self._peek()
             self._maintenance(sequence, timestamps)  # O(logN)
             self._mapping[self._INDEX] = sequence, timestamps
         return iter(timestamps)  # Faster than iter(self._mapping) when it is on disk

py2docfx/venv/venv1/Lib/site-packages/msal/managed_identity.py

@@ -112,8 +112,8 @@ class UserAssignedManagedIdentity(ManagedIdentity):
 
 
 class _ThrottledHttpClient(ThrottledHttpClientBase):
-    def __init__(self, http_client, **kwargs):
-        super(_ThrottledHttpClient, self).__init__(http_client, **kwargs)
+    def __init__(self, *args, **kwargs):
+        super(_ThrottledHttpClient, self).__init__(*args, **kwargs)
         self.get = IndividualCache(  # All MIs (except Cloud Shell) use GETs
             mapping=self._expiring_mapping,
             key_maker=lambda func, args, kwargs: "REQ {} hash={} 429/5xx/Retry-After".format(
@@ -124,7 +124,7 @@ class _ThrottledHttpClient(ThrottledHttpClientBase):
                     str(kwargs.get("params")) + str(kwargs.get("data"))),
                 ),
             expires_in=RetryAfterParser(5).parse,  # 5 seconds default for non-PCA
-            )(http_client.get)
+            )(self.get)  # Note: Decorate the parent get(), not the http_client.get()
 
 
 class ManagedIdentityClient(object):
@@ -233,8 +233,7 @@ class ManagedIdentityClient(object):
             #    (especially for 410 which was supposed to be a permanent failure).
             # 2. MI on Service Fabric specifically suggests to not retry on 404.
             #    ( https://learn.microsoft.com/en-us/azure/service-fabric/how-to-managed-cluster-managed-identity-service-fabric-app-code#error-handling )
-            http_client.http_client  # Patch the raw (unpatched) http client
-                if isinstance(http_client, ThrottledHttpClientBase) else http_client,
+            http_client,
             http_cache=http_cache,
         )
         self._token_cache = token_cache or TokenCache()

py2docfx/venv/venv1/Lib/site-packages/msal/sku.py

@@ -2,5 +2,5 @@
 """
 
 # The __init__.py will import this. Not the other way around.
-__version__ = "1.32.0"
+__version__ = "1.32.3"
 SKU = "MSAL.Python"

py2docfx/venv/venv1/Lib/site-packages/msal/throttled_http_client.py

@@ -3,26 +3,34 @@ from hashlib import sha256
 
 from .individual_cache import _IndividualCache as IndividualCache
 from .individual_cache import _ExpiringMapping as ExpiringMapping
+from .oauth2cli.http import Response
+from .exceptions import MsalServiceError
 
 
 # https://datatracker.ietf.org/doc/html/rfc8628#section-3.4
 DEVICE_AUTH_GRANT = "urn:ietf:params:oauth:grant-type:device_code"
 
 
+def _get_headers(response):
+    # MSAL's HttpResponse did not have headers until 1.23.0
+    # https://github.com/AzureAD/microsoft-authentication-library-for-python/pull/581/files#diff-28866b706bc3830cd20485685f20fe79d45b58dce7050e68032e9d9372d68654R61
+    # This helper ensures graceful degradation to {} without exception
+    return getattr(response, "headers", {})
+
+
 class RetryAfterParser(object):
+    FIELD_NAME_LOWER = "Retry-After".lower()
     def __init__(self, default_value=None):
         self._default_value = 5 if default_value is None else default_value
 
     def parse(self, *, result, **ignored):
         """Return seconds to throttle"""
         response = result
-        lowercase_headers = {k.lower(): v for k, v in getattr(
-            # Historically, MSAL's HttpResponse does not always have headers
-            response, "headers", {}).items()}
+        lowercase_headers = {k.lower(): v for k, v in _get_headers(response).items()}
         if not (response.status_code == 429 or response.status_code >= 500
-                or "retry-after" in lowercase_headers):
+                or self.FIELD_NAME_LOWER in lowercase_headers):
             return 0  # Quick exit
-        retry_after = lowercase_headers.get("retry-after", self._default_value)
+        retry_after = lowercase_headers.get(self.FIELD_NAME_LOWER, self._default_value)
         try:
             # AAD's retry_after uses integer format only
             # https://stackoverflow.microsoft.com/questions/264931/264932
@@ -37,16 +45,44 @@ def _extract_data(kwargs, key, default=None):
     return data.get(key) if isinstance(data, dict) else default
 
 
+class NormalizedResponse(Response):
+    """A http response with the shape defined in Response,
+    but contains only the data we will store in cache.
+    """
+    def __init__(self, raw_response):
+        super().__init__()
+        self.status_code = raw_response.status_code
+        self.text = raw_response.text
+        self.headers = {
+            k.lower(): v for k, v in _get_headers(raw_response).items()
+            # Attempted storing only a small set of headers (such as Retry-After),
+            # but it tends to lead to missing information (such as WWW-Authenticate).
+            # So we store all headers, which are expected to contain only public info,
+            # because we throttle only error responses and public responses.
+        }
+
+    ## Note: Don't use the following line,
+    ## because when being pickled, it will indirectly pickle the whole raw_response
+    # self.raise_for_status = raw_response.raise_for_status
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise MsalServiceError("HTTP Error: {}".format(self.status_code))
+
+
 class ThrottledHttpClientBase(object):
     """Throttle the given http_client by storing and retrieving data from cache.
 
-    This wrapper exists so that our patching post() and get() would prevent
-    re-patching side effect when/if same http_client being reused.
+    This base exists so that:
+    1. These base post() and get() will return a NormalizedResponse
+    2. The base __init__() will NOT re-throttle even if caller accidentally nested ThrottledHttpClient.
 
-    The subclass should implement post() and/or get()
+    Subclasses shall only need to dynamically decorate their post() and get() methods
+    in their __init__() method.
     """
     def __init__(self, http_client, *, http_cache=None):
-        self.http_client = http_client
+        self.http_client = http_client.http_client if isinstance(
+            # If it is already a ThrottledHttpClientBase, we use its raw (unthrottled) http client
+            http_client, ThrottledHttpClientBase) else http_client
         self._expiring_mapping = ExpiringMapping(  # It will automatically clean up
             mapping=http_cache if http_cache is not None else {},
             capacity=1024,  # To prevent cache blowing up especially for CCA
@@ -54,10 +90,10 @@ class ThrottledHttpClientBase(object):
             )
 
     def post(self, *args, **kwargs):
-        return self.http_client.post(*args, **kwargs)
+        return NormalizedResponse(self.http_client.post(*args, **kwargs))
 
     def get(self, *args, **kwargs):
-        return self.http_client.get(*args, **kwargs)
+        return NormalizedResponse(self.http_client.get(*args, **kwargs))
 
     def close(self):
         return self.http_client.close()
@@ -68,12 +104,11 @@ class ThrottledHttpClientBase(object):
 
 
 class ThrottledHttpClient(ThrottledHttpClientBase):
-    def __init__(self, http_client, *, default_throttle_time=None, **kwargs):
-        super(ThrottledHttpClient, self).__init__(http_client, **kwargs)
-
-        _post = http_client.post  # We'll patch _post, and keep original post() intact
-
-        _post = IndividualCache(
+    """A throttled http client that is used by MSAL's non-managed identity clients."""
+    def __init__(self, *args, default_throttle_time=None, **kwargs):
+        """Decorate self.post() and self.get() dynamically"""
+        super(ThrottledHttpClient, self).__init__(*args, **kwargs)
+        self.post = IndividualCache(
             # Internal specs requires throttling on at least token endpoint,
             # here we have a generic patch for POST on all endpoints.
             mapping=self._expiring_mapping,
@@ -91,9 +126,9 @@ class ThrottledHttpClient(ThrottledHttpClientBase):
                                 _extract_data(kwargs, "username")))),  # "account" of ROPC
                     ),
             expires_in=RetryAfterParser(default_throttle_time or 5).parse,
-            )(_post)
+            )(self.post)
 
-        _post = IndividualCache(  # It covers the "UI required cache"
+        self.post = IndividualCache(  # It covers the "UI required cache"
             mapping=self._expiring_mapping,
             key_maker=lambda func, args, kwargs: "POST {} hash={} 400".format(
                 args[0],  # It is the url, typically containing authority and tenant
@@ -125,12 +160,10 @@ class ThrottledHttpClient(ThrottledHttpClientBase):
                     isinstance(kwargs.get("data"), dict)
                     and kwargs["data"].get("grant_type") == DEVICE_AUTH_GRANT
                     )
-                and "retry-after" not in set(  # Leave it to the Retry-After decorator
-                    h.lower() for h in getattr(result, "headers", {}).keys())
+                and RetryAfterParser.FIELD_NAME_LOWER not in set(  # Otherwise leave it to the Retry-After decorator
+                    h.lower() for h in _get_headers(result))
                 else 0,
-            )(_post)
-
-        self.post = _post
+            )(self.post)
 
         self.get = IndividualCache(  # Typically those discovery GETs
             mapping=self._expiring_mapping,
@@ -140,9 +173,4 @@ class ThrottledHttpClient(ThrottledHttpClientBase):
                 ),
             expires_in=lambda result=None, **ignored:
                 3600*24 if 200 <= result.status_code < 300 else 0,
-            )(http_client.get)
-
-    # The following 2 methods have been defined dynamically by __init__()
-    #def post(self, *args, **kwargs): pass
-    #def get(self, *args, **kwargs): pass
-
+            )(self.get)

py2docfx/venv/venv1/Lib/site-packages/opencensus/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

py2docfx/venv/venv1/Lib/site-packages/opencensus/ext/azure/common/__init__.py

@@ -1,138 +1,138 @@
-# Copyright 2019, OpenCensus Authors
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-import os
-import tempfile
-
-from opencensus.ext.azure.common.protocol import BaseObject
-
-INGESTION_ENDPOINT = 'ingestionendpoint'
-INSTRUMENTATION_KEY = 'instrumentationkey'
-TEMPDIR_PREFIX = "opencensus-python-"
-
-_logger = logging.getLogger(__name__)
-
-
-def process_options(options):
-    # Connection string/ikey
-    code_cs = parse_connection_string(options.connection_string)
-    code_ikey = options.instrumentation_key
-    env_cs = parse_connection_string(
-        os.getenv('APPLICATIONINSIGHTS_CONNECTION_STRING'))
-    env_ikey = os.getenv('APPINSIGHTS_INSTRUMENTATIONKEY')
-
-    # Deprecation note about explicit instrumentation key usage
-    if (not code_cs and code_ikey) or (not env_cs and env_ikey):
-        _logger.warning(
-            "DeprecationWarning: Explicitly using instrumentation key is"
-            "deprecated. Please use a connection string instead."
-        )
-
-    # The priority of which value takes on the instrumentation key is:
-    # 1. Key from explicitly passed in connection string
-    # 2. Key from explicitly passed in instrumentation key
-    # 3. Key from connection string in environment variable
-    # 4. Key from instrumentation key in environment variable
-    options.instrumentation_key = code_cs.get(INSTRUMENTATION_KEY) \
-        or code_ikey \
-        or env_cs.get(INSTRUMENTATION_KEY) \
-        or env_ikey
-    # The priority of the ingestion endpoint is as follows:
-    # 1. The endpoint explicitly passed in connection string
-    # 2. The endpoint from the connection string in environment variable
-    # 3. The default breeze endpoint
-    endpoint = code_cs.get(INGESTION_ENDPOINT) \
-        or env_cs.get(INGESTION_ENDPOINT) \
-        or 'https://dc.services.visualstudio.com'
-    options.endpoint = endpoint
-
-    # Authorization
-    # `azure.core.credentials.TokenCredential` class must be valid
-    if options.credential and not hasattr(options.credential, 'get_token'):
-        raise ValueError(
-            'Must pass in valid TokenCredential.'
-        )
-
-    # storage path
-    if options.storage_path is None:
-        TEMPDIR_SUFFIX = options.instrumentation_key or ""
-        options.storage_path = os.path.join(
-                tempfile.gettempdir(),
-                TEMPDIR_PREFIX + TEMPDIR_SUFFIX
-            )
-
-    # proxies
-    if options.proxies is None:
-        options.proxies = '{}'
-
-
-def parse_connection_string(connection_string):
-    if connection_string is None:
-        return {}
-    try:
-        pairs = connection_string.split(';')
-        result = dict(s.split('=') for s in pairs)
-        # Convert keys to lower-case due to case type-insensitive checking
-        result = {key.lower(): value for key, value in result.items()}
-    except Exception:
-        raise ValueError('Invalid connection string')
-    # Validate authorization
-    auth = result.get('authorization')
-    if auth is not None and auth.lower() != 'ikey':
-        raise ValueError('Invalid authorization mechanism')
-    # Construct the ingestion endpoint if not passed in explicitly
-    if result.get(INGESTION_ENDPOINT) is None:
-        endpoint_suffix = ''
-        location_prefix = ''
-        suffix = result.get('endpointsuffix')
-        if suffix is not None:
-            endpoint_suffix = suffix
-            # Get regional information if provided
-            prefix = result.get('location')
-            if prefix is not None:
-                location_prefix = prefix + '.'
-            endpoint = 'https://' + location_prefix + 'dc.' + endpoint_suffix
-            result[INGESTION_ENDPOINT] = endpoint
-        else:
-            # Default to None if cannot construct
-            result[INGESTION_ENDPOINT] = None
-    return result
-
-
-class Options(BaseObject):
-    def __init__(self, *args, **kwargs):
-        super(Options, self).__init__(*args, **kwargs)
-        process_options(self)
-
-    _default = BaseObject(
-        connection_string=None,
-        credential=None,  # Credential class used by AAD auth
-        enable_local_storage=True,
-        enable_standard_metrics=True,  # Used by metrics exporter, True to send standard metrics  # noqa: E501
-        endpoint='https://dc.services.visualstudio.com/v2/track',
-        export_interval=15.0,
-        grace_period=5.0,
-        instrumentation_key=None,
-        logging_sampling_rate=1.0,  # Used by log exporter, controls sampling
-        max_batch_size=100,
-        minimum_retry_interval=60,  # minimum retry interval in seconds
-        proxies=None,  # string maps url schemes to the url of the proxies
-        queue_capacity=8192,
-        storage_maintenance_period=60,
-        storage_max_size=50*1024*1024,  # 50MiB
-        storage_path=None,
-        storage_retention_period=7*24*60*60,
-        timeout=10.0,  # networking timeout in seconds
-    )
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+import tempfile
+
+from opencensus.ext.azure.common.protocol import BaseObject
+
+INGESTION_ENDPOINT = 'ingestionendpoint'
+INSTRUMENTATION_KEY = 'instrumentationkey'
+TEMPDIR_PREFIX = "opencensus-python-"
+
+_logger = logging.getLogger(__name__)
+
+
+def process_options(options):
+    # Connection string/ikey
+    code_cs = parse_connection_string(options.connection_string)
+    code_ikey = options.instrumentation_key
+    env_cs = parse_connection_string(
+        os.getenv('APPLICATIONINSIGHTS_CONNECTION_STRING'))
+    env_ikey = os.getenv('APPINSIGHTS_INSTRUMENTATIONKEY')
+
+    # Deprecation note about explicit instrumentation key usage
+    if (not code_cs and code_ikey) or (not env_cs and env_ikey):
+        _logger.warning(
+            "DeprecationWarning: Explicitly using instrumentation key is"
+            "deprecated. Please use a connection string instead."
+        )
+
+    # The priority of which value takes on the instrumentation key is:
+    # 1. Key from explicitly passed in connection string
+    # 2. Key from explicitly passed in instrumentation key
+    # 3. Key from connection string in environment variable
+    # 4. Key from instrumentation key in environment variable
+    options.instrumentation_key = code_cs.get(INSTRUMENTATION_KEY) \
+        or code_ikey \
+        or env_cs.get(INSTRUMENTATION_KEY) \
+        or env_ikey
+    # The priority of the ingestion endpoint is as follows:
+    # 1. The endpoint explicitly passed in connection string
+    # 2. The endpoint from the connection string in environment variable
+    # 3. The default breeze endpoint
+    endpoint = code_cs.get(INGESTION_ENDPOINT) \
+        or env_cs.get(INGESTION_ENDPOINT) \
+        or 'https://dc.services.visualstudio.com'
+    options.endpoint = endpoint
+
+    # Authorization
+    # `azure.core.credentials.TokenCredential` class must be valid
+    if options.credential and not hasattr(options.credential, 'get_token'):
+        raise ValueError(
+            'Must pass in valid TokenCredential.'
+        )
+
+    # storage path
+    if options.storage_path is None:
+        TEMPDIR_SUFFIX = options.instrumentation_key or ""
+        options.storage_path = os.path.join(
+                tempfile.gettempdir(),
+                TEMPDIR_PREFIX + TEMPDIR_SUFFIX
+            )
+
+    # proxies
+    if options.proxies is None:
+        options.proxies = '{}'
+
+
+def parse_connection_string(connection_string):
+    if connection_string is None:
+        return {}
+    try:
+        pairs = connection_string.split(';')
+        result = dict(s.split('=') for s in pairs)
+        # Convert keys to lower-case due to case type-insensitive checking
+        result = {key.lower(): value for key, value in result.items()}
+    except Exception:
+        raise ValueError('Invalid connection string')
+    # Validate authorization
+    auth = result.get('authorization')
+    if auth is not None and auth.lower() != 'ikey':
+        raise ValueError('Invalid authorization mechanism')
+    # Construct the ingestion endpoint if not passed in explicitly
+    if result.get(INGESTION_ENDPOINT) is None:
+        endpoint_suffix = ''
+        location_prefix = ''
+        suffix = result.get('endpointsuffix')
+        if suffix is not None:
+            endpoint_suffix = suffix
+            # Get regional information if provided
+            prefix = result.get('location')
+            if prefix is not None:
+                location_prefix = prefix + '.'
+            endpoint = 'https://' + location_prefix + 'dc.' + endpoint_suffix
+            result[INGESTION_ENDPOINT] = endpoint
+        else:
+            # Default to None if cannot construct
+            result[INGESTION_ENDPOINT] = None
+    return result
+
+
+class Options(BaseObject):
+    def __init__(self, *args, **kwargs):
+        super(Options, self).__init__(*args, **kwargs)
+        process_options(self)
+
+    _default = BaseObject(
+        connection_string=None,
+        credential=None,  # Credential class used by AAD auth
+        enable_local_storage=True,
+        enable_standard_metrics=True,  # Used by metrics exporter, True to send standard metrics  # noqa: E501
+        endpoint='https://dc.services.visualstudio.com/v2/track',
+        export_interval=15.0,
+        grace_period=5.0,
+        instrumentation_key=None,
+        logging_sampling_rate=1.0,  # Used by log exporter, controls sampling
+        max_batch_size=100,
+        minimum_retry_interval=60,  # minimum retry interval in seconds
+        proxies=None,  # string maps url schemes to the url of the proxies
+        queue_capacity=8192,
+        storage_maintenance_period=60,
+        storage_max_size=50*1024*1024,  # 50MiB
+        storage_path=None,
+        storage_retention_period=7*24*60*60,
+        timeout=10.0,  # networking timeout in seconds
+    )