machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/utils/cloud/onedrive/transaction.py

@@ -15,12 +15,12 @@ Requirements:
     pip install requests
 
 Setup Options:
-    
+
     Option 1: Direct OAuth2 Setup (Recommended)
     1. Run setup_oauth_authentication() for first-time setup
     2. Follow the interactive prompts to authorize
     3. Tokens will be automatically saved and refreshed
-    
+
     Option 2: Using existing rclone token
     1. Update the RCLONE_TOKEN with your rclone token
     2. Set DRIVE_ID from your rclone config
@@ -63,10 +63,10 @@ _cached_config = None
 def get_config(section: str = "odp") -> dict[str, Any]:
     """
     Get OneDrive configuration from rclone config.
-    
+
     Args:
         section: The rclone config section name (default: "odp")
-        
+
     Returns:
         Dictionary containing token, drive_id, and drive_type
     """
@@ -75,20 +75,20 @@ def get_config(section: str = "odp") -> dict[str, Any]:
         rclone_config = get_rclone_token(section)
         if not rclone_config:
             raise Exception(f"Could not find rclone config section '{section}'. Please set up rclone first.")
-        
+
         # Parse the token from rclone config
         token_str = rclone_config.get("token", "{}")
         try:
             token_data = json.loads(token_str)
         except json.JSONDecodeError:
             raise Exception(f"Invalid token format in rclone config section '{section}'")
-        
+
         _cached_config = {
             "token": token_data,
             "drive_id": rclone_config.get("drive_id"),
             "drive_type": rclone_config.get("drive_type", "personal")
         }
-    
+
     return _cached_config
 
 def get_token() -> dict[str, Any]:
@@ -121,7 +121,7 @@ OAUTH_TOKEN_ENDPOINT = "https://login.microsoftonline.com/common/oauth2/v2.0/tok
 def is_token_valid() -> bool:
     """
     Check if the current rclone token is still valid.
-    
+
     Returns:
         True if token is valid, False otherwise
     """
@@ -131,16 +131,16 @@ def is_token_valid() -> bool:
         expiry_str = token.get("expiry")
         if not expiry_str:
             return False
-            
+
         # Remove timezone info for parsing (rclone format includes timezone)
         if '+' in expiry_str:
             expiry_str = expiry_str.split('+')[0]
         elif 'Z' in expiry_str:
             expiry_str = expiry_str.replace('Z', '')
-        
+
         expiry_time = datetime.fromisoformat(expiry_str)
         current_time = datetime.now()
-        
+
         # Add some buffer time (5 minutes)
         return expiry_time > current_time + timedelta(minutes=5)
     except Exception as e:
@@ -151,16 +151,16 @@ def is_token_valid() -> bool:
 def get_access_token() -> Optional[str]:
     """
     Get access token, automatically refreshing if expired.
-    
+
     Returns:
         Access token string or None if token cannot be obtained/refreshed
     """
     # First try to load token from file if it exists
     load_token_from_file()
-    
+
     if not is_token_valid():
         print("🔄 Access token has expired, attempting to refresh...")
-        
+
         # Try to refresh the token
         refreshed_token = refresh_access_token()
         if refreshed_token:
@@ -171,7 +171,7 @@ def get_access_token() -> Optional[str]:
             print("1. Run setup_oauth_authentication() to set up OAuth")
             print("2. Update your rclone token by running: rclone config reconnect odp")
             return None
-    
+
     token = get_token()
     return token.get("access_token")
 
@@ -179,72 +179,72 @@ def get_access_token() -> Optional[str]:
 def make_graph_request(method: str, endpoint: str, **kwargs: Any) -> requests.Response:
     """
     Make authenticated request to Microsoft Graph API.
-    
+
     Args:
         method: HTTP method (GET, POST, PUT, etc.)
         endpoint: API endpoint (without base URL)
         **kwargs: Additional arguments for requests
-        
+
     Returns:
         Response object
-        
+
     Raises:
         Exception: If authentication fails or request fails
     """
     token = get_access_token()
     if not token:
         raise Exception("Failed to get valid access token")
-    
+
     headers = kwargs.get('headers', {})
     headers['Authorization'] = f'Bearer {token}'
     kwargs['headers'] = headers
-    
+
     url = f"{GRAPH_API_BASE}/{endpoint.lstrip('/')}"
     response = requests.request(method, url, **kwargs)
-    
+
     return response
 
 
 def push_to_onedrive(local_path: str, remote_path: str) -> bool:
     """
     Push a file from local system to OneDrive.
-    
+
     Args:
         local_path: Path to the local file
         remote_path: Path where the file should be stored in OneDrive
                     (e.g., "/Documents/myfile.txt")
-        
+
     Returns:
         True if successful, False otherwise
     """
     local_file = Path(local_path)
-    
+
     if not local_file.exists():
         print(f"Local file does not exist: {local_path}")
         return False
-    
+
     if not local_file.is_file():
         print(f"Path is not a file: {local_path}")
         return False
-    
+
     # Ensure remote path starts with /
     if not remote_path.startswith('/'):
         remote_path = '/' + remote_path
-    
+
     # Create parent directories if they don't exist
     remote_dir = os.path.dirname(remote_path)
     if remote_dir and remote_dir != '/':
         create_remote_directory(remote_dir)
-    
+
     try:
         file_size = local_file.stat().st_size
-        
+
         # For small files (< 4MB), use simple upload
         if file_size < 4 * 1024 * 1024:
             return simple_upload(local_file, remote_path)
         else:
             return resumable_upload(local_file, remote_path)
-            
+
     except Exception as e:
         print(f"Error uploading file: {e}")
         return False
@@ -255,21 +255,21 @@ def simple_upload(local_file: Path, remote_path: str) -> bool:
     try:
         with open(local_file, 'rb') as f:
             file_content = f.read()
-        
+
         # URL encode the remote path and use specific drive
         encoded_path = quote(remote_path, safe='/')
         drive_id = get_drive_id()
         endpoint = f"drives/{drive_id}/root:{encoded_path}:/content"
-        
+
         response = make_graph_request('PUT', endpoint, data=file_content)
-        
+
         if response.status_code in [200, 201]:
             print(f"Successfully uploaded: {local_file} -> {remote_path}")
             return True
         else:
             print(f"Upload failed: {response.status_code} - {response.text}")
             return False
-            
+
     except Exception as e:
         print(f"Simple upload error: {e}")
         return False
@@ -282,41 +282,41 @@ def resumable_upload(local_file: Path, remote_path: str) -> bool:
         encoded_path = quote(remote_path, safe='/')
         drive_id = get_drive_id()
         endpoint = f"drives/{drive_id}/root:{encoded_path}:/createUploadSession"
-        
+
         item_data = {
             "item": {
                 "@microsoft.graph.conflictBehavior": "replace",
                 "name": local_file.name
             }
         }
-        
+
         response = make_graph_request('POST', endpoint, json=item_data)
-        
+
         if response.status_code != 200:
             print(f"Failed to create upload session: {response.status_code} - {response.text}")
             return False
-        
+
         upload_url = response.json()['uploadUrl']
         file_size = local_file.stat().st_size
         chunk_size = 320 * 1024  # 320KB chunks
-        
+
         with open(local_file, 'rb') as f:
             bytes_uploaded = 0
-            
+
             while bytes_uploaded < file_size:
                 chunk_data = f.read(chunk_size)
                 if not chunk_data:
                     break
-                
+
                 chunk_end = min(bytes_uploaded + len(chunk_data) - 1, file_size - 1)
-                
+
                 headers = {
                     'Content-Range': f'bytes {bytes_uploaded}-{chunk_end}/{file_size}',
                     'Content-Length': str(len(chunk_data))
                 }
-                
+
                 chunk_response = requests.put(upload_url, data=chunk_data, headers=headers)
-                
+
                 if chunk_response.status_code in [202, 200, 201]:
                     bytes_uploaded += len(chunk_data)
                     progress = (bytes_uploaded / file_size) * 100
@@ -324,10 +324,10 @@ def resumable_upload(local_file: Path, remote_path: str) -> bool:
                 else:
                     print(f"Chunk upload failed: {chunk_response.status_code} - {chunk_response.text}")
                     return False
-        
+
         print(f"Successfully uploaded: {local_file} -> {remote_path}")
         return True
-        
+
     except Exception as e:
         print(f"Resumable upload error: {e}")
         return False
@@ -336,70 +336,70 @@ def resumable_upload(local_file: Path, remote_path: str) -> bool:
 def pull_from_onedrive(remote_path: str, local_path: str) -> bool:
     """
     Pull a file from OneDrive to local system.
-    
+
     Args:
         remote_path: Path to the file in OneDrive (e.g., "/Documents/myfile.txt")
         local_path: Path where the file should be saved locally
-        
+
     Returns:
         True if successful, False otherwise
     """
     # Ensure remote path starts with /
     if not remote_path.startswith('/'):
         remote_path = '/' + remote_path
-    
+
     try:
         # Get file metadata and download URL using specific drive
         encoded_path = quote(remote_path, safe='/')
         drive_id = get_drive_id()
         endpoint = f"drives/{drive_id}/root:{encoded_path}"
-        
+
         response = make_graph_request('GET', endpoint)
-        
+
         if response.status_code == 404:
             print(f"File not found in OneDrive: {remote_path}")
             return False
         elif response.status_code != 200:
             print(f"Failed to get file info: {response.status_code} - {response.text}")
             return False
-        
+
         file_info = response.json()
-        
+
         # Check if it's a file (not a folder)
         if 'folder' in file_info:
             print(f"Path is a folder, not a file: {remote_path}")
             return False
-        
+
         # Get download URL
         download_url = file_info.get('@microsoft.graph.downloadUrl')
         if not download_url:
             print("No download URL available")
             return False
-        
+
         # Create local directory if it doesn't exist
         local_file = Path(local_path)
         local_file.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Download the file
         download_response = requests.get(download_url, stream=True)
         download_response.raise_for_status()
-        
+
         file_size = int(file_info.get('size', 0))
         bytes_downloaded = 0
-        
+
         with open(local_file, 'wb') as f:
             for chunk in download_response.iter_content(chunk_size=8192):
                 if chunk:
                     f.write(chunk)
                     bytes_downloaded += len(chunk)
-                    
+
                     if file_size > 0:
                         progress = (bytes_downloaded / file_size) * 100
                         print(f"Download progress: {progress:.1f}%")
-        
+
         print(f"Successfully downloaded: {remote_path} -> {local_path}")
         return True
-        
+
     except Exception as e:
         print(f"Error downloading file: {e}")
         return False
@@ -408,64 +408,64 @@ def pull_from_onedrive(remote_path: str, local_path: str) -> bool:
 def create_remote_directory(remote_path: str) -> bool:
     """
     Create a directory in OneDrive if it doesn't exist.
-    
+
     Args:
         remote_path: Path to the directory in OneDrive
-        
+
     Returns:
         True if successful or already exists, False otherwise
     """
     if not remote_path or remote_path == '/':
         return True
-    
+
     # Ensure remote path starts with /
     if not remote_path.startswith('/'):
         remote_path = '/' + remote_path
-    
+
     try:
         # Check if directory already exists using specific drive
         encoded_path = quote(remote_path, safe='/')
         drive_id = get_drive_id()
         endpoint = f"drives/{drive_id}/root:{encoded_path}"
-        
+
         response = make_graph_request('GET', endpoint)
-        
+
         if response.status_code == 200:
             # Directory already exists
             return True
         elif response.status_code != 404:
             print(f"Error checking directory: {response.status_code} - {response.text}")
             return False
-        
+
         # Create parent directory first
         parent_dir = os.path.dirname(remote_path)
         if parent_dir and parent_dir != '/':
             if not create_remote_directory(parent_dir):
                 return False
-        
+
         # Create the directory
         dir_name = os.path.basename(remote_path)
         parent_encoded = quote(parent_dir if parent_dir else '/', safe='/')
-        
+
         if parent_dir and parent_dir != '/':
             endpoint = f"drives/{drive_id}/root:{parent_encoded}:/children"
         else:
             endpoint = f"drives/{drive_id}/root/children"
-        
+
         folder_data = {
             "name": dir_name,
             "folder": {},
             "@microsoft.graph.conflictBehavior": "replace"
         }
-        
+
         response = make_graph_request('POST', endpoint, json=folder_data)
-        
+
         if response.status_code in [200, 201]:
             return True
         else:
             print(f"Failed to create directory: {response.status_code} - {response.text}")
             return False
-            
+
     except Exception as e:
         print(f"Error creating directory: {e}")
         return False
@@ -474,7 +474,7 @@ def create_remote_directory(remote_path: str) -> bool:
 def refresh_access_token() -> Optional[dict[str, Any]]:
     """
     Refresh the access token using the refresh token.
-    
+
     Returns:
         New token dictionary with access_token, refresh_token, and expiry, or None if failed
     """
@@ -483,9 +483,9 @@ def refresh_access_token() -> Optional[dict[str, Any]]:
     if not refresh_token:
         print("ERROR: No refresh token available!")
         return None
-    
+
     print("🔄 Refreshing access token...")
-    
+
     # Prepare the token refresh request
     data = {
         'client_id': CLIENT_ID,
@@ -493,25 +493,25 @@ def refresh_access_token() -> Optional[dict[str, Any]]:
         'refresh_token': refresh_token,
         'scope': 'https://graph.microsoft.com/Files.ReadWrite.All offline_access'
     }
-    
+
     # Add client secret if available (for confidential clients)
     if CLIENT_SECRET and CLIENT_SECRET != "your_client_secret_here":
         data['client_secret'] = CLIENT_SECRET
-    
+
     headers = {
         'Content-Type': 'application/x-www-form-urlencoded'
     }
-    
+
     try:
         response = requests.post(OAUTH_TOKEN_ENDPOINT, data=data, headers=headers)
-        
+
         if response.status_code == 200:
             token_data = response.json()
-            
+
             # Calculate expiry time (tokens typically last 1 hour)
             expires_in = token_data.get('expires_in', 3600)  # Default to 1 hour
             expiry_time = datetime.now() + timedelta(seconds=expires_in)
-            
+
             # Update the cached token configuration
             new_token = {
                 'access_token': token_data['access_token'],
@@ -519,27 +519,27 @@ def refresh_access_token() -> Optional[dict[str, Any]]:
                 'refresh_token': token_data.get('refresh_token', refresh_token),  # Use new or keep old
                 'expiry': expiry_time.isoformat()
             }
-            
+
             # Update the cached config
             global _cached_config
             if _cached_config is not None:
                 _cached_config["token"] = new_token
             else:
                 clear_config_cache()  # Force reload on next access
-            
+
             print("✅ Access token refreshed successfully!")
             print(f"🕒 New token expires at: {expiry_time}")
-            
+
             # Optionally save the new token to a file for persistence
             save_token_to_file(new_token)
-            
+
             return new_token
-            
+
         else:
             print(f"❌ Token refresh failed: {response.status_code}")
             print(f"Response: {response.text}")
             return None
-            
+
     except Exception as e:
         print(f"❌ Error refreshing token: {e}")
         return None
@@ -548,31 +548,31 @@ def refresh_access_token() -> Optional[dict[str, Any]]:
 def save_token_to_file(token_data: dict[str, Any], file_path: Optional[str] = None) -> bool:
     """
     Save token data to a file for persistence.
-    
+
     Args:
         token_data: Token dictionary to save
         file_path: Optional path to save the token file
-        
+
     Returns:
         True if successful, False otherwise
     """
     if not file_path:
         # Default to a hidden file in user's home directory
         file_path = os.path.expanduser("~/.onedrive_token.json")
-    
+
     try:
         # Create directory if it doesn't exist
         os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        
+
         with open(file_path, 'w') as f:
             json.dump(token_data, f, indent=2)
-        
+
         # Set restrictive permissions (readable only by owner)
         os.chmod(file_path, 0o600)
-        
+
         print(f"💾 Token saved to: {file_path}")
         return True
-        
+
     except Exception as e:
         print(f"❌ Error saving token: {e}")
         return False
@@ -581,34 +581,34 @@ def save_token_to_file(token_data: dict[str, Any], file_path: Optional[str] = No
 def load_token_from_file(file_path: Optional[str] = None) -> Optional[dict[str, Any]]:
     """
     Load token data from a file.
-    
+
     Args:
         file_path: Optional path to load the token file from
-        
+
     Returns:
         Token dictionary or None if failed
     """
     if not file_path:
         file_path = os.path.expanduser("~/.onedrive_token.json")
-    
+
     try:
         if os.path.exists(file_path):
             with open(file_path, 'r') as f:
                 token_data = json.load(f)
-            
+
             # Update the cached config token
             global _cached_config
             if _cached_config is not None:
                 _cached_config["token"] = token_data
             else:
                 clear_config_cache()  # Force reload on next access
-            
+
             print(f"📂 Token loaded from: {file_path}")
             return token_data
         else:
             print(f"ℹ️  No saved token file found at: {file_path}")
             return None
-            
+
     except Exception as e:
         print(f"❌ Error loading token: {e}")
         return None
@@ -618,12 +618,12 @@ def get_authorization_url() -> str:
     """
     Generate the authorization URL for initial OAuth setup.
     This is needed only for the first-time setup to get the initial tokens.
-    
+
     Returns:
         Authorization URL string
     """
     from urllib.parse import urlencode
-    
+
     params = {
         'client_id': CLIENT_ID,
         'response_type': 'code',
@@ -632,7 +632,7 @@ def get_authorization_url() -> str:
         'scope': 'https://graph.microsoft.com/Files.ReadWrite.All offline_access',
         'state': 'onedrive_auth'
     }
-    
+
     auth_url = f"https://login.microsoftonline.com/common/oauth2/v2.0/authorize?{urlencode(params)}"
     return auth_url
 
@@ -641,10 +641,10 @@ def exchange_authorization_code(authorization_code: str) -> Optional[dict[str, A
     """
     Exchange authorization code for initial tokens.
     This is used during the first-time OAuth setup.
-    
+
     Args:
         authorization_code: The authorization code received from the callback
-        
+
     Returns:
         Token dictionary or None if failed
     """
@@ -655,32 +655,32 @@ def exchange_authorization_code(authorization_code: str) -> Optional[dict[str, A
         'redirect_uri': REDIRECT_URI,
         'scope': 'https://graph.microsoft.com/Files.ReadWrite.All offline_access'
     }
-    
+
     # Add client secret if available
     if CLIENT_SECRET and CLIENT_SECRET != "your_client_secret_here":
         data['client_secret'] = CLIENT_SECRET
-    
+
     headers = {
         'Content-Type': 'application/x-www-form-urlencoded'
     }
-    
+
     try:
         response = requests.post(OAUTH_TOKEN_ENDPOINT, data=data, headers=headers)
-        
+
         if response.status_code == 200:
             token_data = response.json()
-            
+
             # Calculate expiry time
             expires_in = token_data.get('expires_in', 3600)
             expiry_time = datetime.now() + timedelta(seconds=expires_in)
-            
+
             new_token = {
                 'access_token': token_data['access_token'],
                 'token_type': token_data.get('token_type', 'Bearer'),
                 'refresh_token': token_data['refresh_token'],
                 'expiry': expiry_time.isoformat()
             }
-            
+
             # Update cached config and save
             global _cached_config
             if _cached_config is not None:
@@ -688,15 +688,15 @@ def exchange_authorization_code(authorization_code: str) -> Optional[dict[str, A
             else:
                 clear_config_cache()  # Force reload on next access
             save_token_to_file(new_token)
-            
+
             print("✅ Initial tokens obtained successfully!")
             return new_token
-            
+
         else:
             print(f"❌ Token exchange failed: {response.status_code}")
             print(f"Response: {response.text}")
             return None
-            
+
     except Exception as e:
         print(f"❌ Error exchanging authorization code: {e}")
         return None
@@ -709,7 +709,7 @@ def setup_oauth_authentication():
     """
     print("🔧 Setting up OneDrive OAuth Authentication")
     print("=" * 50)
-    
+
     if CLIENT_ID == "your_client_id_here":
         print("❌ You need to set up Azure App Registration first!")
         print("\n📋 Setup Instructions:")
@@ -725,21 +725,21 @@ def setup_oauth_authentication():
         print("   export ONEDRIVE_CLIENT_ID='your_client_id'")
         print("   export ONEDRIVE_REDIRECT_URI='http://localhost:8080/callback'")
         return
-    
+
     print(f"Using Client ID: {CLIENT_ID}")
     print(f"Redirect URI: {REDIRECT_URI}")
-    
+
     # Generate authorization URL
     auth_url = get_authorization_url()
     print("\n🌐 Please visit this URL to authorize the application:")
     print(f"{auth_url}")
-    
+
     print("\n📋 After authorization, you'll be redirected to:")
     print(f"{REDIRECT_URI}?code=AUTHORIZATION_CODE&state=onedrive_auth")
     print("\n🔑 Copy the 'code' parameter from the URL and paste it below:")
-    
+
     auth_code = input("Authorization Code: ").strip()
-    
+
     if auth_code:
         token_data = exchange_authorization_code(auth_code)
         if token_data:
@@ -755,18 +755,18 @@ def setup_oauth_authentication():
 if __name__ == "__main__":
     # Try to load existing token from file
     load_token_from_file()
-    
+
     print("OneDrive transaction functions loaded.")
     try:
         config = get_config()
         print(f"Drive ID: {get_drive_id()}")
         print(f"Drive Type: {get_drive_type()}")
-        
+
         if is_token_valid():
             print("✅ Token is valid and ready to use")
         else:
             print("⚠️  Token has expired or is invalid")
-            
+
             # Try to refresh automatically
             if refresh_access_token():
                 print("✅ Token refreshed successfully")
@@ -778,7 +778,7 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error loading rclone config: {e}")
         print("Please ensure rclone is configured with an 'odp' section")
-    
+
     print("\n📚 Available Functions:")
     print("• push_to_onedrive(local_path, remote_path)")
     print("• pull_from_onedrive(remote_path, local_path)")
@@ -786,11 +786,11 @@ if __name__ == "__main__":
     print("• setup_oauth_authentication() - First-time OAuth setup")
     print("• save_token_to_file(token_data) - Save tokens for persistence")
     print("• load_token_from_file() - Load saved tokens")
-    
+
     print("\n💡 Example usage:")
     print("push_to_onedrive('/home/user/document.pdf', '/Documents/document.pdf')")
     print("pull_from_onedrive('/Documents/document.pdf', '/home/user/downloaded.pdf')")
-    
+
     # Uncomment to test with a file
     # push_to_onedrive('/home/alex/Downloads/users.xlsx', '/Documents/users.xlsx')