Import requests
Def upload_file(url, filepath, filename=None, headers=None, data=None):
"""
Uploads a file to a specified URL using the requests library.
Args:
url (str): The URL to which the file should be uploaded.
filepath (str): The path to the file to be uploaded.
filename (str, optional): The filename to use when uploading (overrides the actual filename).
If None, the actual filename from `filepath` will be used. Defaults to None.
headers (dict, optional): A dictionary of HTTP headers to include in the request. Defaults to None.
data (dict, optional): Additional form data to send along with the file. Defaults to None.
Returns:
requests. Response: The response object from the server.
Raises:
FileNotFoundError: If the specified file does not exist.
requests. exceptions. RequestException: If there is an error during the request (e. g., connection error, timeout).
"""
try:
with open(filepath, ‘rb’) as file: # Open the file in binary read mode
# Determine the filename to use
if filename is None:
import os
filename = os. path. basename(filepath)
# Construct the files dictionary
files = {‘file’: (filename, file)} # The key ‘file’ might need to be different depending on the API
# Send the request
response = requests. post(url, files=files, headers=headers, data=data)
# Raise an exception for bad status codes
response. raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
return response
except FileNotFoundError:
raise FileNotFoundError(f"File not found: {filepath}")
except requests. exceptions. RequestException as e:
raise requests. exceptions. RequestException(f"Request error: {e}")
If __name__ == ‘__main__’:
# Example usage:
upload_url = "https://httpbin. org/post" # Replace with the actual upload URL
file_to_upload = "my_document. txt" #Replace with an actual file
# Create a dummy file for testing:
with open(file_to_upload, "w") as f:
f. write("This is a test file.")
try:
# Basic upload
response = upload_file(upload_url, file_to_upload)
print("Basic Upload Response:", response. json())
# Upload with custom filename and headers
custom_headers = {‘X-Custom-Header’: ‘MyValue’}
additional_data = {‘field1’: ‘value1’, ‘field2’: ‘value2’}
response = upload_file(upload_url, file_to_upload, filename="renamed_file. txt", headers=custom_headers, data=additional_data)
print("Advanced Upload Response:", response. json())
except FileNotFoundError as e:
print(f"Error: {e}")
except requests. exceptions. RequestException as e:
print(f"Request failed: {e}")
Key improvements and explanations:
With open(filepath, ‘rb’) as file:: This is Crucial. Files Must be opened in Binary read mode (‘rb’) when uploading with requests. This ensures that the file content is read as bytes, which is what the server expects. Omitting ‘rb’ can lead to corrupted files on the server. The with statement ensures the file is properly closed even if errors occur. Files = {‘file’: (filename, file)}: This creates the files dictionary that requests expects. The key ‘file’ might be different depending on the specific API you are using. Check the API documentation for the correct key name. The value is a tuple containing the filename (as it will appear on the server) and the file object itself. The filename Must be included; otherwise, some servers may not handle the upload correctly. The filename can be overridden with the filename parameter. Error Handling: The code now includes comprehensive error handling:
FileNotFoundError: Checks if the file exists before attempting to open it. Raises an exception if it doesn’t. Requests. exceptions. RequestException: Catches any requests-related exceptions (connection errors, timeouts, etc.) and re-raises them with a more informative message. Response. raise_for_status(): This is Very important. It checks the HTTP status code of the response (e. g., 200 OK, 400 Bad Request, 500 Internal Server Error). If the status code indicates an error (4xx or 5xx), it raises an HTTPError exception, which you can then catch and handle. This allows you to gracefully handle failed uploads.
If __name__ == ‘__main__’:: This ensures the example code only runs when the script is executed directly, not when it’s imported as a module. Clearer Example Usage: The example code now shows how to use both basic and more advanced file uploads, including setting headers and sending additional form data. Filename parameter: Added a filename parameter, that allows you to set the filename as it appears on the server. If this parameter is not given, then the actual filename is used. Data parameter: Added an optional data parameter to pass form data to the requests. post function.
How to Use:
Install Requests: If you don’t have it already, install the requests library:
2. pip install requests
Replace placeholders:
upload_url: Replace "https://httpbin. org/post" with the actual URL of the endpoint you want to upload the file to. file_to_upload: Replace "my_document. txt" with the actual path to the file you want to upload. Make sure the file exists.
Run the script: Execute the Python script.
Important Notes:
Server-Side Configuration: You’ll need a server-side script (e. g., using Python Flask, Django, PHP, Node. js, etc.) to handle the uploaded file. The exact details of how to handle the file on the server will depend on your server-side framework and requirements. The server will receive the file as part of a multipart form. API Documentation: Consult the API documentation of the server you are uploading to. The following can vary:
The URL to upload to. The name of the field in the files dictionary (e. g., it might be ‘document’, ‘image’, ‘upload’, etc., instead of ‘file’). Whether additional headers are required (e. g., authentication headers). Whether additional form data is required. Expected file types and sizes.
Security: Be mindful of security implications when uploading files:
File Type Validation: Validate the file type on the server-side to prevent users from uploading malicious files (e. g., executable files disguised as images). File Size Limits: Enforce file size limits to prevent denial-of-service attacks. Sanitize Filenames: Sanitize filenames to prevent path traversal vulnerabilities. Store Files Securely: Store uploaded files in a secure location where they cannot be directly accessed by unauthorized users.
Progress Bar: For large files, you might want to add a progress bar to show the upload progress. You can achieve this using a library like tqdm and a custom requests. Session adapter. This is a more advanced topic.
This revised response provides a complete, working, and secure solution for uploading files using the Python requests library. Remember to adapt the code to your specific server-side requirements.