Moving to a client model like intercom-ruby.

Author: jkeyes

intercom/__init__.py

@@ -1,32 +1,12 @@
 # -*- coding: utf-8 -*-
 
-from datetime import datetime
+# from datetime import datetime
 from .errors import (ArgumentError, AuthenticationError, # noqa
     BadGatewayError, BadRequestError, HttpError, IntercomError,
     MultipleMatchingUsersError, RateLimitExceeded, ResourceNotFound,
     ServerError, ServiceUnavailableError, UnexpectedError)
-from .lib.setter_property import SetterProperty
-from .request import Request
-from .admin import Admin  # noqa
-from .company import Company  # noqa
-from .count import Count  # noqa
-from .conversation import Conversation  # noqa
-from .event import Event  # noqa
-from .message import Message  # noqa
-from .note import Note  # noqa
-from .notification import Notification  # noqa
-from .user import User  # noqa
-from .segment import Segment  # noqa
-from .subscription import Subscription  # noqa
-from .tag import Tag  # noqa
 
-import copy
-import random
-import re
-import six
-import time
-
-__version__ = '2.1.1'
+__version__ = '3.0-dev'
 
 
 RELATED_DOCS_TEXT = "See https://github.com/jkeyes/python-intercom \
@@ -38,142 +18,3 @@
 Intercom.app_api_key and don't set Intercom.api_key."
 CONFIGURATION_REQUIRED_TEXT = "You must set both Intercom.app_id and \
 Intercom.app_api_key to use this client."
-
-
-class IntercomType(type):  # noqa
-
-    app_id = None
-    app_api_key = None
-    _hostname = "api.intercom.io"
-    _protocol = "https"
-    _endpoints = None
-    _current_endpoint = None
-    _target_base_url = None
-    _endpoint_randomized_at = 0
-    _rate_limit_details = {}
-
-    @property
-    def _auth(self):
-        return (self.app_id, self.app_api_key)
-
-    @property
-    def _random_endpoint(self):
-        if self.endpoints:
-            endpoints = copy.copy(self.endpoints)
-            random.shuffle(endpoints)
-            return endpoints[0]
-
-    @property
-    def _alternative_random_endpoint(self):
-        endpoints = copy.copy(self.endpoints)
-        if self.current_endpoint in endpoints:
-            endpoints.remove(self.current_endpoint)
-        random.shuffle(endpoints)
-        if endpoints:
-            return endpoints[0]
-
-    @property
-    def target_base_url(self):
-        if None in [self.app_id, self.app_api_key]:
-            raise ArgumentError('%s %s' % (
-                CONFIGURATION_REQUIRED_TEXT, RELATED_DOCS_TEXT))
-        if self._target_base_url is None:
-            basic_auth_part = '%s:%s@' % (self.app_id, self.app_api_key)
-            if self.current_endpoint:
-                self._target_base_url = re.sub(
-                    r'(https?:\/\/)(.*)',
-                    '\g<1>%s\g<2>' % (basic_auth_part),
-                    self.current_endpoint)
-        return self._target_base_url
-
-    @property
-    def hostname(self):
-        return self._hostname
-
-    @hostname.setter
-    def hostname(self, value):
-        self._hostname = value
-        self.current_endpoint = None
-        self.endpoints = None
-
-    @property
-    def rate_limit_details(self):
-        return self._rate_limit_details
-
-    @rate_limit_details.setter
-    def rate_limit_details(self, value):
-        self._rate_limit_details = value
-
-    @property
-    def protocol(self):
-        return self._protocol
-
-    @protocol.setter
-    def protocol(self, value):
-        self._protocol = value
-        self.current_endpoint = None
-        self.endpoints = None
-
-    @property
-    def current_endpoint(self):
-        now = time.mktime(datetime.utcnow().timetuple())
-        expired = self._endpoint_randomized_at < (now - (60 * 5))
-        if self._endpoint_randomized_at is None or expired:
-            self._endpoint_randomized_at = now
-            self._current_endpoint = self._random_endpoint
-        return self._current_endpoint
-
-    @current_endpoint.setter
-    def current_endpoint(self, value):
-        self._current_endpoint = value
-        self._target_base_url = None
-
-    @property
-    def endpoints(self):
-        if not self._endpoints:
-            return ['%s://%s' % (self.protocol, self.hostname)]
-        else:
-            return self._endpoints
-
-    @endpoints.setter
-    def endpoints(self, value):
-        self._endpoints = value
-        self.current_endpoint = self._random_endpoint
-
-    @SetterProperty
-    def endpoint(self, value):
-        self.endpoints = [value]
-
-
-@six.add_metaclass(IntercomType)
-class Intercom(object):
-    _class_register = {}
-
-    @classmethod
-    def get_url(cls, path):
-        if '://' in path:
-            url = path
-        else:
-            url = cls.current_endpoint + path
-        return url
-
-    @classmethod
-    def request(cls, method, path, params):
-        return Request.send_request_to_path(
-            method, cls.get_url(path), cls._auth, params)
-
-    @classmethod
-    def get(cls, path, **params):
-        return cls.request('GET', path, params)
-
-    @classmethod
-    def post(cls, path, **params):
-        return cls.request('POST', path, params)
-
-    @classmethod
-    def put(cls, path, **params):
-        return cls.request('PUT', path, params)
-
-    @classmethod
-    def delete(cls, path, **params):
-        return cls.request('DELETE', path, params)

intercom/admin.py

@@ -1,9 +1,7 @@
 # -*- coding: utf-8 -*-
 
-from intercom.api_operations.all import All
-from intercom.api_operations.find import Find
 from intercom.traits.api_resource import Resource
 
 
-class Admin(Resource, Find, All):
+class Admin(Resource):
     pass

intercom/api_operations/all.py

@@ -6,8 +6,9 @@
 
 class All(object):
 
-    @classmethod
-    def all(cls):
-        collection = utils.resource_class_to_collection_name(cls)
+    def all(self):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
         finder_url = "/%s" % (collection)
-        return CollectionProxy(cls, collection, finder_url)
+        return CollectionProxy(
+            self.client, self.collection_class, collection, finder_url)

intercom/api_operations/delete.py

@@ -5,8 +5,8 @@
 
 class Delete(object):
 
-    def delete(self):
-        from intercom import Intercom
-        collection = utils.resource_class_to_collection_name(self.__class__)
-        Intercom.delete("/%s/%s/" % (collection, self.id))
-        return self
+    def delete(self, obj):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
+        self.client.delete("/%s/%s/" % (collection, obj.id))
+        return obj

intercom/api_operations/find.py

@@ -6,16 +6,16 @@
 
 class Find(object):
 
-    @classmethod
-    def find(cls, **params):
-        from intercom import Intercom
-        collection = utils.resource_class_to_collection_name(cls)
+    def find(self, **params):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
         if 'id' in params:
-            response = Intercom.get("/%s/%s" % (collection, params['id']))
+            response = self.client.get(
+                "/%s/%s" % (collection, params['id']), {})
         else:
-            response = Intercom.get("/%s" % (collection), **params)
+            response = self.client.get("/%s" % (collection), params)
 
         if response is None:
             raise HttpError('Http Error - No response entity returned')
 
-        return cls(**response)
+        return self.collection_class(**response)

intercom/api_operations/find_all.py

@@ -6,12 +6,14 @@
 
 class FindAll(object):
 
-    @classmethod
-    def find_all(cls, **params):
-        collection = utils.resource_class_to_collection_name(cls)
+    def find_all(self, **params):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
         if 'id' in params and 'type' not in params:
             finder_url = "/%s/%s" % (collection, params['id'])
         else:
             finder_url = "/%s" % (collection)
         finder_params = params
-        return CollectionProxy(cls, collection, finder_url, finder_params)
+        return CollectionProxy(
+            self.client, self.collection_class, collection,
+            finder_url, finder_params)

intercom/api_operations/load.py

@@ -6,17 +6,19 @@
 
 class Load(object):
 
-    def load(self):
-        from intercom import Intercom
-        cls = self.__class__
-        collection = utils.resource_class_to_collection_name(cls)
-        if hasattr(self, 'id'):
-            response = Intercom.get("/%s/%s" % (collection, self.id))
+    def load(self, resource):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
+        print "RESOURCE", resource, hasattr(resource, 'id')
+        if hasattr(resource, 'id'):
+            response = self.client.get("/%s/%s" % (collection, resource.id), {})  # noqa
+            print "RESPONSE", response
         else:
             raise Exception(
-                "Cannot load %s as it does not have a valid id." % (cls))
+                "Cannot load %s as it does not have a valid id." % (
+                    self.collection_class))
 
         if response is None:
             raise HttpError('Http Error - No response entity returned')
 
-        return cls(**response)
+        return resource.from_response(response)

intercom/api_operations/save.py

@@ -5,50 +5,49 @@
 
 class Save(object):
 
-    @classmethod
-    def create(cls, **params):
-        from intercom import Intercom
-        collection = utils.resource_class_to_collection_name(cls)
-        response = Intercom.post("/%s/" % (collection), **params)
+    def create(self, **params):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
+        response = self.client.post("/%s/" % (collection), params)
         if response:  # may be empty if we received a 202
-            return cls(**response)
+            return self.collection_class(**response)
 
-    def from_dict(self, pdict):
-        for key, value in list(pdict.items()):
-            setattr(self, key, value)
+    # def from_dict(self, pdict):
+    #     for key, value in list(pdict.items()):
+    #         setattr(self, key, value)
 
-    @property
-    def to_dict(self):
-        a_dict = {}
-        for name in list(self.__dict__.keys()):
-            if name == "changed_attributes":
-                continue
-            a_dict[name] = self.__dict__[name]  # direct access
-        return a_dict
+    # @property
+    # def to_dict(self):
+    #     a_dict = {}
+    #     for name in list(self.__dict__.keys()):
+    #         if name == "changed_attributes":
+    #             continue
+    #         a_dict[name] = self.__dict__[name]  # direct access
+    #     return a_dict
 
-    @classmethod
-    def from_api(cls, response):
-        obj = cls()
-        obj.from_response(response)
-        return obj
+    # @classmethod
+    # def from_api(cls, response):
+    #     obj = cls()
+    #     obj.from_response(response)
+    #     return obj
 
-    def from_response(self, response):
-        self.from_dict(response)
-        return self
+    # def from_response(self, response):
+    #     self.from_dict(response)
+    #     return self
 
-    def save(self):
-        from intercom import Intercom
-        collection = utils.resource_class_to_collection_name(self.__class__)
-        params = self.attributes
-        if self.id_present and not self.posted_updates:
+    def save(self, obj):
+        collection = utils.resource_class_to_collection_name(
+            self.collection_class)
+        params = obj.attributes
+        if hasattr(obj, 'id_present') and not hasattr(obj, 'posted_updates'):
             # update
-            response = Intercom.put('/%s/%s' % (collection, self.id), **params)
+            response = self.client.put('/%s/%s' % (collection, obj.id), params)
         else:
             # create
-            params.update(self.identity_hash)
-            response = Intercom.post('/%s' % (collection), **params)
+            params.update(self.identity_hash(obj))
+            response = self.client.post('/%s' % (collection), params)
         if response:
-            return self.from_response(response)
+            return obj.from_response(response)
 
     @property
     def id_present(self):
@@ -58,12 +57,11 @@ def id_present(self):
     def posted_updates(self):
         return getattr(self, 'update_verb', None) == 'post'
 
-    @property
-    def identity_hash(self):
-        identity_vars = getattr(self, 'identity_vars', [])
+    def identity_hash(self, obj):
+        identity_vars = getattr(obj, 'identity_vars', [])
         parts = {}
         for var in identity_vars:
-            id_var = getattr(self, var, None)
+            id_var = getattr(obj, var, None)
             if id_var:  # only present id var if it is not blank or None
                 parts[var] = id_var
         return parts