Merge pull request #53 from CiscoDevNet/feature-51-refactor-data-models

Feature 51 refactor data models - All tests passing!

ciscosparkapi/__init__.py

@@ -2,71 +2,51 @@
 """Python API wrapper for the Cisco Spark APIs."""
 
 
-# Use future for Python v2 and v3 compatibility
 from __future__ import (
     absolute_import,
     division,
     print_function,
     unicode_literals,
 )
-from builtins import *
-from past.builtins import basestring
-
-
-__author__ = "Chris Lunsford"
-__author_email__ = "chrlunsf@cisco.com"
-__copyright__ = "Copyright (c) 2016-2018 Cisco and/or its affiliates."
-__license__ = "MIT"
-__all__ = [
-    "CiscoSparkAPI", "ciscosparkapiException", "SparkApiError",
-    "SparkRateLimitError", "Person", "Room", "Membership", "Message", "Team",
-    "TeamMembership", "Webhook", "WebhookEvent", "Organization", "License",
-    "Role", "AccessToken"
-]
-
 
+from builtins import *
 import logging
 import os
 
-from .api.people import Person
-from .api.rooms import Room
-from .api.memberships import Membership
-from .api.messages import Message
-from .api.teams import Team
-from .api.team_memberships import TeamMembership
-from .api.webhooks import Webhook, WebhookEvent
-from .api.organizations import Organization
-from .api.licenses import License
-from .api.roles import Role
-from .api.access_tokens import AccessToken
+from past.builtins import basestring
 
-from .api.people import PeopleAPI as _PeopleAPI
-from .api.rooms import RoomsAPI as _RoomsAPI
+from .api.access_tokens import AccessTokensAPI as _AccessTokensAPI
+from .api.licenses import LicensesAPI as _LicensesAPI
 from .api.memberships import MembershipsAPI as _MembershipsAPI
 from .api.messages import MessagesAPI as _MessagesAPI
-from .api.teams import TeamsAPI as _TeamsAPI
-from .api.team_memberships import TeamMembershipsAPI as _TeamMembershipsAPI
-from .api.webhooks import WebhooksAPI as _WebhooksAPI
 from .api.organizations import OrganizationsAPI as _OrganizationsAPI
-from .api.licenses import LicensesAPI as _LicensesAPI
+from .api.people import PeopleAPI as _PeopleAPI
 from .api.roles import RolesAPI as _RolesAPI
-from .api.access_tokens import AccessTokensAPI as _AccessTokensAPI
-
+from .api.rooms import RoomsAPI as _RoomsAPI
+from .api.team_memberships import TeamMembershipsAPI as _TeamMembershipsAPI
+from .api.teams import TeamsAPI as _TeamsAPI
+from .api.webhooks import WebhooksAPI as _WebhooksAPI
 from .exceptions import (
-    ciscosparkapiException,
-    SparkApiError,
-    SparkRateLimitError,
+    SparkApiError, SparkRateLimitError, ciscosparkapiException,
+)
+from .models import (
+    AccessToken, License, Membership, Message, Organization, Person, Role,
+    Room, Team, TeamMembership, Webhook, WebhookEvent, sparkdata_factory,
 )
-
 from .restsession import (
     DEFAULT_SINGLE_REQUEST_TIMEOUT,
     DEFAULT_WAIT_ON_RATE_LIMIT,
     RestSession as _RestSession,
 )
-
 from .utils import check_type
 
 
+__author__ = "Chris Lunsford"
+__author_email__ = "chrlunsf@cisco.com"
+__copyright__ = "Copyright (c) 2016-2018 Cisco and/or its affiliates."
+__license__ = "MIT"
+
+
 # Versioneer version control
 from ._version import get_versions
 __version__ = get_versions()['version']
@@ -94,34 +74,35 @@ class CiscoSparkAPI(object):
     CiscoSparkAPI wraps all of the individual Cisco Spark APIs and represents
     them in a simple hierarchical structure.
 
-    :CiscoSparkAPI: :class:`people <PeopleAPI>`
+    :CiscoSparkAPI: :class:`people <_PeopleAPI>`
 
-                    :class:`rooms <RoomsAPI>`
+                    :class:`rooms <_RoomsAPI>`
 
-                    :class:`memberships <MembershipsAPI>`
+                    :class:`memberships <_MembershipsAPI>`
 
-                    :class:`messages <MessagesAPI>`
+                    :class:`messages <_MessagesAPI>`
 
-                    :class:`teams <TeamsAPI>`
+                    :class:`teams <_TeamsAPI>`
 
-                    :class:`team_memberships <TeamMembershipsAPI>`
+                    :class:`team_memberships <_TeamMembershipsAPI>`
 
-                    :class:`webhooks <WebhooksAPI>`
+                    :class:`webhooks <_WebhooksAPI>`
 
-                    :class:`organizations <OrganizationsAPI>`
+                    :class:`organizations <_OrganizationsAPI>`
 
-                    :class:`licenses <LicensesAPI>`
+                    :class:`licenses <_LicensesAPI>`
 
-                    :class:`roles <RolesAPI>`
+                    :class:`roles <_RolesAPI>`
 
-                    :class:`access_tokens <AccessTokensAPI>`
+                    :class:`access_tokens <_AccessTokensAPI>`
 
     """
 
     def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,
                  timeout=None,
                  single_request_timeout=DEFAULT_SINGLE_REQUEST_TIMEOUT,
-                 wait_on_rate_limit=DEFAULT_WAIT_ON_RATE_LIMIT):
+                 wait_on_rate_limit=DEFAULT_WAIT_ON_RATE_LIMIT,
+                 object_factory=sparkdata_factory):
         """Create a new CiscoSparkAPI object.
 
         An access token must be used when interacting with the Cisco Spark API.
@@ -150,6 +131,8 @@ def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,
                 ciscosparkapi.DEFAULT_SINGLE_REQUEST_TIMEOUT.
             wait_on_rate_limit(bool): Enables or disables automatic rate-limit
                 handling. Defaults to ciscosparkapi.DEFAULT_WAIT_ON_RATE_LIMIT.
+            object_factory(callable): The factory function to use to create
+                Python objects from the returned Cisco Spark JSON data objects.
 
         Returns:
             CiscoSparkAPI: A new CiscoSparkAPI object.
@@ -188,17 +171,21 @@ def __init__(self, access_token=None, base_url=DEFAULT_BASE_URL,
         )
 
         # Spark API wrappers
-        self.people = _PeopleAPI(self._session)
-        self.rooms = _RoomsAPI(self._session)
-        self.memberships = _MembershipsAPI(self._session)
-        self.messages = _MessagesAPI(self._session)
-        self.teams = _TeamsAPI(self._session)
-        self.team_memberships = _TeamMembershipsAPI(self._session)
-        self.webhooks = _WebhooksAPI(self._session)
-        self.organizations = _OrganizationsAPI(self._session)
-        self.licenses = _LicensesAPI(self._session)
-        self.roles = _RolesAPI(self._session)
-        self.access_tokens = _AccessTokensAPI(self.base_url, timeout=timeout)
+        self.people = _PeopleAPI(self._session, object_factory)
+        self.rooms = _RoomsAPI(self._session, object_factory)
+        self.memberships = _MembershipsAPI(self._session, object_factory)
+        self.messages = _MessagesAPI(self._session, object_factory)
+        self.teams = _TeamsAPI(self._session, object_factory)
+        self.team_memberships = _TeamMembershipsAPI(
+            self._session, object_factory
+        )
+        self.webhooks = _WebhooksAPI(self._session, object_factory)
+        self.organizations = _OrganizationsAPI(self._session, object_factory)
+        self.licenses = _LicensesAPI(self._session, object_factory)
+        self.roles = _RolesAPI(self._session, object_factory)
+        self.access_tokens = _AccessTokensAPI(
+            self.base_url, object_factory, timeout=single_request_timeout
+        )
 
     @property
     def access_token(self):

ciscosparkapi/api/access_tokens.py

@@ -1,40 +1,24 @@
 # -*- coding: utf-8 -*-
-"""Cisco Spark Access-Tokens API wrapper.
+"""Cisco Spark Access-Tokens API."""
 
-Classes:
-    AccessToken: Models a Spark 'access token' JSON object as a native Python
-        object.
-    AccessTokensAPI: Wraps the Cisco Spark Access-Tokens API and exposes the
-        API as native Python methods that return native Python objects.
 
-"""
-
-
-# Use future for Python v2 and v3 compatibility
 from __future__ import (
     absolute_import,
     division,
     print_function,
     unicode_literals,
 )
-from builtins import *
-from past.builtins import basestring
+
 from future import standard_library
 standard_library.install_aliases()
 
-
-__author__ = "Chris Lunsford"
-__author_email__ = "chrlunsf@cisco.com"
-__copyright__ = "Copyright (c) 2016-2018 Cisco and/or its affiliates."
-__license__ = "MIT"
-
-
+from builtins import *
 import urllib.parse
 
+from past.builtins import basestring
 import requests
 
 from ..response_codes import EXPECTED_RESPONSE_CODE
-from ..sparkdata import SparkData
 from ..utils import (
     check_response_code,
     check_type,
@@ -44,54 +28,27 @@
 )
 
 
-API_ENDPOINT = "access_token"
-
-
-class AccessToken(SparkData):
-    """Model a Spark 'access token' JSON object as a native Python object."""
-
-    def __init__(self, json):
-        """Init a new AccessToken data object from a dictionary or JSON string.
-
-        Args:
-            json(dict, basestring): Input dictionary or JSON string.
-
-        Raises:
-            TypeError: If the input object is not a dictionary or string.
-
-        """
-        super(AccessToken, self).__init__(json)
+__author__ = "Chris Lunsford"
+__author_email__ = "chrlunsf@cisco.com"
+__copyright__ = "Copyright (c) 2016-2018 Cisco and/or its affiliates."
+__license__ = "MIT"
 
-    @property
-    def access_token(self):
-        """Cisco Spark access token."""
-        return self._json_data.get('access_token')
 
-    @property
-    def expires_in(self):
-        """Access token expiry time (in seconds)."""
-        return self._json_data.get('expires_in')
 
-    @property
-    def refresh_token(self):
-        """Refresh token used to request a new/refreshed access token."""
-        return self._json_data.get('refresh_token')
 
-    @property
-    def refresh_token_expires_in(self):
-        """Refresh token expiry time (in seconds)."""
-        return self._json_data.get('refresh_token_expires_in')
+API_ENDPOINT = 'access_token'
+OBJECT_TYPE = 'access_token'
 
 
 class AccessTokensAPI(object):
-    """Cisco Spark Access-Tokens API wrapper.
+    """Cisco Spark Access-Tokens API.
 
     Wraps the Cisco Spark Access-Tokens API and exposes the API as native
     Python methods that return native Python objects.
 
     """
 
-    def __init__(self, base_url, timeout=None):
+    def __init__(self, base_url, object_factory, timeout=None):
         """Initialize an AccessTokensAPI object with the provided RestSession.
 
         Args:
@@ -112,6 +69,8 @@ def __init__(self, base_url, timeout=None):
         self._endpoint_url = urllib.parse.urljoin(self.base_url, API_ENDPOINT)
         self._request_kwargs = {"timeout": timeout}
 
+        self._object_factory = object_factory
+
     @property
     def base_url(self):
         """The base URL the API endpoints."""
@@ -138,7 +97,7 @@ def get(self, client_id, client_secret, code, redirect_uri):
                 process.
 
         Returns:
-            AccessToken: An AccessToken object with the access token provided
+            ciscosparkapi.AccessToken: An AccessToken object with the access token provided
                 by the Cisco Spark cloud.
 
         Raises:
@@ -165,8 +124,8 @@ def get(self, client_id, client_secret, code, redirect_uri):
         check_response_code(response, EXPECTED_RESPONSE_CODE['POST'])
         json_data = extract_and_parse_json(response)
 
-        # Return a AccessToken object created from the response JSON data
-        return AccessToken(json_data)
+        # Return a access_token object created from the response JSON data
+        return self._object_factory(OBJECT_TYPE, json_data)
 
     def refresh(self, client_id, client_secret, refresh_token):
         """Return a refreshed Access Token from the provided refresh_token.
@@ -205,4 +164,4 @@ def refresh(self, client_id, client_secret, refresh_token):
         json_data = extract_and_parse_json(response)
 
         # Return a AccessToken object created from the response JSON data
-        return AccessToken(json_data)
+        return self._object_factory(OBJECT_TYPE, json_data)