Added Counter backport for Python 2.6. Replaced backend with requests oauth library. Added verify_ssl kwarg for python 2.6 issues with Intuit SSL cert

Author: glenbot

README.md

@@ -10,13 +10,7 @@ pip install python-aggcat
 
 ## Release Notes
 
-**0.2**
- * Cleanup
- * Made end_date an optional parameter in `get_account_transactions` to reflect intuit
- * Added `requirements.pip` file do that docs build correctly on readthedocs.org
-
-**0.1**
- * Initial Release
+[https://aggcat.readthedocs.org/en/latest/#release-notes](https://aggcat.readthedocs.org/en/latest/#release-notes)
 
 ## Full documentation
 

aggcat/client.py

@@ -1,10 +1,9 @@
 from __future__ import absolute_import
 
 import urlparse
-from urllib import urlencode
 
 import requests
-import oauth2
+from requests_oauthlib import OAuth1Session
 from lxml import etree
 
 from .saml import SAML
@@ -15,14 +14,14 @@
 
 
 class AggCatResponse(object):
-    """General response object that contains oAuth2 response object
-    and the content"""
-    def __init__(self, headers, content):
-        self.headers = headers
+    """General response object that contains the HTTP status code
+    and response text"""
+    def __init__(self, status_code, content):
+        self.status_code = status_code
         self.content = content
 
     def __repr__(self):
-        return u'<AggCatResponse %s>' % self.headers.status
+        return u'<AggCatResponse %s>' % self.status_code
 
 
 class AggcatClient(object):
@@ -36,6 +35,7 @@ class AggcatClient(object):
                         testing you can use whatever integer you want.
     :param string private_key: The absolute path to the generated x509 private key
     :param boolean objectify: (optional) Convert XML into pythonic object on every API call. Default: ``True``
+    :param boolean verify_ssl: (optional) Verify SSL Certificate. See :ref:`known_issues`. Default: ``True``
 
     :returns: :class:`AggcatClient`
 
@@ -61,7 +61,7 @@ class AggcatClient(object):
         ``objectify`` (Boolean) This is a BETA functionality. It will objectify the XML returned from
         intuit into standard python objects so you don't have to mess with XML. Default: ``True``
     """
-    def __init__(self, consumer_key, consumer_secret, saml_identity_provider_id, customer_id, private_key, objectify=True):
+    def __init__(self, consumer_key, consumer_secret, saml_identity_provider_id, customer_id, private_key, objectify=True, verify_ssl=True):
         # base API url
         self.base_url = 'https://financialdatafeed.platform.intuit.com/rest-war/v1'
 
@@ -72,6 +72,9 @@ def __init__(self, consumer_key, consumer_secret, saml_identity_provider_id, cus
         self.customer_id = customer_id
         self.private_key = private_key
 
+        # verify ssl
+        self.verify_ssl = verify_ssl
+
         # SAML object to help create SAML assertion message
         self.saml = SAML(private_key, saml_identity_provider_id, customer_id)
 
@@ -88,17 +91,15 @@ def __init__(self, consumer_key, consumer_secret, saml_identity_provider_id, cus
         self.client = self._client()
 
     def _client(self):
-        """Build an oAuth2 client from consumer tokens, and oauth tokens"""
-        consumer = oauth2.Consumer(
-            key=self.consumer_key,
-            secret=self.consumer_secret
-        )
-        token = oauth2.Token(
-            key=self._oauth_tokens['oauth_token'][0],
-            secret=self._oauth_tokens['oauth_token_secret'][0]
+        """Build an oAuth client from consumer tokens, and oauth tokens"""
+        # initialze the oauth session for requests
+        session = OAuth1Session(
+            self.consumer_key,
+            self.consumer_secret,
+            self._oauth_tokens['oauth_token'][0],
+            self._oauth_tokens['oauth_token_secret'][0]
         )
-
-        return oauth2.Client(consumer, token)
+        return session
 
     def _get_oauth_tokens(self):
         """Get an oauth token by sending over the SAML assertion"""
@@ -123,48 +124,51 @@ def _refresh_client(self):
         # get a new client
         self.client = self._client()
 
-    def _build_url(self, path, query):
-        """Build a url from a string path and dict query"""
-        if query:
-            return '%s/%s?%s' % (self.base_url, path, urlencode(query))
-        else:
-            return '%s/%s' % (self.base_url, path)
+    def _build_url(self, path):
+        """Build a url from a string path"""
+        return '%s/%s' % (self.base_url, path)
 
     def _make_request(self, path, method='GET', body=None, query={}, headers={}):
         """Make the signed request to the API"""
-        url = self._build_url(path, query)
+        # build the query url
+        url = self._build_url(path)
 
         # check for plain object request
         return_obj = self.objectify
 
-        if method == 'GET' or method == 'DELETE':
-            response, content = self.client.request(url, method)
-        else:
+        if method == 'GET':
+            response = self.client.get(url, params=query, verify=self.verify_ssl)
+
+        if method == 'PUT':
             headers.update({'Content-Type': 'application/xml'})
-            response, content = self.client.request(
-                url,
-                method=method,
-                body=body,
-                headers=headers,
-                realm=None
-            )
+            response = self.client.put(url, data=body, headers=headers, verify=self.verify_ssl)
+
+        if method == 'DELETE':
+            response = self.client.delete(url, verify=self.verify_ssl)
+
+        if method == 'POST':
+            headers.update({'Content-Type': 'application/xml'})
+            response = self.client.post(url, data=body, headers=headers, verify=self.verify_ssl)
 
         # refresh the token if token expires and retry the query
-        if 'www-authenticate' in response and response['www-authenticate'] == \
-            'OAuth oauth_problem="token_rejected"':
-            self._refresh_client()
-            self._make_request(path, method, body, query, headers)
+        if 'www-authenticate' in response.headers:
+            if response.headers['www-authenticate'] == 'OAuth oauth_problem="token_rejected"':
+                self._refresh_client()
+                self._make_request(path, method, body, query, headers)
 
-        if response.status not in [200, 201, 401]:
-            raise HTTPError('Status Code: %s, Response %s' % (response.status, content,))
+        if response.status_code not in [200, 201, 401]:
+            raise HTTPError('Status Code: %s, Response %s' % (response.status_code, response.text,))
 
         if return_obj:
             try:
-                return AggCatResponse(response, Objectify(content).get_object())
+                return AggCatResponse(
+                    response.status_code,
+                    Objectify(response.content).get_object()
+                )
             except etree.XMLSyntaxError:
                 return None
 
-        return AggCatResponse(response, content)
+        return AggCatResponse(response.status_code, response.content)
 
     def _remove_namespaces(self, tree):
         """Remove the namspaces from the Intuit XML for easier parsing"""

aggcat/counter.py

@@ -0,0 +1,186 @@
+# http://code.activestate.com/recipes/576611-counter-class/
+from operator import itemgetter
+from heapq import nlargest
+from itertools import repeat, ifilter
+
+
+class Counter(dict):
+    '''Dict subclass for counting hashable objects.  Sometimes called a bag
+    or multiset.  Elements are stored as dictionary keys and their counts
+    are stored as dictionary values.
+
+    >>> Counter('zyzygy')
+    Counter({'y': 3, 'z': 2, 'g': 1})
+
+    '''
+
+    def __init__(self, iterable=None, **kwds):
+        '''Create a new, empty Counter object.  And if given, count elements
+        from an input iterable.  Or, initialize the count from another mapping
+        of elements to their counts.
+
+        >>> c = Counter()                           # a new, empty counter
+        >>> c = Counter('gallahad')                 # a new counter from an iterable
+        >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
+        >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
+
+        '''        
+        self.update(iterable, **kwds)
+
+    def __missing__(self, key):
+        return 0
+
+    def most_common(self, n=None):
+        '''List the n most common elements and their counts from the most
+        common to the least.  If n is None, then list all element counts.
+
+        >>> Counter('abracadabra').most_common(3)
+        [('a', 5), ('r', 2), ('b', 2)]
+
+        '''        
+        if n is None:
+            return sorted(self.iteritems(), key=itemgetter(1), reverse=True)
+        return nlargest(n, self.iteritems(), key=itemgetter(1))
+
+    def elements(self):
+        '''Iterator over elements repeating each as many times as its count.
+
+        >>> c = Counter('ABCABC')
+        >>> sorted(c.elements())
+        ['A', 'A', 'B', 'B', 'C', 'C']
+
+        If an element's count has been set to zero or is a negative number,
+        elements() will ignore it.
+
+        '''
+        for elem, count in self.iteritems():
+            for _ in repeat(None, count):
+                yield elem
+
+    # Override dict methods where the meaning changes for Counter objects.
+
+    @classmethod
+    def fromkeys(cls, iterable, v=None):
+        raise NotImplementedError(
+            'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
+
+    def update(self, iterable=None, **kwds):
+        '''Like dict.update() but add counts instead of replacing them.
+
+        Source can be an iterable, a dictionary, or another Counter instance.
+
+        >>> c = Counter('which')
+        >>> c.update('witch')           # add elements from another iterable
+        >>> d = Counter('watch')
+        >>> c.update(d)                 # add elements from another counter
+        >>> c['h']                      # four 'h' in which, witch, and watch
+        4
+
+        '''        
+        if iterable is not None:
+            if hasattr(iterable, 'iteritems'):
+                if self:
+                    self_get = self.get
+                    for elem, count in iterable.iteritems():
+                        self[elem] = self_get(elem, 0) + count
+                else:
+                    dict.update(self, iterable) # fast path when counter is empty
+            else:
+                self_get = self.get
+                for elem in iterable:
+                    self[elem] = self_get(elem, 0) + 1
+        if kwds:
+            self.update(kwds)
+
+    def copy(self):
+        'Like dict.copy() but returns a Counter instance instead of a dict.'
+        return Counter(self)
+
+    def __delitem__(self, elem):
+        'Like dict.__delitem__() but does not raise KeyError for missing values.'
+        if elem in self:
+            dict.__delitem__(self, elem)
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % self.__class__.__name__
+        items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
+        return '%s({%s})' % (self.__class__.__name__, items)
+
+    # Multiset-style mathematical operations discussed in:
+    #       Knuth TAOCP Volume II section 4.6.3 exercise 19
+    #       and at http://en.wikipedia.org/wiki/Multiset
+    #
+    # Outputs guaranteed to only include positive counts.
+    #
+    # To strip negative and zero counts, add-in an empty counter:
+    #       c += Counter()
+
+    def __add__(self, other):
+        '''Add counts from two counters.
+
+        >>> Counter('abbb') + Counter('bcc')
+        Counter({'b': 4, 'c': 2, 'a': 1})
+
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = self[elem] + other[elem]
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __sub__(self, other):
+        ''' Subtract count, but keep only results with positive counts.
+
+        >>> Counter('abbbc') - Counter('bccd')
+        Counter({'b': 2, 'a': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = self[elem] - other[elem]
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __or__(self, other):
+        '''Union is the maximum of value in either of the input counters.
+
+        >>> Counter('abbb') | Counter('bcc')
+        Counter({'b': 3, 'c': 2, 'a': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        _max = max
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = _max(self[elem], other[elem])
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __and__(self, other):
+        ''' Intersection is the minimum of corresponding counts.
+
+        >>> Counter('abbb') & Counter('bcc')
+        Counter({'b': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        _min = min
+        result = Counter()
+        if len(self) < len(other):
+            self, other = other, self
+        for elem in ifilter(self.__contains__, other):
+            newcount = _min(self[elem], other[elem])
+            if newcount > 0:
+                result[elem] = newcount
+        return result

aggcat/docs/requirements.pip

@@ -1,4 +1,4 @@
 lxml==3.2.1
 M2Crypto==0.21.1
 requests==1.2.0
-git+https://github.com/glenbot/python-oauth2.git
+requests-oauthlib==0.3.3

aggcat/docs/source/conf.py

@@ -49,9 +49,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '0.2'
+version = '0.3'
 # The full version, including alpha/beta/rc tags.
-release = '0.2'
+release = '0.3'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

aggcat/docs/source/index.rst

@@ -26,6 +26,13 @@ Installation
     pip install python-aggcat
 
 
+.. _known_issues:
+
+Known Issues
+------------
+
+The SSL library in Python 2.6 and below has a bug and will not parse the ``AlternativeNames`` out of the Intuit SSL cert causing a name mismatch during cetificate validation. For now, please pass ``verify_ssl = False`` to the :class:`AggcatClient` when initializing it. While less secure, I wanted the verification to be turned off explictly so you are aware. If possible, upgrade to Python 2.7+.
+
 Initializing the API Client
 ---------------------------