ImplicitMount

class pyremotedata.implicit_mount.ImplicitMount(user: str | None = None, password: str | None = None, remote: str | None = None, port: int = 2222, verbose: bool = False)[source]

Bases: object

This is a low-level wrapper of LFTP, which provides a pythonic interface for executing LFTP commands and reading the output. It provides a robust and efficient backend for communicating with a remote storage server using the SFTP protocol, using a persistent LFTP shell handled in the background by a subprocess. It is designed to be used as a base class for higher-level wrappers, such as the IOHandler class, or as a standalone class for users familiar with LFTP.

OBS: The attributes of this method should not be used unless for development or advanced use cases, all responsibility in this case is on the user.

Parameters:
  • user (Optional[str]) – The username to use for connecting to the remote directory.

  • password (Optional[str]) – The SFTP password to possibly use when connecting to the remote host.

  • remote (Optional[str]) – The remote server to connect to.

  • port (int) – The port to connect to (default: 2222).

  • verbose (bool) – If True, print the commands executed by the class.

execute_command(command: str, output: bool = True, blocking: bool = True, execute: bool = True, default_args: dict | None = None, **kwargs) str | List[str] | None[source]

Executes a command on the LFTP shell.

Parameters:
  • command (str) – The command to execute.

  • output (bool) – If True, the function will return the output of the command.

  • blocking (bool) – If True, the function will block until the command is complete. If output is True, blocking must also be True.

  • execute (bool) – If True, the function will execute the command, otherwise it will return the command as a string.

  • default_args (Union[dict, None]) – A dictionary of default arguments to use for the command. If None, no default arguments will be used.

  • **kwargs – Keyword arguments to pass to the command.

Returns:

If execute is False, the function will return the command as a string. If output is True, returns a string, list or None depending of the number of output lines, otherwise returns None.

Return type:

Union[str, List[str], None]

static format_options(**kwargs) str[source]

Takes a dictionary of options and formats them into a string of command line arguments suitable for LFTP.

Parameters:

**kwargs – Keyword arguments to format.

Returns:

The formatted arguments.

Return type:

str

lcd(local_path: str) str[source]

Changes the current local directory using the LFTP command lcd.

Parameters:

local_path (str) – The local directory to change to.

lls(local_path: str, **kwargs) List[str][source]

Find all files in the given local directory using the LFTP command !ls or !find.

OBS: This function should probably not be used, just use the standard OS commands instead.

lpwd() str[source]

Get the current local directory using the LFTP command lpwd.

Returns:

The current local directory.

Return type:

str

ls(path: str = '.', recursive: bool = False, use_cache: bool = True, pbar: int = 0, top: bool = True) List[str][source]

Find all files in the given remote directory using the LFTP command cls. Can be used recursively, even though LFTP does not support recursive listing with the cls command.

Parameters:
  • path (str) – The remote directory to search in.

  • recursive (bool) – If True, the function will search recursively.

  • use_cache (bool) – If True, the function will use cls, otherwise it will use recls. recls forces a refresh of the cache.

  • pbar (int) – If 1, prints something to show that the process is not dead, only relevant if recursive is True. Defaults to 0.

  • top (bool) – DO NOT USE! Flag to indicate whether the recursion is at the top level.

Returns:

If the directory is empty, the function will return None, if the directory contains one file, the function will return a string, otherwise it will return a list of strings.

Return type:

Union[None, str, List[str]]

mirror(remote_path: str, local_destination: str, blocking: bool = True, execute: bool = True, do_return: bool = True, **kwargs) List[str] | None[source]

Download a directory from the remote directory to the given local destination using the LFTP mirror command.

Parameters:
  • remote_path (str) – The remote directory to download.

  • local_destination (str) – The local destination to download the directory to.

  • blocking (bool) – If True, the function will block until the download is complete.

  • execute (bool) – If True, the function will execute the mirror command, otherwise it will return the command as a string.

  • do_return (bool) – If True, the function will return a list of the newly downloaded files.

  • **kwargs – Keyword arguments to pass to the mirror command.

Returns:

If do_return is True, the function will return a list of the newly downloaded files, otherwise it will return None.

Return type:

Union[None, List[str]]

mount(lftp_settings: dict | None = None) None[source]

Mount the remote directory.

Parameters:

lftp_settings (Union[dict, None]) – A dictionary of LFTP settings to use for mounting the remote directory. If None, the default settings will be used.

Raises:
  • Exception – If the subprocess fails to start.

  • RuntimeError – If the connection to the remote directory fails.

pget(remote_path: str, local_destination: str, blocking: bool = True, execute: bool = True, output: bool | None = None, **kwargs)[source]

Download a single file from the remote directory using the LFTP command pget.

Parameters:
  • remote_path (str) – The remote file to download.

  • local_destination (str) – The local destination to download the file to.

  • blocking (bool) – If True, the function will block until the download is complete.

  • execute (bool) – If True, the function will execute the pget command, otherwise it will return the command as a string.

  • output (Union[bool, None]) – If True, the function will return the absolute local path of the downloaded file, otherwise it will return None.

Returns:

If output is True, the function will return the absolute local path of the downloaded file, otherwise it will return None.

Return type:

Union[None, str]

put(local_path: str, remote_destination: str | None = None, blocking: bool = True, execute: bool = True, output: bool | None = None, **kwargs)[source]

Upload a single file to the remote directory using the LFTP command put.

TODO: Is it really just a single file?

Parameters:
  • local_path (str) – The local file to upload.

  • remote_destination (str, optional) – The remote destination to upload the file to. If None, the file will be uploaded to the current remote directory.

  • blocking (bool) – If True, the function will block until the upload is complete.

  • execute (bool) – If True, the function will execute the put command, otherwise it will return the command as a string.

  • output (Union[bool, None]) – If True, the function will return the absolute remote path of the uploaded file, otherwise it will return None.

  • **kwargs – Keyword arguments to pass to the put command.

pwd() str[source]

Get the current remote directory using the LFTP command pwd.

Returns:

The current remote directory.

Return type:

str

unmount(timeout: float = 1) None[source]

Unmount the remote directory.

Parameters:

timeout (float) – The maximum time to wait for the lftp shell to terminate. If the timeout is exceeded, the lftp shell will be forcefully terminated.