brynq-sdk-jira 3.0.4__py3-none-any.whl

brynq_sdk_jira/__init__.py

@@ -0,0 +1,2 @@
+from .jira import Jira
+from .tempo import Tempo

brynq_sdk_jira/jira.py

@@ -0,0 +1,183 @@
+import json
+from typing import Union, List, Literal, Optional
+import pandas as pd
+import requests
+from brynq_sdk_brynq import BrynQ
+
+class Jira(BrynQ):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug=False):
+        super().__init__()
+        credentials = self.interfaces.credentials.get(system="jira", system_type=system_type)
+        credentials = credentials.get('data')
+        self.base_url = credentials['base_url']
+        self.headers = {
+            "Authorization": f"Basic {credentials['access_token']}",
+            "Content-Type": "application/json"
+        }
+        self.debug = debug
+        self.timeout = 3600
+
+    def get_issues(self, jql_filter: str = None, jira_filter_id: int = None, get_extra_fields: list = None, expand_fields: list = None) -> pd.DataFrame:
+        """
+        This method retrieves issues from Jira.
+        :param jql_filter: optional filter in jql format
+        :param jira_filter_id: optional filter id of predefined filter in jira
+        :param get_extra_fields: an optional list of extra fields to retrieve
+        :param expand_fields: an optional list of fields to expand
+        :return: dataframe with issues
+        """
+        if jira_filter_id is not None:
+            raise ValueError("Jira filter id is no longer supported, use jql_filter instead")
+
+        # Use new JQL search endpoint
+        url = f"{self.base_url}rest/api/3/search/jql"
+
+        all_issues = []
+        next_page_token = None
+
+        while True:
+            payload = {
+                "maxResults": 100,
+                "fields": ["summary", "issuetype", "timetracking", "timespent", "description", "assignee", "project"]
+            }
+
+            if jql_filter:
+                payload["jql"] = jql_filter
+
+            if get_extra_fields:
+                payload["fields"].extend(get_extra_fields)
+
+            if expand_fields:
+                # Convert list to comma-delimited string
+                payload["expand"] = ",".join(expand_fields)
+
+            if next_page_token:
+                payload["nextPageToken"] = next_page_token
+
+            if self.debug:
+                print(f"Payload: {payload}")
+
+            response = requests.post(
+                url=url,
+                headers=self.headers,
+                data=json.dumps(payload),
+                timeout=self.timeout
+            )
+
+            if response.status_code == 200:
+                response_json = response.json()
+                all_issues.extend(response_json.get("issues", []))
+
+                # Check for next page
+                if "nextPageToken" in response_json:
+                    next_page_token = response_json["nextPageToken"]
+                else:
+                    break
+            else:
+                raise ConnectionError(f"Error getting issues from Jira with message: {response.status_code, response.text}")
+
+        if self.debug:
+            print(f"Received {len(all_issues)} issues from Jira")
+
+        df = pd.json_normalize(all_issues)
+        return df
+
+    def get_projects(self) -> pd.DataFrame:
+        """
+        This method retrieves projects from Jira.
+        :return: a dataframe with projects
+        """
+        total_response = []
+        got_all_results = False
+        no_of_loops = 0
+
+        while not got_all_results:
+            query = {
+                'startAt': f'{50 * no_of_loops}',
+                'maxResults': '50',
+                'expand': 'description'
+            }
+            if self.debug:
+                print(query)
+            response = requests.get(f"{self.base_url}rest/api/3/project/search", headers=self.headers, params=query, timeout=self.timeout)
+            if response.status_code == 200:
+                response_json = response.json()
+                response.raise_for_status()
+                no_of_loops += 1
+                got_all_results = False if len(response_json['values']) == 50 else True
+                total_response += response_json['values']
+            else:
+                raise ConnectionError(f"Error getting projects from Jira with message: {response.status_code, response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} projects from Jira")
+
+        df = pd.json_normalize(total_response)
+
+        return df
+
+    def get_versions(self, project_key: str) -> pd.DataFrame:
+        """
+        This method retrieves versions for a given project from Jira.
+        :param project_key: The key of the project for which versions are to be retrieved.
+        :return: A dataframe with the versions.
+        """
+        url = f"{self.base_url}rest/api/latest/project/{project_key}/versions"
+        response = requests.get(url=url, headers=self.headers, timeout=self.timeout)
+        if response.status_code == 200:
+            response_json = response.json()
+            df = pd.json_normalize(response_json)
+            if self.debug:
+                print(f"Received {len(df)} versions for project {project_key}")
+            return df
+        else:
+            raise ConnectionError(f"Error getting versions from Jira with message: {response.status_code, response.text}")
+
+    def get_users(self) -> pd.DataFrame:
+        """
+        This method retrieves users from Jira.
+        :return: a dataframe with users
+        """
+        start_at = 0
+        max_results = 50
+        all_users = []
+
+        while True:
+            response = requests.get(f"{self.base_url}rest/api/3/users/search?startAt={start_at}&maxResults={max_results}", headers=self.headers, timeout=self.timeout)
+            response.raise_for_status()
+            if response.status_code == 200:
+                users = response.json()  # A list of user objects
+                all_users.extend(users)  # Add users to the total list
+
+                # Stop if no more users are returned
+                if not users:
+                    break
+
+                # Increment startAt for the next page
+                start_at += len(users)
+            else:
+                raise ConnectionError(f"Error getting users from Jira with message: {response.status_code, response.text}")
+            if self.debug:
+                print(f"Received {len(all_users)} jira users from Jira")
+
+        df = pd.json_normalize(all_users)
+        return df
+
+    def update_issue(self, issue, fields : dict):
+        try:
+            url = f"{self.base_url}rest/api/3/issue/{issue}"
+            payload = {
+                "fields" : fields
+            }
+
+            resp = requests.put(
+                url,
+                json= payload,
+                headers= self.headers,
+                timeout=60
+            )
+
+            return resp
+        except Exception as e:
+            message = "Error updating issue"
+            return message

brynq_sdk_jira/tempo.py

@@ -0,0 +1,288 @@
+import json
+import requests
+from itertools import islice
+from brynq_sdk_brynq import BrynQ
+from typing import Union, List, Literal, Optional
+
+
+class Tempo(BrynQ):
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug=False):
+        super().__init__()
+        self.debug = debug
+        credentials = self.interfaces.credentials.get(system="jira", system_type=system_type)
+        credentials = credentials.get('data')
+        self.headers = {
+            "Authorization": f"Bearer {credentials['api_token']}",
+            "Content-Type": "application/json"
+        }
+        if self.debug:
+            print(self.headers)
+        self.timeout = 3600
+
+    def get_tempo_hours(self, from_date: str = None, to_date: str = None, updated_from: str = None) -> json:
+        """
+        This function gets hours from Tempo for the specified time period
+
+        :param from_date: (Optional) string - retrieve results starting with this date
+        :param to_date: (Optional) string - retrieve results up to and including this date
+        :param updated_from: (Optional) string <yyyy-MM-dd['T'HH:mm:ss]['Z']> - retrieve results that have been updated from this date(e.g "2023-11-16") or date time (e.g "2023-11-06T16:48:59Z")
+        :return: json response with results
+        """
+        total_response = []
+        got_all_results = False
+        no_of_loops = 0
+        parameters = {}
+        if from_date is not None:
+            parameters.update({"from": from_date})
+        if to_date is not None:
+            parameters.update({"to": to_date})
+        if updated_from is not None:
+            parameters.update({"updatedFrom": updated_from})
+
+        while not got_all_results:
+            loop_parameters = parameters | {"limit": 1000, "offset": 1000 * no_of_loops}
+            response = requests.get('https://api.tempo.io/4/worklogs', headers=self.headers, params=loop_parameters, timeout=self.timeout)
+            if response.status_code == 200:
+                response_json = response.json()
+                no_of_loops += 1
+                got_all_results = False if int(response_json['metadata']['count']) == 1000 else True
+                total_response += response_json['results']
+            else:
+                raise ConnectionError(f"Error getting worklogs from Tempo: {response.status_code, response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} lines from Tempo")
+
+        return total_response
+
+    def get_tempo_timesheet_approvals(self, from_date: str, to_date: str, team_id: int = 19) -> json:
+        """
+        This function retrieves approved timesheet approvals for a given team in Tempo
+        over the specified date range.
+
+        :param from_date: string <yyyy-MM-dd> - retrieve results starting with this date
+        :param to_date: string <yyyy-MM-dd> - retrieve results up to and including this date
+        :param team_id: int (default 19) - Tempo team ID whose approvals are retrieved
+        :return: json response with results
+        """
+        total_response = []
+        got_all_results = False
+        no_of_loops = 0
+
+        parameters = {
+            "from": from_date,
+            "to": to_date,
+        }
+
+        while not got_all_results:
+            loop_parameters = parameters | {"limit": 50, "offset": 50 * no_of_loops}
+            url = f"https://api.tempo.io/4/timesheet-approvals/team/{team_id}"
+            response = requests.get(
+                url,
+                headers=self.headers,
+                params=loop_parameters,
+                timeout=self.timeout
+            )
+
+            if response.status_code == 200:
+                response_json = response.json()
+                no_of_loops += 1
+                got_all_results = False if int(response_json['metadata']['count']) == 50 else True
+                total_response += response_json['results']
+            else:
+                raise ConnectionError(
+                    f"Error getting timesheet approvals from Tempo: {response.status_code, response.text}"
+                )
+
+        if self.debug:
+            print(f"Received {len(total_response)} timesheet approvals from Tempo")
+
+        return total_response
+
+    def call_api(self, url: str, limit: int = 50) -> list[dict]:
+        """
+        Calls the Tempo API and retrieves all paginated results for a given endpoint.
+
+        Args:
+            url (str): The API endpoint URL to call.
+            limit (int): Max results to fetch per request (default 50).
+
+        Returns:
+            list[dict]: A list of all results across all pages.
+        """
+        all_results = []
+        offset = 0
+        while True:
+            querystring = {"limit": str(limit), "offset": str(offset)}
+            response = requests.get(url, headers=self.headers, params=querystring)
+            response.raise_for_status()
+            data = response.json()
+
+            # append results
+            results = data.get("results", [])
+            all_results.extend(results)
+
+            # pagination check
+            count = data.get("metadata", {}).get("count", 0)
+            if count < limit:
+                break
+
+            offset += limit
+
+        return all_results
+
+    def get_tempo_teams(self, team_members: List[str] = None, name: str = None) -> json:
+        """
+        Fetches teams from the Tempo API in smaller batches to prevent long URLs if team_members is specified,
+        otherwise, retrieves a list of all existing Teams.
+
+        :param team_members: (Optional) List of Jira user account IDs to filter teams.
+        :param name: (Optional) Name of the team to filter teams.
+        :return: A json response containing team details.
+        """
+        total_response = []
+
+        # Split team members into smaller chunks (avoid long URLs)
+        team_member_chunks = self._chunk_list(team_members, 50) if team_members else [None]
+
+        for team_chunk in team_member_chunks:
+            parameters = {"limit": 1000, "offset": 0}
+            if team_chunk:
+                parameters["teamMembers"] = ",".join(team_chunk)  # Send fewer team members at a time
+            if name:
+                parameters["name"] = name
+            got_all_results = False
+            no_of_loops = 0
+
+            while not got_all_results:
+                parameters["offset"] = 1000 * no_of_loops
+                response = requests.get('https://api.tempo.io/4/teams', headers=self.headers, params=parameters, timeout=self.timeout)
+                if response.status_code == 200:
+                    response_json = response.json()
+                    total_response.extend(response_json["results"])
+                    got_all_results = False if int(response_json['metadata']['count']) == 1000 else True
+                    no_of_loops += 1
+                else:
+                    raise ConnectionError(f"Error getting teams from Tempo: {response.status_code}, {response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} teams from Tempo")
+        return total_response
+
+    def get_tempo_team_members(self, team_ids: List[int]) -> json:
+        """
+        Fetches members of multiple teams from the Tempo API iteratively.
+
+        :param team_ids: List of Tempo team IDs to retrieve members from.
+        :return: A json response containing team members' details.
+        """
+        total_response = []
+
+        for team_id in team_ids:
+            got_all_results = False
+            no_of_loops = 0
+
+            while not got_all_results:
+                parameters = {"limit": 1000, "offset": 1000 * no_of_loops}
+                response = requests.get(f'https://api.tempo.io/4/teams/{team_id}/members', headers=self.headers, params=parameters, timeout=self.timeout)
+                if response.status_code == 200:
+                    response_json = response.json()
+                    total_response.extend(response_json["results"])
+                    got_all_results = False if int(response_json.get('metadata', {}).get('count', 0)) == 1000 else True
+                    no_of_loops += 1
+                else:
+                    raise ConnectionError(f"Error getting team members from Tempo: {response.status_code}, {response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} team members from Tempo")
+        return total_response
+
+    def get_accounts(self) -> json:
+        """
+        Fetches account details from the Tempo API in batches to handle large datasets.
+
+        :return: A json object containing account details.
+        """
+        total_response = []
+        got_all_results = False
+        no_of_loops = 0
+        parameters = {}
+
+        while not got_all_results:
+            loop_parameters = parameters | {"limit": 1000, "offset": 1000 * no_of_loops}
+            response = requests.get('https://api.tempo.io/4/accounts', headers=self.headers, params=loop_parameters, timeout=self.timeout)
+            if response.status_code == 200:
+                response_json = response.json()
+                no_of_loops += 1
+                got_all_results = False if int(response_json['metadata']['count']) == 1000 else True
+                total_response += response_json['results']
+            else:
+                raise ConnectionError(f"Error getting accounts from Tempo: {response.status_code}, {response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} accounts from Tempo")
+        return total_response
+
+    def get_worklog_accounts(self, account_key: str, from_date: str = None, to_date: str = None, updated_from: str = None) -> json:
+        """
+        Fetches worklog data for a given account key from the Tempo API.
+
+        :param account_key: (Required) string - The account key for which worklog data is required.
+        :param from_date: (Optional) string - retrieve results starting with this date
+        :param to_date: (Optional) string - retrieve results up to and including this date
+        :param updated_from: (Optional) string <yyyy-MM-dd['T'HH:mm:ss]['Z']> - retrieve results that have been updated from this date(e.g "2023-11-16") or date time (e.g "2023-11-06T16:48:59Z")
+        :return: A json containing worklog details.
+        """
+        total_response = []
+        got_all_results = False
+        no_of_loops = 0
+        parameters = {}
+        if from_date is not None:
+            parameters.update({"from": from_date})
+        if to_date is not None:
+            parameters.update({"to": to_date})
+        if updated_from is not None:
+            parameters.update({"updatedFrom": updated_from})
+
+        while not got_all_results:
+            loop_parameters = parameters | {"limit": 1000, "offset": 1000 * no_of_loops}
+            response = requests.get(f"https://api.tempo.io/4/worklogs/account/{account_key}", headers=self.headers, params=loop_parameters, timeout=self.timeout)
+            if response.status_code == 200:
+                response_json = response.json()
+                total_response.extend(response_json.get("results", []))
+                got_all_results = False if int(response_json.get('metadata', {}).get('count', 0)) == 1000 else True
+                no_of_loops += 1
+            else:
+                raise ConnectionError(f"Failed to fetch data for account key {account_key}: {response.status_code}, {response.text}")
+
+        if self.debug:
+            print(f"Received {len(total_response)} worklogs for account key {account_key}")
+
+        return total_response
+
+    def update_worklog(self, worklog_id: Union[str, int], data: Union[str, dict]) -> requests.Response:
+        """
+        Updates a Tempo worklog by ID.
+
+        Args:
+            worklog_id (str | int): ID of the worklog to update.
+            data (str | dict): The payload to send in the update request (JSON string or dict).
+
+        Returns:
+            requests.Response: The HTTP response object from Tempo API.
+        """
+        url = f"https://api.tempo.io/4/worklogs/{worklog_id}"
+
+        # Ensure we send valid JSON
+        if isinstance(data, dict):
+            payload = json.dumps(data)
+        else:
+            payload = data
+
+        response = requests.put(url, headers=self.headers, data=payload, timeout=self.timeout)
+        return response
+
+    def _chunk_list(self, data_list, chunk_size):
+        """Splits a list into chunks of `chunk_size`."""
+        it = iter(data_list)
+        return iter(lambda: list(islice(it, chunk_size)), [])

brynq_sdk_jira-3.0.4.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: brynq_sdk_jira
+Version: 3.0.4
+Summary: JIRA wrapper from BrynQ
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Requires-Dist: brynq-sdk-brynq<5,>=4
+Requires-Dist: pandas<3,>=1
+Requires-Dist: requests<=3,>=2
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+JIRA wrapper from BrynQ

brynq_sdk_jira-3.0.4.dist-info/RECORD

@@ -0,0 +1,7 @@
+brynq_sdk_jira/__init__.py,sha256=sw18oQvBYeGrqYrTXfMANQSE0B3BJ2TFetEy06h8wAU,47
+brynq_sdk_jira/jira.py,sha256=KH2bBOWkWYpDniIWbRc31n8J62j1Hx-5amgKWItYLPM,6797
+brynq_sdk_jira/tempo.py,sha256=mcRXfGHbxxS9cVlEnflzCv8RXyKY4Rj9L_ErdLkR5Yo,12505
+brynq_sdk_jira-3.0.4.dist-info/METADATA,sha256=kfHATSRlPw9EXWzsv7GGVt7UscXV8Lx5T99OQfox_YY,397
+brynq_sdk_jira-3.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brynq_sdk_jira-3.0.4.dist-info/top_level.txt,sha256=e4NQdxchgAtFyXeuPqqN4Mbx2BbrUk2Cf7vNKRQrcys,15
+brynq_sdk_jira-3.0.4.dist-info/RECORD,,

brynq_sdk_jira-3.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

brynq_sdk_jira-3.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk_jira