tap-asana 2.3.0__tar.gz → 2.4.0__tar.gz

{tap-asana-2.3.0/tap_asana.egg-info → tap_asana-2.4.0}/PKG-INFO

@@ -1,16 +1,22 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: tap-asana
-Version: 2.3.0
+Version: 2.4.0
 Summary: Singer.io tap for extracting Asana data
 Home-page: http://github.com/singer-io/tap-asana
 Author: Stitch
 Classifier: Programming Language :: Python :: 3 :: Only
 License-File: LICENSE
-Requires-Dist: asana==3.1.0
-Requires-Dist: singer-python==5.13.0
+Requires-Dist: asana==5.1.0
+Requires-Dist: requests==2.32.4
+Requires-Dist: singer-python==6.1.1
 Provides-Extra: test
 Requires-Dist: pylint; extra == "test"
-Requires-Dist: requests==2.20.0; extra == "test"
-Requires-Dist: nose; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ipdb; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary

{tap-asana-2.3.0 → tap_asana-2.4.0}/setup.py

@@ -3,24 +3,23 @@ from setuptools import setup
 
 setup(
     name="tap-asana",
-    version="2.3.0",
+    version="2.4.0",
     description="Singer.io tap for extracting Asana data",
     author="Stitch",
     url="http://github.com/singer-io/tap-asana",
     classifiers=["Programming Language :: Python :: 3 :: Only"],
     py_modules=["tap_asana"],
     install_requires=[
-        "asana==3.1.0",
-        'singer-python==5.13.0'
+        "asana==5.1.0",
+        "requests==2.32.4",
+        "singer-python==6.1.1"
     ],
     extras_require={
-        'test': [
-            'pylint',
-            'requests==2.20.0',
-            'nose'
+        "test": [
+            "pylint"
         ],
-        'dev': [
-            'ipdb'
+        "dev": [
+            "ipdb"
         ]
     },
     entry_points="""

tap_asana-2.4.0/tap_asana/asana.py

@@ -0,0 +1,67 @@
+import asana
+import singer
+import requests
+
+LOGGER = singer.get_logger()
+
+
+""" Simple wrapper for Asana. """
+
+
+# pylint: disable=too-many-positional-arguments
+class Asana():
+    """Base class for tap-asana"""
+
+    def __init__(
+        self, client_id, client_secret, redirect_uri, refresh_token, access_token=None
+    ):  # pylint: disable=too-many-arguments
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.redirect_uri = redirect_uri
+        self.refresh_token = refresh_token
+        self.access_token = access_token
+        self._client = self._access_token_auth()
+
+    def _access_token_auth(self):
+        """Check for access token"""
+        if self.access_token is None:
+            self.access_token = self.refresh_access_token()
+
+        if self.access_token:
+            try:
+                configuration = asana.Configuration()
+                configuration.access_token = self.access_token
+                return asana.ApiClient(configuration)
+            except asana.rest.ApiException as e:
+                LOGGER.error("Error creating Asana client: %s", e)
+        return None
+
+    def refresh_access_token(self):
+        """Get the access token using the refresh token"""
+        url = "https://app.asana.com/-/oauth_token"
+        payload = {
+            "grant_type": "refresh_token",
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "redirect_uri": self.redirect_uri,
+            "refresh_token": self.refresh_token,
+        }
+
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+        try:
+            response = requests.post(url, data=payload, headers=headers, timeout=30)
+
+            if response.status_code == 200:
+                LOGGER.debug("Access token refreshed successfully.")
+                if "access_token" in response.json():
+                    self.access_token = response.json()["access_token"]
+                    return response.json()["access_token"]
+            return None
+        except requests.exceptions.RequestException as e:
+            LOGGER.error("Failed to refresh access token: %s", e)
+            return None
+
+    @property
+    def client(self):
+        return self._client

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/schemas/portfolios.json

@@ -466,7 +466,7 @@
                 ]
               }
             }
-          }    
+          }
         }
       }
     },
@@ -645,7 +645,7 @@
             "string"
           ]
         }
-      }      
+      }
     },
     "custom_fields": {
       "type": [
@@ -872,6 +872,57 @@
         "null",
         "boolean"
       ]
+    },
+    "archived": {
+      "type": [
+        "null",
+        "boolean"
+      ]
+    },
+    "default_access_level": {
+      "type": [
+        "null",
+        "string"
+      ]
+    },
+    "privacy_setting": {
+      "type": [
+        "null",
+        "string"
+      ]
+    },
+    "project_templates": {
+      "type": [
+        "null",
+        "array"
+      ],
+      "items": {
+        "type": [
+          "null",
+          "object"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "gid": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "resource_type": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      }
     }
   }
 }

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/schemas/projects.json

@@ -940,7 +940,7 @@
                 ]
               }
             }
-          }    
+          }
         }
       }
     },

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/schemas/stories.json

@@ -1218,6 +1218,12 @@
         "null",
         "string"
       ]
+    },
+    "new_approval_status_updated": {
+      "type": [
+        "null",
+        "string"
+      ]
     }
   }
 }

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/schemas/teams.json

@@ -106,6 +106,30 @@
         "null",
         "string"
       ]
+    },
+    "edit_team_name_or_description_access_level": {
+      "type": ["null", "string"]
+    },
+    "edit_team_visibility_or_trash_team_access_level": {
+      "type": ["null", "string"]
+    },
+    "member_invite_management_access_level": {
+      "type": ["null", "string"]
+    },
+    "guest_invite_management_access_level": {
+      "type": ["null", "string"]
+    },
+    "join_request_management_access_level": {
+      "type": ["null", "string"]
+    },
+    "team_member_removal_access_level": {
+      "type": ["null", "string"]
+    },
+    "team_content_management_access_level": {
+      "type": ["null", "string"]
+    },
+    "endorsed": {
+      "type": ["null", "boolean"]
     }
   }
 }

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/streams/base.py

@@ -2,18 +2,11 @@ import math
 import functools
 import sys
 
+import asana
 import requests
 import backoff
 import simplejson
 import singer
-from asana.error import (
-    NoAuthorizationError,
-    RetryableAsanaError,
-    InvalidTokenError,
-    RateLimitEnforcedError,
-)
-from asana.page_iterator import CollectionPageIterator
-from oauthlib.oauth2 import TokenExpiredError
 from singer import utils
 from tap_asana.context import Context
 
@@ -61,14 +54,19 @@ def retry_handler(details):
 
 # pylint: disable=unused-argument
 def retry_after_wait_gen(**kwargs):
+    """Generator to handle Retry-After logic for HTTP 429 errors."""
     # This is called in an except block so we can retrieve the exception
     # and check it.
     exc_info = sys.exc_info()
-    resp = exc_info[1].response
-    # Retry-After is an undocumented header. But honoring
-    # it was proven to work in our spikes.
-    sleep_time_str = resp.headers.get("Retry-After")
-    yield math.floor(float(sleep_time_str))
+    if exc_info[1] is not None and hasattr(exc_info[1], "response"):
+        resp = exc_info[1].response
+        if resp.status_code == 429:
+            # Retry-After is an undocumented header. But honoring
+            # it was proven to work in our spikes.
+            sleep_time_str = resp.headers.get("Retry-After", "5")
+            yield math.floor(float(sleep_time_str))
+    else:
+        yield 0
 
 
 def invalid_token_handler(details):
@@ -85,23 +83,22 @@ def asana_error_handling(fnc):
     )
     @backoff.on_exception(
         backoff.expo,
-        (InvalidTokenError, NoAuthorizationError, TokenExpiredError),
+        (InvalidTokenError, NoAuthorizationError),
         on_backoff=invalid_token_handler,
         max_tries=MAX_RETRIES,
     )
     @backoff.on_exception(
         backoff.expo,
-        (simplejson.scanner.JSONDecodeError, RetryableAsanaError),
+        (simplejson.scanner.JSONDecodeError, requests.exceptions.HTTPError),
         giveup=is_not_status_code_fn(range(500, 599)),
         on_backoff=retry_handler,
         max_tries=MAX_RETRIES,
     )
     @backoff.on_exception(
         retry_after_wait_gen,
-        RateLimitEnforcedError,
+        (requests.exceptions.HTTPError, requests.exceptions.ConnectionError),
         giveup=is_not_status_code_fn([429]),
         on_backoff=leaky_bucket_handler,
-        # No jitter as we want a constant value
         jitter=None,
     )
     @functools.wraps(fnc)
@@ -109,14 +106,24 @@ def asana_error_handling(fnc):
         return fnc(*args, **kwargs)
     return wrapper
 
-# Added decorator over functions of asana SDK as functions from SDK returns generator and
-# tap is yielding data from that function so backoff is not working over tap functions.
-# Decorator can be put above get_objects() functions of every stream file but
-# it has multiple for loops so it's expensive to backoff everything.
-CollectionPageIterator.get_initial = asana_error_handling(
-    CollectionPageIterator.get_initial
-)
-CollectionPageIterator.get_next = asana_error_handling(CollectionPageIterator.get_next)
+
+class InvalidTokenError(Exception):
+    """Custom exception for Invalid Token (Status Code 412)"""
+
+    def __init__(self, response=None):
+        super().__init__("Invalid Token Error")
+        self.status_code = 412
+        self.response = response
+
+
+class NoAuthorizationError(Exception):
+    """Custom exception for Unauthorized Access (Status Code 401)"""
+
+    def __init__(self, response=None):
+        super().__init__("No Authorization Error")
+        self.status_code = 401
+        self.response = response
+
 
 class Stream():
     # Used for bookmarking and stream identification. Is overridden by
@@ -179,7 +186,7 @@ class Stream():
     def get_updated_session_bookmark(session_bookmark, value):
         """Returns the updated session bookmark"""
         try:
-            session_bookmark = utils.strptime_with_tz(session_bookmark)
+            session_bookmark = utils.strptime_with_tz(str(session_bookmark))
         except TypeError:
             pass
 
@@ -196,13 +203,75 @@ class Stream():
     # hence removed the condition: 'if query_params', as
     # there will be atleast 1 param: 'timeout'
     @asana_error_handling
-    def call_api(self, resource, **query_params):
-        """Function to make API call"""
-        api_function = getattr(Context.asana.client, resource)
-        query_params["timeout"] = self.request_timeout
-        return api_function.find_all(**query_params)
-
+    def call_api(self, api_instance, method_name, **query_params):
+        """Function to make API call with error handling"""
+        api_method = getattr(api_instance, method_name, None)
+        if not api_method:
+            raise AttributeError(f"Method '{method_name}' not found in {api_instance.__class__.__name__}.")
+
+        # Ensure the 'opts' parameter is included
+        if "opts" not in query_params:
+            query_params["opts"] = {}
+
+        # Call the API method without pagination
+        results = {"data": []}
+        try:
+            response = api_method(**query_params)
+
+            # Handle generator responses
+            if isinstance(response, (list, tuple)):
+                results["data"] = response
+            else:
+                results["data"] = list(response)  # Convert generator to list
+        except asana.rest.ApiException as e:
+            if e.status == 412:
+                raise InvalidTokenError(response=e) from e
+            if e.status == 401:
+                raise NoAuthorizationError(response=e) from e
+            LOGGER.error("Error during API call: %s", e)
+            raise e from None
+
+        return results
+
+    # pylint: disable=use-yield-from
     def sync(self):
         """Yield's processed SDK object dicts to the caller."""
         for obj in self.get_objects():
             yield obj
+
+    @asana_error_handling
+    def fetch_workspaces(self, opts=None):
+        """Fetch all workspaces using the Asana API."""
+        if opts is None:  # Initialize opts as an empty dictionary if not provided
+            opts = {}
+        result = []
+        try:
+            workspaces_api = asana.WorkspacesApi(Context.asana.client)
+            response = list(workspaces_api.get_workspaces(opts=opts))
+            result =  response
+        except asana.rest.ApiException as e:
+            if e.status == 412:
+                raise InvalidTokenError(response=e) from e
+            if e.status == 401:
+                raise NoAuthorizationError(response=e) from e
+            LOGGER.error("Failed to fetch workspaces: %s", e)
+            raise e from None
+        return result
+
+    @asana_error_handling
+    def fetch_projects(self, workspace_gid, opt_fields, request_timeout):
+        """Fetch all projects using the Asana API."""
+        result = []
+        try:
+            projects_api = asana.ProjectsApi(Context.asana.client)
+            response = projects_api.get_projects(opts={"workspace": workspace_gid, "opt_fields": opt_fields},
+                                                 _request_timeout=request_timeout)
+            result = list(response)
+        except asana.rest.ApiException as e:
+            if e.status == 412:
+                raise InvalidTokenError(response=e) from e
+            if e.status == 401:
+                raise NoAuthorizationError(response=e) from e
+            LOGGER.error("Failed to fetch projects: %s", e)
+            raise e from None
+        return result

tap_asana-2.4.0/tap_asana/streams/portfolios.py

@@ -0,0 +1,72 @@
+import asana
+from tap_asana.context import Context
+from tap_asana.streams.base import Stream
+
+
+class Portfolios(Stream):
+    name = "portfolios"
+    replication_method = "FULL_TABLE"
+
+    fields = [
+        "gid",
+        "resource_type",
+        "name",
+        "color",
+        "created_at",
+        "created_by",
+        "custom_field_settings",
+        "is_template",
+        "due_on",
+        "members",
+        "owner",
+        "permalink_url",
+        "start_on",
+        "workspace",
+        "portfolio_items",
+        "current_status_update",
+        "custom_fields",
+        "public"
+    ]
+
+    def get_objects(self):
+        """Get stream object"""
+        opt_fields = ",".join(self.fields)
+        workspaces = self.fetch_workspaces()
+
+        # Use WorkspacesApi to fetch workspaces
+        portfolios_api = asana.PortfoliosApi(Context.asana.client)
+
+        for workspace in workspaces:
+            # Paginate through portfolios for each workspace
+            offset = True
+            while True:
+                # Fetch portfolios for the current workspace using call_api
+                response = self.call_api(
+                    portfolios_api,
+                    "get_portfolios",
+                    workspace=workspace["gid"],  # Workspace ID
+                    opts={"owner": "me", "opt_fields": opt_fields},
+                    _request_timeout=self.request_timeout,
+                )
+
+                for portfolio in response["data"]:
+                    # Fetch detailed portfolio information using get_portfolio
+                    portfolio_details = self.call_api(
+                        portfolios_api,
+                        "get_portfolio",
+                        portfolio_gid=portfolio["gid"],
+                        opts={"opt_fields": opt_fields},
+                        _request_timeout=self.request_timeout,
+                    )
+
+                    # Add detailed portfolio information to the portfolio object
+                    portfolio.update(portfolio_details)
+                    yield portfolio
+
+                # Check if there are more pages
+                offset = response.get("offset")
+                if not offset:
+                    break
+
+
+Context.stream_objects["portfolios"] = Portfolios

{tap-asana-2.3.0 → tap_asana-2.4.0}/tap_asana/streams/projects.py

@@ -1,3 +1,4 @@
+import asana
 from tap_asana.context import Context
 from tap_asana.streams.base import Stream
 
@@ -45,11 +46,34 @@ class Projects(Stream):
     opt_fields = ",".join(self.fields)
     bookmark = self.get_bookmark()
     session_bookmark = bookmark
-    for workspace in self.call_api("workspaces"):
-      for project in self.call_api("projects", workspace=workspace["gid"], opt_fields=opt_fields):
-        session_bookmark = self.get_updated_session_bookmark(session_bookmark, project[self.replication_key])
-        if self.is_bookmark_old(project[self.replication_key]):
-          yield project
+
+    workspaces = self.fetch_workspaces()
+
+    # Use ProjectsApi to fetch projects
+    projects_api = asana.ProjectsApi(Context.asana.client)
+
+    for workspace in workspaces:
+        # Paginate through projects for each workspace
+        offset = None
+        while True:
+            response = self.call_api(
+                projects_api,
+                "get_projects",
+                opts={"workspace": workspace["gid"], "opt_fields": opt_fields},
+                _request_timeout=self.request_timeout,
+            )
+
+            for project in response["data"]:
+                session_bookmark = self.get_updated_session_bookmark(session_bookmark, project[self.replication_key])
+                if self.is_bookmark_old(project[self.replication_key]):
+                    yield project
+
+            # Check if there are more pages
+            offset = response.get("offset")
+            if not offset:
+                break
+
+    # Update the bookmark after processing all projects
     self.update_bookmark(session_bookmark)
 
 

tap_asana-2.4.0/tap_asana/streams/sections.py

@@ -0,0 +1,47 @@
+import asana
+from tap_asana.context import Context
+from tap_asana.streams.base import Stream
+
+
+# pylint: disable=use-yield-from
+class Sections(Stream):
+    replication_method = "FULL_TABLE"
+    name = "sections"
+
+    fields = [
+        "gid",
+        "resource_type",
+        "name",
+        "created_at",
+        "project",
+        "projects"
+    ]
+
+    def get_objects(self):
+        """Get stream object"""
+        opt_fields = ",".join(self.fields)
+        workspaces = self.fetch_workspaces()
+
+        # Use SectionsApi to fetch sections
+        sections_api = asana.SectionsApi(Context.asana.client)
+
+        # Iterate over all workspaces
+        for workspace in workspaces:
+            response = self.fetch_projects(workspace_gid=workspace["gid"], opt_fields=opt_fields,
+                                           request_timeout=self.request_timeout)
+            project_ids = [project["gid"] for project in response]
+
+            # Iterate over all project IDs and fetch sections
+            for project_id in project_ids:
+                section_response = self.call_api(
+                    sections_api,
+                    "get_sections_for_project",
+                    project_gid=project_id,
+                    opts={"opt_fields": opt_fields},
+                    _request_timeout=self.request_timeout,
+                )
+                for section in section_response["data"]:
+                    yield section
+
+
+Context.stream_objects["sections"] = Sections