drivelinepy 1.5.1__tar.gz

drivelinepy-1.5.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Driveline Research and Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

drivelinepy-1.5.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: drivelinepy
+Version: 1.5.1
+Summary: A Python package for Driveline Baseball API interactions
+Home-page: https://github.com/drivelineresearch/drivelinepy
+Author: Garrett York
+Author-email: garrett@drivelinebaseball.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Drivelinepy
+
+## Installation
+
+```
+pip install drivelinepy
+```
+
+[Using Environment Variables](/docs/env-variables.md).
+
+## System Specific Docs
+- [Slack API](/docs/slack-api.md)
+- [TRAQ API](/docs/traq-api.md)
+- [Virtuagym API](/docs/virtuagym-api.md)
+- [Zoho APIs](/docs/zoho-overview.md)
+
+
+

drivelinepy-1.5.1/README.md

@@ -0,0 +1,16 @@
+# Drivelinepy
+
+## Installation
+
+```
+pip install drivelinepy
+```
+
+[Using Environment Variables](/docs/env-variables.md).
+
+## System Specific Docs
+- [Slack API](/docs/slack-api.md)
+- [TRAQ API](/docs/traq-api.md)
+- [Virtuagym API](/docs/virtuagym-api.md)
+- [Zoho APIs](/docs/zoho-overview.md)
+

drivelinepy-1.5.1/drivelinepy/__init__.py

@@ -0,0 +1,6 @@
+from .base_api_wrapper import BaseAPIWrapper
+from .zoho_billing_api import ZohoBillingAPI
+from .zoho_crm_api import ZohoCrmAPI
+from .virtuagym_api import VirtuagymAPI
+from .traq_api import TRAQAPI
+from .slack_api import SlackAPI

drivelinepy-1.5.1/drivelinepy/base_api_wrapper.py

@@ -0,0 +1,184 @@
+#=================================================================
+# Author: Garrett York
+# Date: 2023/11/29
+# Description: Boiler plate code for API wrapper
+#=================================================================
+
+import requests
+import logging
+from datetime import datetime
+import time
+from urllib.parse import urljoin
+import re
+
+class BaseAPIWrapper():
+
+    #-----------------------------------------------------------------
+    # Constructor
+    #-----------------------------------------------------------------
+    def __init__(self, base_url, auth_url=None):
+        self.base_url = base_url
+        self.auth_url = auth_url
+        self.logger = logging.getLogger(__name__)
+
+    #-----------------------------------------------------------------
+    # Method - Construct URL
+    #-----------------------------------------------------------------
+
+    def _url(self, path, is_auth=False):
+        """Construct URL from base/auth url and path."""
+        if is_auth:
+            url = urljoin(self.auth_url, path)
+        else:
+            url = urljoin(self.base_url, path)
+        return url
+    
+    #-----------------------------------------------------------------
+    # Method - Prepare Parameters
+    #-----------------------------------------------------------------
+
+    def _prepare_params(self, base_params, additional_params=None):
+        """
+        Prepares and merges base parameters with additional parameters.
+
+        :param base_params: A dictionary of base parameters common to all API requests.
+        :param additional_params: A dictionary of additional parameters specific to a particular API request.
+        :return: A merged dictionary of parameters with none values filtered out.
+        """
+        self.logger.info(f"Entering _prepare_params() with base parameters: {base_params}")
+
+        if base_params is None:
+                base_params = {}
+        params = base_params.copy()
+
+        if additional_params is not None:
+            params.update(additional_params)  # Merges additional parameters
+
+        # Filtering out None values
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+
+        self.logger.info("Exiting _prepare_params()")
+        return filtered_params
+
+    
+    #-----------------------------------------------------------------
+    # Method - Send Request
+    #-----------------------------------------------------------------
+
+    def _send_request(self, method, path, params=None, data=None, headers=None, is_auth=False, files=None):
+        """Send a request to the API."""
+        url = self._url(path, is_auth=is_auth)
+
+        # Prepare the keyword arguments for the request method.
+        request_kwargs = {
+            'params': params,
+            'headers': headers,
+            'data': data,
+            'files': files
+        }
+
+        # Make sure not to send 'None' values
+        request_kwargs = {k: v for k, v in request_kwargs.items() if v is not None}
+
+        try:
+            # Make a single request with the conditional arguments.
+            response = requests.request(method, url, **request_kwargs)
+            
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as err:
+            self.logger.error(f'HTTP error occurred: {err}')
+        except requests.exceptions.RequestException as req_err:
+            self.logger.error(f'Request error: {req_err}')
+        except Exception as err:
+            self.logger.error(f'An unexpected error occurred: {err}')
+        return None
+    
+    #-----------------------------------------------------------------
+    # Method - HTTP Functions
+    #-----------------------------------------------------------------
+
+    def get(self, path, params=None, headers=None):
+        """GET request."""
+        return self._send_request('GET', path, params=params, headers=headers)
+
+    def post(self, path, data=None, headers=None, is_auth=False, files=None):
+        """POST request."""
+        return self._send_request('POST', path, data=data, headers=headers, is_auth=is_auth, files=files)
+
+    def put(self, path, data, headers=None):
+        """PUT request."""
+        return self._send_request('PUT', path, data=data, headers=headers)
+
+    def options(self, path, headers=None):
+        """OPTIONS request."""
+        return self._send_request('OPTIONS', path, headers=headers)
+
+    def delete(self, path, headers=None):
+        """DELETE request."""
+        return self._send_request('DELETE', path, headers=headers)
+    
+    #-----------------------------------------------------------------
+    # Method - Convert Date to Timestamp
+    #-----------------------------------------------------------------
+    
+    def convert_yyyy_mm_dd_to_timestamp(self, date_str, is_end_date=False):
+        """
+        Convert a date string to a Unix timestamp.
+
+        :param date_str: Date string in 'YYYY-MM-DD' format.
+        :param is_end_date: Boolean indicating whether the date is an end date.
+                            If True, it will set the time to the end of the day.
+        :return: Unix timestamp corresponding to the provided date.
+        """
+        self.logger.info(f'Entering convert_yyyy_mm_dd_to_timestamp() for date {date_str}')
+
+        if is_end_date:
+            date_time_str = date_str + " 23:59:59.999999"
+        else:
+            date_time_str = date_str + " 00:00:00.000000"
+        
+        # Converting to datetime object
+        date_time_obj = datetime.strptime(date_time_str, '%Y-%m-%d %H:%M:%S.%f')
+        # Converting to Unix timestamp
+        timestamp = time.mktime(date_time_obj.timetuple())
+        self.logger.info("Exiting convert_yyyy_mm_dd_to_timestamp()")
+        return timestamp
+    
+    #-----------------------------------------------------------------
+    # Method - Validate Date Format
+    #-----------------------------------------------------------------
+    
+    def validate_date_yyyy_mm_dd(self, date_str):
+        """
+        Validate a date string in 'YYYY-MM-DD' format.
+
+        :param date_str: Date string in 'YYYY-MM-DD' format.
+        :return: Boolean indicating whether the date string is valid.
+        """
+        try:
+            datetime.strptime(date_str, '%Y-%m-%d')
+            self.logger.info(f"Date string is valid: {date_str}. Exiting validate_date_yyyy_mm_dd()")
+            return True
+        except ValueError:
+            self.logger.error(f"Incorrect data format for date string '{date_str}', should be YYYY-MM-DD. Exiting validate_date_yyyy_mm_dd()")
+            return False
+
+    #-----------------------------------------------------------------
+    # Method - Validate Email
+    #-----------------------------------------------------------------
+        
+    def validate_email(self, email):
+        """
+        Validates that the provided string is a valid email format.
+
+        :param email: The email address to be validated.
+        :return: Boolean indicating whether the email is valid.
+        """
+        email_regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        if re.match(email_regex, email):
+            self.logger.info(f"Email address {email} is valid.")
+            return True
+        else:
+            self.logger.error(f"Invalid email address: {email}.")
+            return False

drivelinepy-1.5.1/drivelinepy/brightpearl_api.py

@@ -0,0 +1,176 @@
+# =================================================================
+# Author: Diego Plata
+# Date: 2023/12/19
+# Description: Class for Brightpearl API
+# =================================================================
+
+from base_api_wrapper import BaseAPIWrapper
+from datetime import datetime
+from brightpearl_utils.helper_functions import *
+
+class BrightpearlApi(BaseAPIWrapper):
+
+    # -----------------------------------------------------------------
+    # Method - Constructor
+    # -----------------------------------------------------------------
+
+    def __init__(self, client_id, client_secret, refresh_token, api_iteration_limit=50,
+                 auth_url="https://oauth.brightpearl.com", base_url=""):
+        super().__init__(base_url)
+        self.auth_url = auth_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.refresh_token = refresh_token
+        self.api_iteration_limit = api_iteration_limit  # Number of times to call an API endpoint in a single function
+        self.time_of_last_refresh = None  # Set in _refresh_access_token()
+        self.access_token = None  # Set in _refresh_access_token()
+        self._refresh_access_token()
+
+    # -----------------------------------------------------------------
+    # Method - Refresh Access Token
+    # -----------------------------------------------------------------
+
+    def _refresh_access_token(self):
+
+        """
+        Refreshes the OAuth access token using the refresh token.
+
+        :return: True if the access token was successfully refreshed, False otherwise.
+        """
+
+        self.logger.info("Entering _refresh_access_token()")
+        self.time_of_last_refresh = datetime.now()
+
+        path = "/token/driveline"
+
+        data = {
+            'refresh_token': self.refresh_token,
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'grant_type': 'refresh_token'
+        }
+        headers = {}
+
+        response = self.post(path=path, headers=headers, data=data, is_auth=True)
+
+        # valid if response is successful, if it was return true, if not return false
+        if response is None:
+            self.logger.error("Failed to refresh access token - response is None")
+            return False
+        else:
+            # if access token exists, return true
+            if "access_token" in response:
+                self.access_token = response["access_token"]
+                self.base_url = f"https://{response['api_domain']}"
+                self.logger.info("Access token refreshed and base url set to api domain")
+                return True
+            else:
+                self.logger.error("Failed to refresh access token - access token does not exist in response")
+                return False
+
+    # -----------------------------------------------------------------
+    # Method - Check Last Time Access Token Was Refreshed
+    # -----------------------------------------------------------------
+
+    def check_if_access_token_needs_refreshed(self):
+        """
+        Checks if the access token needs to be refreshed.
+        return: True if the access token needs to be refreshed, False otherwise.
+        """
+        self.logger.info("Entering check_last_refresh()")
+
+        time_since_last_refresh = datetime.now() - self.time_of_last_refresh
+
+        if time_since_last_refresh.seconds > 3600:
+            self.logger.info("Exiting check_last_refresh() - Token needs to be refreshed")
+            return True
+        else:
+            self.logger.info("Exiting check_last_refresh() - Token does not need to be refreshed")
+            return False
+
+    # -----------------------------------------------------------------
+    # Method - Get Headers
+    # -----------------------------------------------------------------
+
+    def _get_headers(self):
+        self.logger.info("Entering _get_headers()")
+        if self.check_if_access_token_needs_refreshed():
+            if not self._refresh_access_token():
+                return None
+
+        headers = {
+            'Authorization': f"Bearer {self.access_token}",
+            'Content-Type': 'application/json',
+            'brightpearl-app-ref': self.client_id,
+            'brightpearl-dev-ref': 'driveline1058'
+        }
+
+        self.logger.info(f'Headers have been set!')
+        self.logger.info("Exiting _get_headers()")
+        return headers
+
+    def get_all_sales_orders_from_date(self, since_date, page_size):
+        # TODO: add docstring documentation
+        self.logger.info("Entering get_all_sales_orders()")
+        endpoint = "/public-api/driveline/order-service/sales-order-search"
+
+        result_index = 1
+        today = pd.to_datetime('today').date()
+        params = {
+                    "createdOn": f"{since_date}T00:00/{today}T00:00",
+                    "pageSize": page_size,
+                    "firstResult": result_index
+        }
+
+        sales_orders = self._fetch_sales_orders_by_date(self.base_url+endpoint, params)
+
+        return sales_orders
+
+    def get_all_sales_orders_by_ids(self, sales_orders):
+        # TODO: add docstring documentation
+        self.logger.info("Entering get_all_sales_orders_by_id()")
+        order_service_endpoint = "/public-api/driveline/order-service"
+        sales_order_endpoint = "/public-api/driveline/order-service/sales-order"
+        params = {
+
+        }
+        headers = self._get_headers()
+        orders_ids = construct_sales_orders_url(sales_orders['salesOrderId'].values, self.base_url)
+        uris_response = self.options(f"{self.base_url}{sales_order_endpoint}/{','.join(orders_ids)}", headers=headers)
+        urls = uris_response["response"]["getUris"]
+        sales_orders = self._fetch_sales_orders_by_ids(f"{self.base_url}{order_service_endpoint}", params, urls)
+
+        return sales_orders
+
+    def _fetch_sales_orders_by_date(self, endpoint, initial_params):
+        # TODO: add docstring documentation
+        self.logger.info(f'Entering _fetch_data() for endpoint {endpoint}')
+        all_data_list = []
+        params = initial_params
+        headers = self._get_headers()
+        more_pages_available = True
+        while more_pages_available:
+            response = self.get(endpoint, params=params, headers=headers)
+            more_pages_available = response["response"]["metaData"]["morePagesAvailable"]
+            data_count = response["response"]["metaData"]["resultsReturned"]
+            first_index_returned = response["response"]["metaData"]["firstResult"]
+            last_index_returned = response["response"]["metaData"]["lastResult"]
+            self.logger.info(f"Retrieved {data_count} results from index {first_index_returned} to index {last_index_returned}")
+            all_data_list.append(sales_orders_list_to_dataframe(response["response"]["results"], response["response"]["metaData"]["columns"]))
+            result_index = response["response"]["metaData"]["lastResult"] + 1
+            params['firstResult'] = result_index
+
+        self.logger.info(f"Exiting _fetch_sales_orders_by_date()")
+        return pd.concat(all_data_list)
+
+    def _fetch_sales_orders_by_ids(self, endpoint, initial_params, urls):
+        # TODO: add docstring documentation
+        self.logger.info(f'Entering _fetch_data() for endpoint {endpoint}')
+        params = initial_params
+        headers = self._get_headers()
+        response = [self.get(endpoint+url, params=params, headers=headers) for url in urls]
+        individual_sales_orders_list = list()
+        for sale_order_dictionary in response:
+            individual_sales_orders_list.append(individual_sales_orders_to_dataframe(sale_order_dictionary["response"]))
+        self.logger.info(f"Exiting _fetch_sales_orders_by_ids()")
+        return pd.concat(individual_sales_orders_list)

drivelinepy-1.5.1/drivelinepy/brightpearl_utils/helper_functions.py

@@ -0,0 +1,27 @@
+import pandas as pd
+
+
+def sales_orders_list_to_dataframe(results, columns):
+    header_columns = [column["name"] for column in columns]
+    return pd.DataFrame(results, columns=header_columns)
+
+def construct_sales_orders_url(ids, base_url):
+    string_ids = [str(id) for id in ids]
+    return string_ids
+
+def individual_sales_orders_to_dataframe(orders):
+    return pd.json_normalize(orders, sep='_')
+
+
+def append_order_and_individual_sales_entry(orders):
+    row_frames = list()
+    for _, row in orders.iterrows():
+        row_frame = pd.json_normalize(row["rows"])
+        # can join later
+        row_frame["salesOrderId"] = row["id"]
+        row_frame = row_frame.add_prefix("individual_sale_entry_")
+        row_frames.append(row_frame)
+    row_frames = pd.concat(row_frames)
+    megaframe = orders.merge(row_frames, how='right',left_on=["id"], right_on=["individual_sale_entry_salesOrderId"], suffixes=("","sale_entry"))
+    megaframe = megaframe.drop("rows",axis=1)
+    return megaframe

drivelinepy-1.5.1/drivelinepy/slack_api.py

@@ -0,0 +1,99 @@
+#================================================================================
+# Author: Garrett York
+# Date: 2024/02/01
+# Description: Class for Slack API
+#================================================================================
+
+from .base_api_wrapper import BaseAPIWrapper
+import os
+import mimetypes
+
+class SlackAPI(BaseAPIWrapper):
+
+    #---------------------------------------------------------------------------
+    # Constructor
+    #---------------------------------------------------------------------------
+
+    def __init__(self, token, base_url="https://slack.com/api/"):
+        super().__init__(base_url)
+        self.token = token
+
+    #---------------------------------------------------------------------------
+    # Method - Post Message
+    #---------------------------------------------------------------------------
+
+    def post_message(self, channel, text):
+        """
+        Posts a message to a specified channel on Slack.
+
+        :param channel: The channel ID where the message will be posted.
+        :param text: The text of the message to post.
+        :return: The response from the Slack API.
+        """
+        self.logger.info("Entering post_message()")
+
+        endpoint = "chat.postMessage"
+        payload = {
+            'channel': channel,
+            'text': text
+        }
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Authorization': f'Bearer {self.token}'
+        }
+
+        response = self.post(endpoint, data=payload, headers=headers)
+
+        self.logger.info("Exiting post_message()")
+        return response
+    
+    #---------------------------------------------------------------------------
+    # Method - Post File + Message (optional)
+    #---------------------------------------------------------------------------
+
+    def upload_file(self, channel, file_absolute_path, text=None):
+
+        """
+        Uploads a file to a specified channel on Slack.
+
+        This method attempts to upload a file to the specified Slack channel. It first checks if the file exists at the given path and then determines its MIME type for proper uploading. The file is then uploaded with an optional initial comment.
+
+        :param channel: str
+            The channel ID where the file will be uploaded.
+        :param file_absolute_path: str
+            The absolute path to the file to upload.
+        :param text: str, optional
+            An initial comment to add when uploading the file. Defaults to None. The API documentation refers to this parameter is initial_comment
+            but it is referred to as text in this method to match the parameter name in the post_message method.
+
+        :return: dict
+            A dictionary response from the Slack API indicating the success or failure of the file upload.
+        """
+        self.logger.info("Entering upload_file()")
+
+        if not os.path.exists(file_absolute_path):
+            self.logger.error(f"File not found: {file_absolute_path}")
+            return {"ok": False, "error": "file_not_found"}
+
+        endpoint = "files.upload"
+
+        # Attempt to determine the MIME type of the file based on its extension. 
+        # The `guess_type` function returns a tuple (MIME type, encoding), 
+        # where we are only interested in the MIME type. The underscore (_) 
+        # is used to ignore the encoding part of the returned tuple.
+        
+        mime_type, _ = mimetypes.guess_type(file_absolute_path)
+        mime_type = mime_type or 'application/octet-stream'
+
+        try:
+            with open(file_absolute_path, 'rb') as file_content:
+                files = [('file', (os.path.basename(file_absolute_path), file_content, mime_type))]
+                payload = {'channels': channel, 'initial_comment': text}
+                headers = {'Authorization': f'Bearer {self.token}'}
+                response = self.post(endpoint, headers=headers, data=payload, files=files)
+        except Exception as e:
+            self.logger.error(f"Error uploading file: {e}")
+            return {"ok": False, "error": str(e)}
+
+        self.logger.info("Exiting upload_file()")
+        return response