5 Best Ways to Access Files of a Device in the Same Network Using Python

by

💡 Problem Formulation: In networked environments, it’s common to require access to files on different devices without manual transfer. For example, a script on your computer (the client) may need to open, read, or write files on a server. This article solves the problem of accessing these files using Python, detailing methods that work with a range of protocols and security levels.

Method 1: Using the built-in open() function with mounted drives

Python’s standard open() function can access files on network shares that are mounted as local drives. This approach is best suited for networks where shared folders are already configured and accessible as drive letters or mounted volumes.

Here’s an example:

file_path = 'Z:/shared_folder/example.txt'
with open(file_path, 'r') as file:
    content = file.read()
print(content)

As a result, you would see the content of ‘example.txt’ printed out, assuming ‘Z:/shared_folder/’ is correctly mounted.

This technique is straightforward, relying on the operating system’s ability to mount network drives. It means your Python script can work with networked files as if they were local.

Method 2: Using socket for custom networking

The socket library can be used for low-level network communication. This is useful when you need full control over the networking process, potentially implementing custom protocols or working with raw data.

Here’s an example:

import socket

s = socket.socket()
host = '192.168.1.5'  # Server IP
port = 12345          # Server Port
s.connect((host, port))

# Request a file
s.send(b'GET example.txt')
data = s.recv(1024)
print(data.decode())

s.close()

The output would be the contents of ‘example.txt’ received from the server, or an error if the file is not found.

This method requires a deeper understanding of network protocols and is better suited for custom networking needs.

Method 3: Utilizing paramiko for SFTP

The paramiko library is a Python implementation of SSHv2, providing an easy-to-use interface for SFTP (SSH File Transfer Protocol). This is a secure method for transferring files between devices on the same network.

Here’s an example:

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.5', username='user', password='password')
sftp = ssh.open_sftp()
remote_file = sftp.file('example.txt', 'r')
print(remote_file.read().decode())
sftp.close()
ssh.close()

This code would output the contents of ‘example.txt’ from the remote server at the IP address ‘192.168.1.5’.

paramiko provides a secure and programmatic way to access files over a network, bypassing the need to mount network drives or write custom network protocols.

Method 4: Accessing SMB/CIFS resources with smbprotocol

To work with Windows shares (SMB/CIFS), you can use the smbprotocol library to list shares, read, and write files on a network. This can be useful in environments with Windows network file sharing.

Here’s an example:

from smbprotocol.connection import Connection, Dialects
from smbprotocol.session import Session
from smbprotocol.tree import TreeConnect
from smbprotocol.file import CreateDisposition, FileAttributes, Files

connection = Connection(uuid.uuid4(), '192.168.1.5', 445)
connection.connect(Dialects.SMB_3_0_2)
session = Session(connection, 'user', 'password')
session.connect()
tree = TreeConnect(session, r'\\192.168.1.5\share')
tree.connect()
files = Files(tree, 'example.txt')
files.open(CreateDisposition.FILE_OPEN, FileAttributes.FILE_ATTRIBUTE_NORMAL)
file_contents = files.read()
files.close()

The output will be the content of ‘example.txt’ from the specified SMB share.

This method provides Python-native access to SMB shares for reading and writing files across devices on a network.

Bonus One-Liner Method 5: Simple HTTP Server

If you’re looking for a quick and dirty way to serve files over a network using Python, you may consider Python’s built-in HTTP server in the http module (Python 3+).

Here’s an example:

python -m http.server 8000

This command serves the current directory’s files at http://your_ip:8000, which you can access from any device on the network.

This method is simplistic and lacks security features, but it’s great for quickly sharing files over a LAN without writing any code.

Summary/Discussion

  • Method 1: Using open(). Ideal for simple access to mounted network drives. Not suitable for non-mounted resources or across different operating systems.
  • Method 2: Using socket. Offers full control over network communication, good for custom protocols. Not suitable for less experienced programmers due to complexity.
  • Method 3: Utilizing paramiko for SFTP. Secure way to access files, great for accessing Linux-based devices. Requires additional setup for SSH server and keys management.
  • Method 4: Accessing SMB/CIFS with smbprotocol. Python-native method specifically for Windows shares. May require additional library installation and setup.
  • Bonus One-Liner Method 5: Simple HTTP Server. Quick and easy way to temporarily share files, but insecure and not meant for persistent use.