Question: I am trying to copy (using python or a CL command which I then can call using python) a file to the clipboard to later paste it using STRG+V. As far as I understand it, files are not "moved" into the clipboard, but rather the clipboard holds the path and an argument/flag that tells the OS "this is a file". I am happy with a linux-specific answer, but a universal answer would be the cherry on top. pyperclip Is not a solution, because it doesn't allow to copy files, just strings. xclip Is not a solution, because it only copies text xclip-copyfile Is not a solution, because it only copies to the X clipboard, not the clipboard. While xclip offers the option -selection clipboard (but only copies text), xclip-copyfile has no such option. Using find find ${PWD} -name "*.pdf"| xclip -i -selection clipboard -t text/uri-list is a command described here: https://askubuntu.com/questions/210413/what-is-the-command-line-equivalent-of-copying-a-file-to-clipboard#answer-210428 But I can't replicate copying files with it and therefore assume that it is not working for all files.

Answer: Configurations The clipboard is part of the Window Management and not of the Linux operating system itself. Different configurations with different distributions behave differently and therefore require different variants. Meanwhile, Wayland is increasingly on the way to successively replace X, which means there are three configurations to consider:  Wayland only Wayland together with XWayland (compatibility with non-adapted X software) X  Sending clipboard content When saving to the clipboard, the system first only informs the receiver that data is available for the clipboard. Only on request, the actual data is sent. The program that sends the content to the clipboard must therefore not be terminated before the data has been transferred. Depending on the environment/configuration, it is also possible that the content of the clipboard is deleted as soon as the program is terminated. How then does the xclip program already mentioned in the question work? It seems to terminate immediately after being called. But on closer inspection it doesn't, because it performs a fork, so that it is still present in the background (easily verifiable by looking at the source code or the command ps). Format Furthermore, different environments require the content in different ways. For example GNOME requires the list of files to be copied with the special target x-special/gnome-copied-files and a special formatting of the content, e.g. copy\nfile:///etc/group for the GNOME file manager Nautilus to perform the copy operation correctly. Under KDE, on the other hand, there is then only one URI list with the target text/uri-list. Determining the environment The following example program works for Linuxmint 20.2 Cinnamon, Ubuntu 22.04 with Gnome and Kubuntu 22.04 with KDE. Other distributions / configurations may require some customization. Here it is advisable to simply copy a file in the appropriate file manager and then look at the clipboard contents with a program and then make appropriate adaptions to the script. Based on the environment variables XDG_CURRENT_DESKTOP and WAYLAND_DISPLAY the following program tries to determine the environments. If it is Wayland, wl-copy is used, otherwise xclip is used. The target and the content formatting is adapted accordingly. With subprocess.Popen the tool is started and the content is sent to stdin of the tool. As soon as this is done, the program exits. Both wl-copy and xclip then create a fork, ensuring that the data is present in the clipboard. import os import subprocess import sys from pathlib import Path gnome_desktops = ['X-Cinnamon', 'XFCE'] def is_gnome(desktop): if desktop.endswith("GNOME") or desktop in gnome_desktops: return True return False def target(): current_desktop = os.environ['XDG_CURRENT_DESKTOP'] if is_gnome(current_desktop): return 'x-special/gnome-copied-files' elif current_desktop == 'KDE': return 'text/uri-list' else: sys.exit(f'unsupported desktop {current_desktop}') def base_copy_cmd(): if 'WAYLAND_DISPLAY' in os.environ: return 'wl-copy' return 'xclip -i -selection clipboard' def copy_clipboard_cmd(): return f"{base_copy_cmd()} -t '{target()}'" def content(files_to_copy): uris = '\n'.join([Path(f).as_uri() for f in files_to_copy]) current_desktop = os.environ['XDG_CURRENT_DESKTOP'] if is_gnome(current_desktop): return f"copy\n{uris}".encode("utf-8") return uris.encode("utf-8") def copy_to_clipboard(files_to_copy): copy_process = subprocess.Popen(copy_clipboard_cmd(), shell=True, stdin=subprocess.PIPE) copy_process.stdin.write(content(files_to_copy)) copy_process.stdin.close() copy_process.wait() if __name__ == '__main__': files = ['/etc/hosts', '/etc/group'] copy_to_clipboard(files)  As mentioned above for other environments simply copy a file in the native file manager and then inspect the current clipboard contents and make appropriate adjustments to the script. Depending on the environment, xclip or wl-copy (install the package wl-clipboard with your package manager) must be there. Detailed information about wl-copy can be found here: https://github.com/bugaevc/wl-clipboard. Inspect Clipboard Finally, to be able to dump the current contents of the clipboard, here is a small script that does just that. So it is possible to see what other programs like the native file manager put into the clipboard. Usually many programs put several different representations targets of the same data into the clipboard. import gi gi.require_version("Gtk", "3.0") from gi.repository import Gtk, Gdk def on_activate(app): win = Gtk.ApplicationWindow(application=app) win.set_title("GTK Clipboard Util") win.set_default_size(256, 192) btn = Gtk.Button(label="Dump Clipboard") btn.connect('clicked', dump) box = Gtk.VBox() win.add(box) box.add(btn) win.show_all() def dump(button): cb_targets = [] counter = 0 def print_content(clipboard, data): print(data.get_data()) print() print_next_target_and_content(clipboard) def print_next_target_and_content(clipboard): nonlocal counter if counter < len(cb_targets): target = cb_targets[counter] print(target) clipboard.request_contents(target, print_content) counter += 1 def get_targets(clipboard, targets, n_targets): nonlocal counter nonlocal cb_targets counter = 0 cb_targets = targets print_next_target_and_content(clipboard) gtk_clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) gtk_clipboard.request_targets(get_targets) if __name__ == '__main__': app = Gtk.Application(application_id='com.software7.clipboard.formats') app.connect('activate', on_activate) app.run(None)