brynq-sdk-monday 2.1.2__py3-none-any.whl

brynq_sdk_monday/__init__.py

@@ -0,0 +1,3 @@
+from .extract_monday import ExtractMonday
+from .extract_tracket import ExtractTracket
+from .upload_tracket import UploadTracket

brynq_sdk_monday/extract_monday.py

@@ -0,0 +1,335 @@
+from brynq_sdk_brynq import BrynQ
+import os
+import sys
+import pandas as pd
+from typing import Union, List, Literal, Optional
+import requests
+import json
+
+basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(basedir)
+
+
+class ExtractMonday(BrynQ):
+
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False):
+        """
+        For the full documentation, see: https://developer.monday.com/api-reference/docs/basics
+        """
+        super().__init__()
+        self.endpoint = "https://api.monday.com/v2/"
+        self.debug = debug
+        self.timeout = 3600
+        self.headers = self.__get_headers(system_type)
+
+    def __get_headers(self, system_type):
+        credentials = self.interfaces.credentials.get(system="monday", system_type=system_type)
+        credentials = credentials.get('data')
+        api_key = credentials['api_key']
+        headers = {
+            'Authorization': f"Bearer {api_key}",
+            'Content-Type': 'application/json',
+            'API-Version': '2023-10'
+        }
+
+        return headers
+
+    def get_activity_logs_boards(self, board_id: int, start_date: str, end_date: str, column_ids: str = '', limit: int = 25):
+        """
+        See for the docs: https://developer.monday.com/api-reference/docs/activity-logs
+        :param board_id: the ID of the board you want to get the activity logs from
+        :param start_date: start date in YYYY-MM-DD format
+        :param end_date: end date in YYYY-MM-DD format
+        :param column_ids: optional list of column ID's where you want to get the status updates for. If empty, updates for all columns will be returned
+        :param limit: amount of items to be returned. Default is 25
+        """
+        continue_loop = True
+        page = 0
+        df = pd.DataFrame()
+        while continue_loop:
+            page += 1
+            payload = json.dumps({
+                "query": f"query {{boards (ids: {board_id}) {{ activity_logs (from: \"{start_date}\", to: \"{end_date}\", limit: {limit}, page: {page}, column_ids: [\"{column_ids}\"]) {{ id event entity data user_id created_at }} }} }}"
+            })
+            if self.debug:
+                print(payload)
+            response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+            if self.debug:
+                print(response.json())
+            response.raise_for_status()
+            response_length = len(response.json()['data']['boards'][0]['activity_logs'])
+            if response_length > 0:
+                df_temp = pd.json_normalize(response.json()['data']['boards'][0]['activity_logs'])
+                df = pd.concat([df, df_temp], axis=0)
+            if response_length < limit:
+                continue_loop = False
+        return df
+
+    
+    def get_activity_logs_items(
+        self,
+        board_id: int,
+        item_ids: list,
+        start_date: str,
+        end_date: str = None,
+        limit: int = 500,
+    ):
+        """
+        Retrieve activity‑log history for one or more items on a monday.com board.
+
+        Parameters
+        ----------
+        board_id : int
+            ID of the board that owns the items.
+        item_ids : list
+            List of item IDs (max 50 per request, per monday API limits).
+        start_date : str
+            Lower‑bound timestamp in ISO‑8601 format (``YYYY‑MM‑DDThh:mm:ssZ``).
+        end_date : str, optional
+            Upper‑bound timestamp in ISO‑8601 format. ``None`` means "up to now".
+        limit : int, optional
+            Maximum log rows per page (default 500, monday hard‑caps at 500).
+
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame containing the activity‑log rows.
+        """
+        continue_loop = True
+        page = 0
+        df = pd.DataFrame()
+
+        # Pre‑format the item‑ID literal once
+        ids_literal = ",".join(str(i) for i in item_ids)
+
+        while continue_loop:
+            page += 1
+            to_clause = f'to: "{end_date}", ' if end_date else ''
+            query = (
+                f'query {{ boards (ids: {board_id}) {{ '
+                f'activity_logs (item_ids: [{ids_literal}], '
+                f'from: "{start_date}", '
+                + to_clause +
+                f'limit: {limit}, page: {page}) '
+                f'{{ id event entity data user_id created_at }} }} }}'
+            )
+            payload = json.dumps({"query": query})
+
+            if self.debug:
+                print(payload)
+
+            response = requests.request("POST", self.endpoint, headers=self.headers, data=payload)
+
+            if self.debug:
+                print(response.json())
+
+            response.raise_for_status()
+
+            logs = response.json()["data"]["boards"][0]["activity_logs"]
+
+            # Append to dataframe if we received rows
+            if logs:
+                df = pd.concat([df, pd.json_normalize(logs)], axis=0)
+
+            # Stop looping once the page returns fewer rows than the page size
+            if len(logs) < limit:
+                continue_loop = False
+
+        # -- flatten the JSON held in the "data" column into real columns
+        if not df.empty and "data" in df.columns:
+            # convert JSON‑encoded strings into dicts
+            data_dicts = df["data"].apply(lambda x: json.loads(x) if isinstance(x, str) and x.startswith("{") else {})
+            df_expanded = pd.json_normalize(data_dicts, sep="__")
+            df = pd.concat([df.drop(columns=["data"]).reset_index(drop=True), df_expanded.reset_index(drop=True)], axis=1)
+        
+        return df
+
+    def get_users(self, limit: int = 50, fields: str = 'id name created_at email is_admin is_guest is_view_only is_pending enabled join_date title last_activity account {id}'):
+        continue_loop = True
+        page = 0
+        df = pd.DataFrame()
+        while continue_loop:
+            page += 1
+            payload = json.dumps({
+                "query": f"query {{users (limit:{limit} page:{page}) {{ {fields} }} }}"
+            })
+            if self.debug:
+                print(payload)
+            response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+            if self.debug:
+                print(response.json())
+            response.raise_for_status()
+            response_length = len(response.json()['data']['users'])
+            if response_length > 0:
+                df_temp = pd.json_normalize(response.json()['data']['users'])
+                df = pd.concat([df, df_temp], axis=0)
+            if response_length < limit:
+                continue_loop = False
+        return df
+
+    def get_boards(self, limit: int = 50, fields: str = 'id name description board_kind board_folder_id state items_count'):
+        continue_loop = True
+        page = 0
+        df = pd.DataFrame()
+        while continue_loop:
+            page += 1
+            payload = json.dumps({
+                "query": f"query {{boards (limit:{limit} page:{page}) {{ {fields} }} }}"
+            })
+            if self.debug:
+                print(payload)
+            response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+            if self.debug:
+                print(response.json())
+            response.raise_for_status()
+            response_length = len(response.json()['data']['boards'])
+            if response_length > 0:
+                df_temp = pd.json_normalize(response.json()['data']['boards'])
+                df = pd.concat([df, df_temp], axis=0)
+            if response_length < limit:
+                continue_loop = False
+        return df
+
+    def get_groups(self, board_id, fields: str = 'id title position archived deleted color'):
+        """
+        Get the groups from a board. Groups are groupings of tickets.
+        :param board_id: mandatory field from monday.com
+        :param fields: optional fields to be returned. Enter as one string without comma's. Default is id, title, position, archived, deleted and color
+        """
+        payload = json.dumps({
+            "query": f"query {{boards (ids:{board_id}) {{groups {{ {fields} }} }} }}"
+        })
+        if self.debug:
+            print(payload)
+        response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+        if self.debug:
+            print(response.json())
+        response.raise_for_status()
+        response_data = response.json()
+        if isinstance(response_data.get('data'), dict):
+            df = pd.json_normalize(response_data['data']['boards'][0]['groups'])
+            return df
+        else:
+            return response
+
+    def get_column_values(self, item_ids: list):
+        """
+        :param item_ids: all the items where you want to get the column values from
+        """
+        # Chunk in lists of 50 items since monday.com doesn't accept requests longer than 50 items
+        if not isinstance(item_ids, list):
+            item_ids = item_ids.tolist()
+        else:
+            item_ids = item_ids
+        items_list = [item_ids[pos:pos + 25] for pos in range(0, len(item_ids), 25)]
+        all_data = []
+
+        for chunk in items_list:
+            payload = {
+                "query": f"query {{items (ids: {json.dumps(chunk)} exclude_nonactive: false) {{id name state updated_at column_values {{ column {{ title }} id text value }} }} }}"
+            }
+            payload = json.dumps(payload, ensure_ascii=False)
+            if self.debug:
+                print(payload)
+            response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+            if self.debug:
+                print(response.json())
+            response.raise_for_status()
+            data = response.json()['data']
+
+            # flatten the data
+            flat_data = []
+            for item in data['items']:
+                row = {}
+                row['item_id'] = item['id']
+                row['item'] = item['name']
+                row['state'] = item['state']
+                row['updated_at'] = item['updated_at']
+                for col in item['column_values']:
+                    title = col['column']['title']
+                    text = col['value'] if col['text'] == None else col['text']
+                    row[title] = text
+                flat_data.append(row)
+            all_data.extend(flat_data)
+        df = pd.DataFrame(all_data)
+        return df
+
+    def get_items(self,
+                  board_id: int = None,
+                  limit: int = 50,
+                  linked_board_id: int = None,
+                  source_column_id: str = None,
+                  target_column_id: str = None,
+                  item_filter: list = None,
+                  fields: str = 'id name created_at email group {id} parent_item {id} state subitems {id} updated_at creator_id'
+                  ):
+        """
+        Get the items from a group. Be aware, we only got the item ID's in this request. Values should be received from a different url.
+        :param board_id: mandatory field from monday.com
+        :param linked_board_id: If you want to get fields from a linked board, enter that board ID here
+        :param source_column_id: The column ID of the column on the CURRENT (board_id) board that links to the linked board. This is the column that contains the linked items.
+        :param target_column_id: The column ID of the column on the LINKED (linked_board_id) board that contains the value you want to get.
+        :param limit: amount of items to be returned. Default is 50
+        :param item_filter: Optional filter to filter on specific items based on their ID. Give a list with ID's
+        :param fields: optional fields to be returned. Enter as one string without comma's. Default is id, name, created_at, email, group {id}, parent_item {id}, state, subitems {id}, updated_at and creator_id
+        """
+        # Since monday.com doesn't accept requests, longer than 100 items, split up the request in multiple requests
+        df = pd.DataFrame()
+        # Create chunks of item_filter if it has more than 100 IDs
+        if item_filter:
+            item_filter_chunks = [item_filter[i:i + limit] for i in range(0, len(item_filter), limit)]
+        else:
+            item_filter_chunks = [None]
+
+        for item_filter_chunk in item_filter_chunks:
+
+            if item_filter_chunk and linked_board_id and board_id:
+                if not source_column_id or not target_column_id:
+                    raise ValueError('If you have filled the linked_board_id, you need to specify the source_column_id and target_column_id')
+                payload = {"query":
+                               f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}, query_params: {{ids: {item_filter_chunk} }}) "
+                                    f"{{cursor items {{ {fields} linked_items (linked_board_id: {linked_board_id}, link_to_item_column_id: \"{source_column_id}\") {{ id column_values(ids: [\"{target_column_id}\"]) {{ id text value }} }} }} }} }} }}"}
+            elif linked_board_id and board_id:
+                if not source_column_id or not target_column_id:
+                    raise ValueError('If you have filled the linked_board_id, you need to specify the source_column_id and target_column_id')
+                payload = {"query":
+                               f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}) {{cursor items {{ {fields} linked_items "
+                               f"(linked_board_id: {linked_board_id}, link_to_item_column_id: \"{source_column_id}\") {{ id column_values(ids: [\"{target_column_id}\"]) {{ id text value }} }} }} }} }} }}"}
+            elif item_filter_chunk and board_id:
+                payload = {"query": f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}, query_params: {{ids: {item_filter_chunk} }}) {{cursor items {{ {fields} }} }} }} }}"}
+            elif board_id:
+                payload = {"query": f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}) {{cursor items {{ {fields} }} }} }} }}"}
+            else:
+                payload = {"query": f"query {{items (ids: {item_filter_chunk}) {{ {fields} }} }}"}
+
+            payload = json.dumps(payload)
+            if self.debug:
+                print(payload)
+            continue_loop = True
+            while continue_loop:
+                response = requests.request("POST", self.endpoint, headers=self.headers, data=payload, timeout=self.timeout)
+                if self.debug:
+                    print(response.json())
+                response.raise_for_status()
+                if board_id:
+                    data = response.json()['data']['boards'][0]['items_page']
+                else:
+                    data = response.json()['data']
+                df_temp = pd.json_normalize(data['items'])
+                df = pd.concat([df, df_temp])
+
+                # Check if there is a next page
+                cursor = data.get('cursor')
+                if cursor:
+                    if linked_board_id:
+                        payload = json.dumps({
+                            "query": f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}, cursor: \"{cursor}\") {{cursor items {{ {fields} linked_items (linked_board_id: {linked_board_id}, link_to_item_column_id: \"{source_column_id}\") {{ id column_values(ids: [\"{target_column_id}\"]) {{ id text value }} }} }} }} }} }}"
+                        })
+                    else:
+                        payload = json.dumps({
+                            "query": f"query {{boards (ids:{board_id}) {{id items_page (limit: {limit}, cursor: \"{cursor}\") {{cursor items {{ {fields} }} }} }} }}"
+                        })
+                else:
+                    continue_loop = False
+
+        return df

brynq_sdk_monday/extract_tracket.py

@@ -0,0 +1,105 @@
+from brynq_sdk_brynq import BrynQ
+import os
+import sys
+import pandas as pd
+from typing import Union, List, Literal, Optional
+import requests
+import json
+
+basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(basedir)
+
+
+class ExtractTracket(BrynQ):
+
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False):
+        """
+        For the full documentation, see: https://avisi-apps.gitbook.io/tracket/api/
+        """
+        super().__init__()
+        self.timeout = 3600
+        self.headers = self.__get_headers(system_type)
+        self.base_url = "https://us.production.timesheet.avisi-apps.com/api/2.0/"
+
+    def __get_headers(self, system_type):
+        """
+        Get the credentials for the Traket API from BrynQ, with those credentials, get the access_token for Tracket.
+        Return the headers with the access_token.
+        """
+        # Get credentials from BrynQ
+        credentials = self.interfaces.credentials.get(system="monday", system_type=system_type)
+        credentials = credentials.get('data')
+
+        # With those credentials, get the access_token from Tracket
+        endpoint = 'https://us.production.timesheet.avisi-apps.com/api/2.0/oauth2/token'
+        payload = json.dumps({
+            "grant-type": "client-credentials",
+            "monday/account-id": credentials['account_id'],
+            "client-id": credentials['client_id'],
+            "client-secret": credentials['client_secret']
+        })
+        headers = {'Content-Type': 'application/json'}
+        tracket_response = requests.request("POST", endpoint, headers=headers, data=payload, timeout=self.timeout)
+        tracket_response.raise_for_status()
+
+        # Return the headers with the access_token
+        access_token = tracket_response.json()['access_token']
+        headers = {
+            'Authorization': f"Bearer {access_token}",
+            'Content-Type': 'application/json'
+        }
+
+        return headers
+
+    def get_worklogs(self, date_start: str = None, date_end: str = None, created_since: str = None, created_up_to: str = None, updated_since: str = None, updated_up_to: str = None):
+        """
+        Get all the worklogs from Tracket.
+        :param date_start: Get all the records from a certain date and after
+        :param date_end: Get all the records until a certain date
+        :param created_since: Get all the records which are created since a certain date
+        :param created_up_to: Get all the records which are created before a certain date
+        :param updated_since: Get all the records which are updated since a certain date
+        :param updated_up_to: Get all the records which are updated before a certain date
+        """
+        endpoint = f'{self.base_url}timeEntries?size=100&'
+        if date_start:
+            endpoint = f'{endpoint}fields.date.gte={date_start}&'
+        if date_end:
+            endpoint = f'{endpoint}fields.date.lte={date_end}&'
+        if created_since:
+            endpoint = f'{endpoint}fields.createdDate.gte={created_since}&'
+        if created_up_to:
+            endpoint = f'{endpoint}fields.createdDate.lte={created_up_to}&'
+        if updated_since:
+            endpoint = f'{endpoint}fields.updatedDate.gte={updated_since}&'
+        if updated_up_to:
+            endpoint = f'{endpoint}fields.updatedDate.lte={updated_up_to}&'
+        continue_loop = True
+        df = pd.DataFrame()
+        full_url = endpoint
+        while continue_loop:
+            response = requests.get(full_url, headers=self.headers, timeout=self.timeout)
+            response.raise_for_status()
+            response_data = response.json()
+            worklogs = response_data.get('items')
+            worklogs = worklogs if worklogs else []
+            next_cursor = response_data.get('nextCursor')
+            if len(worklogs) > 0:
+                df_temp = pd.DataFrame(worklogs)
+                df = pd.concat([df, df_temp])
+            if next_cursor:
+                full_url = f'{endpoint}after={next_cursor}'
+            else:
+                continue_loop = False
+        return df
+
+    def get_categories(self):
+        """
+        Get all the hour categories from Tracket.
+        """
+        endpoint = f'{self.base_url}templates/timeEntry/fields/category/options'
+        response = requests.request("GET", endpoint, headers=self.headers, timeout=self.timeout)
+        response.raise_for_status()
+        data = response.json()['items']
+        df = pd.DataFrame(data)
+        return df

brynq_sdk_monday/upload_tracket.py

@@ -0,0 +1,150 @@
+from brynq_sdk_brynq import BrynQ
+import os
+import sys
+import pandas as pd
+from typing import Union, List, Literal, Optional
+import warnings
+import requests
+import json
+
+basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(basedir)
+
+
+class UploadTracket(BrynQ):
+
+    def __init__(self, system_type: Optional[Literal['source', 'target']] = None, debug: bool = False):
+        """
+        For the full documentation, see: https://avisi-apps.gitbook.io/tracket/api/
+        """
+        super().__init__()
+        self.timeout = 3600
+        self.headers = self.__get_headers(system_type)
+        self.base_url = "https://us.production.timesheet.avisi-apps.com/api/2.0/"
+        self.debug = debug
+
+    def __get_headers(self, system_type):
+        """
+        Get the credentials for the Traket API from BrynQ, with those credentials, get the access_token for Tracket.
+        Return the headers with the access_token.
+        """
+        # Get credentials from BrynQ
+        credentials = self.interfaces.credentials.get(system="monday", system_type=system_type)
+        credentials = credentials.get('data')
+
+        # With those credentials, get the access_token from Tracket
+        endpoint = 'https://us.production.timesheet.avisi-apps.com/api/2.0/oauth2/token'
+        payload = json.dumps({
+            "grant-type": "client-credentials",
+            "monday/account-id": credentials['account_id'],
+            "client-id": credentials['client_id'],
+            "client-secret": credentials['client_secret']
+        })
+        headers = {'Content-Type': 'application/json'}
+        tracket_response = requests.request("POST", endpoint, headers=headers, data=payload, timeout=self.timeout)
+
+        # Return the headers with the access_token
+        access_token = tracket_response.json()['access_token']
+        headers = {
+            'Authorization': f"Bearer {access_token}",
+            'Content-Type': 'application/json'
+        }
+
+        return headers
+
+    @staticmethod
+    def __check_fields(data: Union[dict, List], required_fields: List, allowed_fields: List):
+        if isinstance(data, dict):
+            data = data.keys()
+
+        for field in data:
+            if field not in allowed_fields and field not in required_fields:
+                warnings.warn('Field {field} is not implemented. Optional fields are: {allowed_fields}'.format(field=field, allowed_fields=tuple(allowed_fields)))
+
+        for field in required_fields:
+            if field not in data:
+                raise ValueError('Field {field} is required. Required fields are: {required_fields}'.format(field=field, required_fields=tuple(required_fields)))
+
+    def create_worklog(self, data: dict) -> requests.Response:
+        """
+        Create a new worklog in Tracket.
+        :param data: A dictionary with all the required fields to create a worklog.
+        """
+        required_fields = ['worklogMinutes', 'worklogDate', 'itemId', 'userId']
+        allowed_fields = ['worklogCategory', 'description', 'worklogBillableMinutes', 'team']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f'{self.base_url}timeEntries'
+
+        base_body = {
+            "minutes": data['worklogMinutes'],
+            "date": data['worklogDate'],
+            "item": data['itemId'],
+            "user": data['userId'],
+        }
+
+        if 'worklogCategory' in data:
+            base_body["customFields"] = {
+                "category": data['worklogCategory']
+            }
+
+        fields_to_update = {}
+
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        fields_to_update.update({"description": data['description']}) if 'description' in data else fields_to_update
+        fields_to_update.update({"billableMinutes": data['worklogBillableMinutes']}) if 'worklogBillableMinutes' in data else fields_to_update
+        fields_to_update.update({"team": data['team']}) if 'team' in data else fields_to_update
+        base_body.update(fields_to_update)
+
+        if self.debug:
+            print(json.dumps(base_body))
+
+        response = requests.request("POST", url, data=json.dumps(base_body), headers=self.headers, timeout=self.timeout)
+        return response
+
+    def update_worklog(self, worklog_id: str, data: dict) -> requests.Response:
+        """
+        Get all the worklogs from Tracket.
+        :param worklog_id: The ID of the worklog that you want to update.
+        :param data: A dictionary with all the required fields to update a worklog.
+        """
+        required_fields = ['worklogMinutes', 'worklogDate', 'itemId', 'userId']
+        allowed_fields = ['worklogCategory', 'description', 'worklogBillableMinutes', 'team']
+        self.__check_fields(data=data, required_fields=required_fields, allowed_fields=allowed_fields)
+
+        url = f'{self.base_url}timeEntries/{worklog_id}'
+
+        base_body = {
+            "minutes": data['worklogMinutes'],
+            "date": data['worklogDate'],
+            "item": data['itemId'],
+            "user": data['userId']
+        }
+
+        if 'worklogCategory' in data:
+            base_body["customFields"] = {
+                "category": data['worklogCategory']
+            }
+
+        fields_to_update = {}
+
+        # Add fields that you want to update a dict (adding to body itself is too much text)
+        fields_to_update.update({"description": data['description']}) if 'description' in data else fields_to_update
+        fields_to_update.update({"billableMinutes": data['worklogBillableMinutes']}) if 'worklogBillableMinutes' in data else fields_to_update
+        fields_to_update.update({"team": data['team']}) if 'team' in data else fields_to_update
+        base_body.update(fields_to_update)
+
+        if self.debug:
+            print(json.dumps(base_body))
+
+        response = requests.request("PUT", url, data=json.dumps(base_body), headers=self.headers, timeout=self.timeout)
+        return response
+
+    def delete_worklog(self, worklog_id: str) -> requests.Response:
+        """
+        Get all the worklogs from Tracket.
+        :param worklog_id: The ID of the worklog that you want to delete.
+        """
+        url = (f'{self.base_url}timeEntries/{worklog_id}')
+        response = requests.request("DELETE", url, headers=self.headers, timeout=self.timeout)
+        return response

brynq_sdk_monday-2.1.2.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: brynq_sdk_monday
+Version: 2.1.2
+Summary: Monday.com wrapper from BrynQ
+Author: BrynQ
+Author-email: support@brynq.com
+License: BrynQ License
+Requires-Dist: brynq-sdk-brynq<5,>=4
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+Monday.com wrapper from BrynQ

brynq_sdk_monday-2.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+brynq_sdk_monday/__init__.py,sha256=mBtdOdiAEp_o1RrwkUVWB9RWdJaG5R9LpmTXz-eyzwU,127
+brynq_sdk_monday/extract_monday.py,sha256=WsnIXDo0jpyGJ263-xiZo5IGI6nRjK8z-Mw1jtHXf24,15946
+brynq_sdk_monday/extract_tracket.py,sha256=M3ISHF-4t54b8gfBGZ8Latrlqv-mzq46MkSo3NEMH6A,4540
+brynq_sdk_monday/upload_tracket.py,sha256=oRcFNwWSSjebTNsgmdUm8AxPLcnWKmuNXUAE2QIKEzQ,6391
+brynq_sdk_monday-2.1.2.dist-info/METADATA,sha256=LhQZamW-EVqKhjMe_USdiljdlkzxCCjypKYaazeKQLY,352
+brynq_sdk_monday-2.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+brynq_sdk_monday-2.1.2.dist-info/top_level.txt,sha256=04GPvAhh_JA0TxgrLk__3MYMHISNjuyR-9OpiwP-vyI,17
+brynq_sdk_monday-2.1.2.dist-info/RECORD,,

brynq_sdk_monday-2.1.2.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_monday-2.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+brynq_sdk_monday