gam7 7.3.4__py3-none-any.whl

gam/atom/token_store.py

@@ -0,0 +1,105 @@
+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License 2.0;
+
+
+"""This module provides a TokenStore class which is designed to manage
+auth tokens required for different services.
+
+Each token is valid for a set of scopes which is the start of a URL. An HTTP
+client will use a token store to find a valid Authorization header to send
+in requests to the specified URL. If the HTTP client determines that a token
+has expired or been revoked, it can remove the token from the store so that
+it will not be used in future requests.
+"""
+
+# __author__ = 'api.jscudder (Jeff Scudder)'
+
+import atom.http_interface
+import atom.url
+
+SCOPE_ALL = 'http'
+
+
+class TokenStore(object):
+    """Manages Authorization tokens which will be sent in HTTP headers."""
+
+    def __init__(self, scoped_tokens=None):
+        self._tokens = scoped_tokens or {}
+
+    def add_token(self, token):
+        """Adds a new token to the store (replaces tokens with the same scope).
+
+        Args:
+          token: A subclass of http_interface.GenericToken. The token object is
+              responsible for adding the Authorization header to the HTTP request.
+              The scopes defined in the token are used to determine if the token
+              is valid for a requested scope when find_token is called.
+
+        Returns:
+          True if the token was added, False if the token was not added becase
+          no scopes were provided.
+        """
+        if not hasattr(token, 'scopes') or not token.scopes:
+            return False
+
+        for scope in token.scopes:
+            self._tokens[str(scope)] = token
+        return True
+
+    def find_token(self, url):
+        """Selects an Authorization header token which can be used for the URL.
+
+        Args:
+          url: str or atom.url.Url or a list containing the same.
+              The URL which is going to be requested. All
+              tokens are examined to see if any scopes begin match the beginning
+              of the URL. The first match found is returned.
+
+        Returns:
+          The token object which should execute the HTTP request. If there was
+          no token for the url (the url did not begin with any of the token
+          scopes available), then the atom.http_interface.GenericToken will be
+          returned because the GenericToken calls through to the http client
+          without adding an Authorization header.
+        """
+        if url is None:
+            return None
+        if isinstance(url, str):
+            url = atom.url.parse_url(url)
+        if url in self._tokens:
+            token = self._tokens[url]
+            if token.valid_for_scope(url):
+                return token
+            else:
+                del self._tokens[url]
+        for scope, token in self._tokens.items():
+            if token.valid_for_scope(url):
+                return token
+        return atom.http_interface.GenericToken()
+
+    def remove_token(self, token):
+        """Removes the token from the token_store.
+
+        This method is used when a token is determined to be invalid. If the
+        token was found by find_token, but resulted in a 401 or 403 error stating
+        that the token was invlid, then the token should be removed to prevent
+        future use.
+
+        Returns:
+          True if a token was found and then removed from the token
+          store. False if the token was not in the TokenStore.
+        """
+        token_found = False
+        scopes_to_delete = []
+        for scope, stored_token in self._tokens.items():
+            if stored_token == token:
+                scopes_to_delete.append(scope)
+                token_found = True
+        for scope in scopes_to_delete:
+            del self._tokens[scope]
+        return token_found
+
+    def remove_all_tokens(self):
+        self._tokens = {}

gam/atom/url.py

@@ -0,0 +1,130 @@
+#
+# Copyright (C) 2008 Google Inc.
+#
+# Licensed under the Apache License 2.0;
+
+
+
+# __author__ = 'api.jscudder (Jeff Scudder)'
+
+import urllib.error
+import urllib.parse
+import urllib.parse
+import urllib.request
+
+DEFAULT_PROTOCOL = 'http'
+DEFAULT_PORT = 80
+
+
+def parse_url(url_string):
+    """Creates a Url object which corresponds to the URL string.
+
+    This method can accept partial URLs, but it will leave missing
+    members of the Url unset.
+    """
+    parts = urllib.parse.urlparse(url_string)
+    url = Url()
+    if parts[0]:
+        url.protocol = parts[0]
+    if parts[1]:
+        host_parts = parts[1].split(':')
+        if host_parts[0]:
+            url.host = host_parts[0]
+        if len(host_parts) > 1:
+            url.port = host_parts[1]
+    if parts[2]:
+        url.path = parts[2]
+    if parts[4]:
+        param_pairs = parts[4].split('&')
+        for pair in param_pairs:
+            pair_parts = pair.split('=')
+            if len(pair_parts) > 1:
+                url.params[urllib.parse.unquote_plus(pair_parts[0])] = (
+                    urllib.parse.unquote_plus(pair_parts[1]))
+            elif len(pair_parts) == 1:
+                url.params[urllib.parse.unquote_plus(pair_parts[0])] = None
+    return url
+
+
+class Url(object):
+    """Represents a URL and implements comparison logic.
+
+    URL strings which are not identical can still be equivalent, so this object
+    provides a better interface for comparing and manipulating URLs than
+    strings. URL parameters are represented as a dictionary of strings, and
+    defaults are used for the protocol (http) and port (80) if not provided.
+    """
+
+    def __init__(self, protocol=None, host=None, port=None, path=None,
+                 params=None):
+        self.protocol = protocol
+        self.host = host
+        self.port = port
+        self.path = path
+        self.params = params or {}
+
+    def to_string(self):
+        url_parts = ['', '', '', '', '', '']
+        if self.protocol:
+            url_parts[0] = self.protocol
+        if self.host:
+            if self.port:
+                url_parts[1] = ':'.join((self.host, str(self.port)))
+            else:
+                url_parts[1] = self.host
+        if self.path:
+            url_parts[2] = self.path
+        if self.params:
+            url_parts[4] = self.get_param_string()
+        return urllib.parse.urlunparse(url_parts)
+
+    def get_param_string(self):
+        param_pairs = []
+        for key, value in self.params.items():
+            param_pairs.append('='.join((urllib.parse.quote_plus(key),
+                                         urllib.parse.quote_plus(str(value)))))
+        return '&'.join(param_pairs)
+
+    def get_request_uri(self):
+        """Returns the path with the parameters escaped and appended."""
+        param_string = self.get_param_string()
+        if param_string:
+            return '?'.join([self.path, param_string])
+        else:
+            return self.path
+
+    def __cmp__(self, other):
+        if not isinstance(other, Url):
+            return cmp(self.to_string(), str(other))
+        difference = 0
+        # Compare the protocol
+        if self.protocol and other.protocol:
+            difference = cmp(self.protocol, other.protocol)
+        elif self.protocol and not other.protocol:
+            difference = cmp(self.protocol, DEFAULT_PROTOCOL)
+        elif not self.protocol and other.protocol:
+            difference = cmp(DEFAULT_PROTOCOL, other.protocol)
+        if difference != 0:
+            return difference
+        # Compare the host
+        difference = cmp(self.host, other.host)
+        if difference != 0:
+            return difference
+        # Compare the port
+        if self.port and other.port:
+            difference = cmp(self.port, other.port)
+        elif self.port and not other.port:
+            difference = cmp(self.port, DEFAULT_PORT)
+        elif not self.port and other.port:
+            difference = cmp(DEFAULT_PORT, other.port)
+        if difference != 0:
+            return difference
+        # Compare the path
+        difference = cmp(self.path, other.path)
+        if difference != 0:
+            return difference
+        # Compare the parameters
+        return cmp(self.params, other.params)
+
+    def __str__(self):
+        return self.to_string()