Download app.py from OCM-2/gpfgan: direct link, hf CLI and curl.
- Browser
- Download file 20.9 kB
-
https://huggingface.co/spaces/OCM-2/gpfgan/resolve/main/app.py
- Command line
-
hf download hf://spaces/OCM-2/gpfgan/app.py
-
curl -L -o app.py https://huggingface.co/spaces/OCM-2/gpfgan/resolve/main/app.py
20.9 kB
| import requests | |
| import time | |
| import logging | |
| import json | |
| import base64 | |
| import uuid | |
| import re # Add this import | |
| from datetime import datetime | |
| from flask import Flask, jsonify, request | |
| from threading import Thread | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| app = Flask(__name__) | |
| MONDAY_API_KEY = 'eyJhbGciOiJIUzI1NiJ9.eyJ0aWQiOjMxNTM4Nzc3MCwiYWFpIjoxMSwidWlkIjo0NDg2Njc1LCJpYWQiOiIyMDI0LTAxLTI5VDIwOjA4OjQ3LjAwMFoiLCJwZXIiOiJtZTp3cml0ZSIsImFjdGlkIjoyMDQxNzA0LCJyZ24iOiJ1c2UxIn0.SnGPJOO36I5UIB-RggAWhlydS6HaOMFWfewQQc6q0QQ' | |
| BOARD_ID = '6976740103' | |
| UPS_CLIENT_ID = 'LKrZBgcSZ2v7vtAn3VAmEEBXqpkXD8zIEcZum97Eb8sSl7Fx' | |
| UPS_CLIENT_SECRET = 'DBAV77mzTWgI5oqWwXlA12hi62hgyUkesoGsREZsmjd1WHMSugpDUuBGTjyUiteT' | |
| FEDEX_API_KEY = 'l705da56bf34254c3495f351772a6ea2d3' | |
| FEDEX_SECRET_KEY = 'ae27688af74341f094228fc67a36a8cc' | |
| COLUMN_IDS = { | |
| 'tracking': 'text3__1', | |
| 'courier': 'text38__1', | |
| 'estimatedDelivery': 'text65__1', | |
| 'latestLocation': 'text6__1', | |
| 'latestCheckpoint': 'text2__1', | |
| 'lastUpdateDateTime': 'text54__1', | |
| 'recipientInfo': 'long_text6__1' # Added this line | |
| } | |
| def get_fedex_access_token(): | |
| url = "https://apis.fedex.com/oauth/token" | |
| headers = { | |
| 'Content-Type': "application/x-www-form-urlencoded" | |
| } | |
| payload = { | |
| 'grant_type': 'client_credentials', | |
| 'client_id': FEDEX_API_KEY, | |
| 'client_secret': FEDEX_SECRET_KEY | |
| } | |
| try: | |
| logger.info("Requesting FedEx token") | |
| logger.info(f"FedEx API Key: {FEDEX_API_KEY}") | |
| logger.info(f"Request URL: {url}") | |
| logger.info(f"Request headers: {headers}") | |
| logger.info(f"Request payload: {payload}") | |
| response = requests.post(url, data=payload, headers=headers) | |
| logger.info(f"Response status code: {response.status_code}") | |
| logger.info(f"Response headers: {dict(response.headers)}") | |
| logger.info(f"Response content: {response.text}") | |
| response.raise_for_status() | |
| token_data = response.json() | |
| return token_data['access_token'] | |
| except requests.exceptions.RequestException as e: | |
| logger.error(f"Error obtaining FedEx access token: {e}") | |
| if hasattr(e, 'response'): | |
| logger.error(f"Response status code: {e.response.status_code}") | |
| logger.error(f"Response headers: {dict(e.response.headers)}") | |
| logger.error(f"Response content: {e.response.text}") | |
| raise | |
| def fetch_board_items(): | |
| query = f""" | |
| query {{ | |
| boards(ids: {BOARD_ID}) {{ | |
| items_page(limit: 100) {{ | |
| items {{ | |
| id | |
| name | |
| column_values {{ | |
| id | |
| text | |
| }} | |
| }} | |
| }} | |
| }} | |
| }} | |
| """ | |
| headers = { | |
| 'Content-Type': 'application/json', | |
| 'Authorization': MONDAY_API_KEY | |
| } | |
| response = requests.post('https://api.monday.com/v2', headers=headers, json={'query': query}) | |
| response.raise_for_status() | |
| result = response.json() | |
| logger.info(f'Raw Monday.com API response: {json.dumps(result, indent=2)}') | |
| if 'errors' in result: | |
| raise Exception(result['errors'][0]['message']) | |
| return result['data']['boards'][0]['items_page']['items'] | |
| def get_ups_access_token(): | |
| token_url = "https://onlinetools.ups.com/security/v1/oauth/token" | |
| headers = { | |
| 'Content-Type': 'application/x-www-form-urlencoded', | |
| 'Accept': 'application/json', | |
| 'User-Agent': 'OCMTrackingApp/1.0', | |
| 'transId': str(uuid.uuid4()), | |
| 'transactionSrc': 'OCMTrackingApp' | |
| } | |
| credentials = base64.b64encode(f"{UPS_CLIENT_ID}:{UPS_CLIENT_SECRET}".encode()).decode() | |
| headers['Authorization'] = f'Basic {credentials}' | |
| data = { | |
| 'grant_type': 'client_credentials' | |
| } | |
| try: | |
| logger.info("Requesting UPS token") | |
| response = requests.post(token_url, headers=headers, data=data) | |
| response.raise_for_status() | |
| token_data = response.json() | |
| return token_data['access_token'] | |
| except requests.exceptions.RequestException as e: | |
| logger.error(f"Error obtaining UPS access token: {e}") | |
| if hasattr(e, 'response'): | |
| logger.error(f"Response content: {e.response.text}") | |
| raise | |
| def fetch_ups_tracking_info(tracking_number): | |
| access_token = get_ups_access_token() | |
| url = f"https://onlinetools.ups.com/api/track/v1/details/{tracking_number}" | |
| headers = { | |
| 'Authorization': f'Bearer {access_token}', | |
| 'Content-Type': 'application/json', | |
| 'Accept': 'application/json', | |
| 'User-Agent': 'OCMTrackingApp/1.0', | |
| 'transId': str(uuid.uuid4()), | |
| 'transactionSrc': 'OCMTrackingApp' | |
| } | |
| params = { | |
| "locale": "en_US", | |
| "returnSignature": "false", | |
| "returnMilestones": "false", | |
| "returnPOD": "false" | |
| } | |
| try: | |
| logger.info(f"Requesting UPS tracking info for {tracking_number}") | |
| response = requests.get(url, headers=headers, params=params) | |
| response.raise_for_status() | |
| data = response.json() | |
| shipment = data['trackResponse']['shipment'][0] | |
| package = shipment['package'][0] | |
| events = package.get('activity', []) | |
| if events: | |
| sorted_events = sorted(events, key=lambda x: x['date'] + x['time'], reverse=True) | |
| latest_event = sorted_events[0] | |
| else: | |
| latest_event = None | |
| def format_date(date_str, time_str): | |
| if not date_str or not time_str or date_str == 'N/A' or time_str == 'N/A': | |
| return 'N/A' | |
| try: | |
| date = datetime.strptime(date_str + time_str, '%Y%m%d%H%M%S') | |
| return date.strftime('%m/%d/%Y %I:%M %p') | |
| except ValueError: | |
| logger.warning(f"Unable to parse date: {date_str} or time: {time_str}") | |
| return 'N/A' | |
| delivery_date = 'N/A' | |
| delivery_time = 'N/A' | |
| if 'deliveryDate' in package: | |
| if isinstance(package['deliveryDate'], list) and package['deliveryDate']: | |
| delivery_date = package['deliveryDate'][0].get('date', 'N/A') | |
| elif isinstance(package['deliveryDate'], dict): | |
| delivery_date = package['deliveryDate'].get('date', 'N/A') | |
| if 'deliveryTime' in package: | |
| delivery_time = package['deliveryTime'].get('endTime', 'N/A') | |
| return { | |
| 'status': latest_event['status']['type'] if latest_event else 'N/A', | |
| 'courier': 'UPS', | |
| 'estimatedDelivery': format_date(delivery_date, delivery_time), | |
| 'latestLocation': latest_event['location']['address'].get('city', 'N/A') if latest_event else 'N/A', | |
| 'latestCheckpoint': latest_event['status']['description'] if latest_event else 'N/A', | |
| 'lastUpdateDateTime': format_date(latest_event['date'], latest_event['time']) if latest_event else 'N/A', | |
| 'latestEventId': latest_event['status']['statusCode'] if latest_event else 'N/A', | |
| 'rawTimestamp': latest_event['date'] + latest_event['time'] if latest_event else None | |
| } | |
| except requests.exceptions.RequestException as e: | |
| logger.error(f"Error fetching UPS tracking info: {e}") | |
| if hasattr(e, 'response'): | |
| logger.error(f"Response content: {e.response.text}") | |
| raise | |
| def fetch_fedex_tracking_info(tracking_number): | |
| access_token = get_fedex_access_token() | |
| url = "https://apis.fedex.com/track/v1/trackingnumbers" | |
| headers = { | |
| 'Content-Type': "application/json", | |
| 'X-locale': "en_US", | |
| 'Authorization': f"Bearer {access_token}" | |
| } | |
| payload = { | |
| "trackingInfo": [ | |
| { | |
| "trackingNumberInfo": { | |
| "trackingNumber": tracking_number | |
| } | |
| } | |
| ], | |
| "includeDetailedScans": True | |
| } | |
| try: | |
| logger.info(f"Requesting FedEx tracking info for {tracking_number}") | |
| logger.info(f"Request URL: {url}") | |
| logger.info(f"Request headers: {headers}") | |
| logger.info(f"Request payload: {payload}") | |
| response = requests.post(url, json=payload, headers=headers) | |
| logger.info(f"Response status code: {response.status_code}") | |
| logger.info(f"Response headers: {dict(response.headers)}") | |
| logger.info(f"Response content: {response.text}") | |
| response.raise_for_status() | |
| data = response.json() | |
| track_results = data['output']['completeTrackResults'][0]['trackResults'][0] | |
| latest_status = track_results['latestStatusDetail'] | |
| scan_events = track_results.get('scanEvents', []) | |
| def format_date(date_str): | |
| if not date_str or date_str == 'N/A': | |
| return 'N/A' | |
| try: | |
| date = datetime.fromisoformat(date_str.replace('Z', '+00:00')) | |
| return date.strftime('%m/%d/%Y %I:%M %p') | |
| except ValueError: | |
| logger.warning(f"Unable to parse date: {date_str}") | |
| return 'N/A' | |
| # Extract recipient information | |
| recipient_info = track_results.get('recipientInformation', {}).get('address', {}) | |
| street_lines = recipient_info.get('streetLines', []) | |
| recipient_address = '\n'.join(street_lines) if street_lines else 'Address not available' | |
| city = recipient_info.get('city', '') | |
| state = recipient_info.get('stateOrProvinceCode', '') | |
| postal_code = recipient_info.get('postalCode', '') | |
| country = recipient_info.get('countryName', '') | |
| # Combine all the address information into a single formatted string | |
| recipient_city_state = ', '.join(filter(None, [city, state])) | |
| if postal_code: | |
| recipient_city_state += f" {postal_code}" | |
| recipient_full_info = f"{recipient_address}\n{recipient_city_state}\n{country}".strip() | |
| # If recipient_address is 'Address not available', adjust formatting | |
| if recipient_address == 'Address not available': | |
| recipient_full_info = f"{recipient_city_state}\n{country}".strip() | |
| # If city and state are also missing, set recipient_full_info to 'Recipient information not available' | |
| if not recipient_city_state.strip(', '): | |
| recipient_full_info = 'Recipient information not available' | |
| estimated_delivery = 'N/A' | |
| # Check all dateAndTimes entries for estimated delivery | |
| for date_time in track_results.get('dateAndTimes', []): | |
| if date_time.get('type') == 'ESTIMATED_DELIVERY': | |
| estimated_delivery = format_date(date_time.get('dateTime')) | |
| break | |
| # If no estimated delivery found in dateAndTimes, fall back to transit time windows | |
| if estimated_delivery == 'N/A': | |
| if 'standardTransitTimeWindow' in track_results and 'window' in track_results['standardTransitTimeWindow'] and 'ends' in track_results['standardTransitTimeWindow']['window']: | |
| estimated_delivery = format_date(track_results['standardTransitTimeWindow']['window']['ends']) | |
| elif 'estimatedDeliveryTimeWindow' in track_results and 'window' in track_results['estimatedDeliveryTimeWindow'] and 'ends' in track_results['estimatedDeliveryTimeWindow']['window']: | |
| estimated_delivery = format_date(track_results['estimatedDeliveryTimeWindow']['window']['ends']) | |
| if 'scanLocation' in latest_status and 'city' in latest_status['scanLocation']: | |
| location = f"{latest_status['scanLocation']['city']}, {latest_status['scanLocation'].get('stateOrProvinceCode', 'N/A')}" | |
| else: | |
| location = 'N/A' | |
| # Get the latest event time | |
| latest_event_time = format_date(latest_status.get('scanDateTime')) | |
| if latest_event_time == 'N/A' and scan_events: | |
| latest_event_time = format_date(scan_events[0].get('date')) | |
| # Get delivery time if the package is delivered | |
| delivery_time = 'N/A' | |
| if latest_status.get('statusByLocale') == 'Delivered': | |
| for date_time in track_results.get('dateAndTimes', []): | |
| if date_time.get('type') == 'ACTUAL_DELIVERY': | |
| delivery_time = format_date(date_time.get('dateTime')) | |
| break | |
| # Append reasonDescription to latestCheckpoint if there's a shipment exception | |
| latest_checkpoint = latest_status.get('description', 'N/A') | |
| if latest_status.get('code') == 'SE': | |
| reason_description = latest_status.get('ancillaryDetails', [{}])[0].get('reasonDescription', '') | |
| if reason_description: | |
| latest_checkpoint += f" ({reason_description})" | |
| # Return the delivery time if available, otherwise return the latest event time | |
| last_update_date_time = delivery_time if delivery_time != 'N/A' else latest_event_time | |
| return { | |
| 'status': latest_status.get('statusByLocale', 'N/A'), | |
| 'courier': 'FedEx', | |
| 'estimatedDelivery': estimated_delivery, | |
| 'latestLocation': location, | |
| 'latestCheckpoint': latest_checkpoint, | |
| 'lastUpdateDateTime': last_update_date_time, | |
| 'latestEventId': latest_status.get('code', 'N/A'), | |
| 'rawTimestamp': latest_status.get('scanDateTime') or (scan_events[0].get('date') if scan_events else 'N/A'), | |
| 'recipientInfo': recipient_full_info # This now includes the full address | |
| } | |
| except requests.exceptions.RequestException as e: | |
| logger.error(f"Error fetching FedEx tracking info: {e}") | |
| if hasattr(e, 'response'): | |
| logger.error(f"Response status code: {e.response.status_code}") | |
| logger.error(f"Response headers: {dict(e.response.headers)}") | |
| logger.error(f"Response content: {e.response.text}") | |
| raise | |
| except (KeyError, IndexError) as e: | |
| logger.error(f"Error parsing FedEx tracking info: {e}") | |
| logger.error(f"Response content: {data}") | |
| raise | |
| def update_monday_columns(item_id, status, courier, estimatedDelivery, latestLocation, latestCheckpoint, lastUpdateDateTime, latestEventId, recipientInfo): | |
| column_values = { | |
| COLUMN_IDS['courier']: courier, | |
| COLUMN_IDS['estimatedDelivery']: estimatedDelivery, | |
| COLUMN_IDS['latestLocation']: latestLocation, | |
| COLUMN_IDS['latestCheckpoint']: latestCheckpoint, | |
| COLUMN_IDS['lastUpdateDateTime']: lastUpdateDateTime, | |
| COLUMN_IDS['recipientInfo']: recipientInfo # Added this line | |
| } | |
| logger.info(f'Updating item {item_id} with values: {json.dumps(column_values, indent=2)}') | |
| mutation = f""" | |
| mutation {{ | |
| change_multiple_column_values( | |
| board_id: {BOARD_ID}, | |
| item_id: {item_id}, | |
| column_values: {json.dumps(json.dumps(column_values))} | |
| ) {{ | |
| id | |
| }} | |
| }} | |
| """ | |
| headers = { | |
| 'Authorization': MONDAY_API_KEY, | |
| 'Content-Type': 'application/json' | |
| } | |
| response = requests.post('https://api.monday.com/v2', headers=headers, json={'query': mutation}) | |
| response.raise_for_status() | |
| result = response.json() | |
| if 'errors' in result: | |
| raise Exception(result['errors'][0]['message']) | |
| logger.info(f'Successfully updated item {item_id}') | |
| def clean_tracking_number(tracking_number): | |
| # Remove all non-alphanumeric characters | |
| return re.sub(r'[^a-zA-Z0-9]', '', tracking_number) | |
| def process_trackings(force_update=False): | |
| try: | |
| items = fetch_board_items() | |
| for item in items: | |
| item_id = item['id'] | |
| tracking_number = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['tracking']), None) | |
| courier = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['courier']), None) | |
| if tracking_number: | |
| # Clean the tracking number | |
| tracking_number = clean_tracking_number(tracking_number) | |
| try: | |
| # Detect courier if not specified | |
| if not courier or courier.strip() == '': | |
| if tracking_number.startswith('1Z'): | |
| courier = 'UPS' | |
| elif len(tracking_number) == 12 and tracking_number.isdigit(): | |
| courier = 'FedEx' | |
| else: | |
| logger.warning(f"Unable to detect courier for tracking number {tracking_number}") | |
| continue | |
| if courier.lower() == 'ups': | |
| tracking_details = fetch_ups_tracking_info(tracking_number) | |
| elif courier.lower() == 'fedex': | |
| tracking_details = fetch_fedex_tracking_info(tracking_number) | |
| else: | |
| logger.warning(f"Unsupported courier: {courier} for tracking number {tracking_number}") | |
| continue | |
| latest_event_id = tracking_details.pop('latestEventId') | |
| raw_timestamp = tracking_details.pop('rawTimestamp') | |
| recipient_info = tracking_details.pop('recipientInfo', 'N/A') | |
| current_update_time = next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['lastUpdateDateTime']), None) | |
| logger.info(f'Current update time for item {item_id}: {current_update_time}') | |
| logger.info(f'Raw timestamp for item {item_id}: {raw_timestamp}') | |
| if force_update or not current_update_time or (raw_timestamp and (current_update_time == 'N/A' or raw_timestamp > current_update_time)): | |
| update_monday_columns(item_id, **tracking_details, latestEventId=latest_event_id, recipientInfo=recipient_info) | |
| logger.info(f'Updated item {item_id} with tracking number {tracking_number}') | |
| else: | |
| logger.info(f'No update needed for item {item_id} with tracking number {tracking_number}') | |
| except Exception as e: | |
| logger.error(f'Failed to process tracking number {tracking_number} for item {item_id}: {e}') | |
| logger.info('Finished processing all tracking numbers.') | |
| except Exception as e: | |
| logger.error(f'Error processing trackings: {e}') | |
| def background_task(): | |
| while True: | |
| process_trackings() | |
| time.sleep(300) # 5 minutes | |
| def home(): | |
| return "Tracking update service is running." | |
| def trigger_update(): | |
| try: | |
| process_trackings(force_update=True) | |
| return jsonify({"status": "success", "message": "Tracking update triggered successfully"}), 200 | |
| except Exception as e: | |
| return jsonify({"status": "error", "message": str(e)}), 500 | |
| def update_specific_tracking(): | |
| tracking_number = request.json.get('tracking_number') | |
| courier = request.json.get('courier') | |
| if not tracking_number or not courier: | |
| return jsonify({"status": "error", "message": "Tracking number and courier are required"}), 400 | |
| try: | |
| items = fetch_board_items() | |
| for item in items: | |
| if next((col['text'] for col in item['column_values'] if col['id'] == COLUMN_IDS['tracking']), None) == tracking_number: | |
| if courier.lower() == 'ups': | |
| tracking_details = fetch_ups_tracking_info(tracking_number) | |
| elif courier.lower() == 'fedex': | |
| tracking_details = fetch_fedex_tracking_info(tracking_number) | |
| else: | |
| return jsonify({"status": "error", "message": f"Unsupported courier: {courier}"}), 400 | |
| latest_event_id = tracking_details.pop('latestEventId') | |
| tracking_details.pop('rawTimestamp') # Remove raw timestamp before updating | |
| update_monday_columns(item['id'], **tracking_details, latestEventId=latest_event_id) | |
| return jsonify({"status": "success", "message": f"Updated tracking for {tracking_number}"}), 200 | |
| return jsonify({"status": "error", "message": "Tracking number not found in board"}), 404 | |
| except Exception as e: | |
| return jsonify({"status": "error", "message": str(e)}), 500 | |
| def status(): | |
| return jsonify({"status": "operational"}), 200 | |
| if __name__ == '__main__': | |
| thread = Thread(target=background_task) | |
| thread.daemon = True | |
| thread.start() | |
| app.run(host='0.0.0.0', port=7860) |