saleguas / context_menu Goto Github PK

Hi, i am trying to add the context menu functionality to a simple script i wrote but i can't get the example script to generate the menu. When i try to run it it doesn't get me any errors.

I have a menu, and I only want to show one item for a specific filetype etc. but i can't because ^

Hi,

I had a hard time with the provided examples on Windows 11, because in the Quickstart you say:

It's super easy! You can create entries in as little as 3 lines:

from context_menu import menus

fc = menus.FastCommand('Example Fast Command 1', type='FILES', command='echo Hello')
fc.compile()

With a screenshot of the menu on Windows.

However I don't know if that's a difference with older Windows, or because you wanted the examples to look crossplatform, or concises, but for me the FastCommand with echo hello doesn't work. In fact it has to be cmd /c echo hello.

Actually I test it with pause so that if there's a command prompt it doesn't disappear right away. With pause, Windows opens me a menu to choose how to open the file because the FastCommand doesn't work. With cmd /c pause, the FastCommand works correctly and the command prompt opens.

Not saying that you should change the examples to include cmd /c, but right now the README makes it look like echo hello should work, and I spent many time trying to find why it didn't work for me 😅 . So the README should mention somewhere that if you want to do echo hello, the command actually has to be cmd /c echo hello on Windows

Hello,
I just discovered your library and I already find it very very practical. I have a program which can already load files through a pop-up (PyQt5's QFileDialog) and would like to add the option to load them via context menu too.

My question is: can the function's signature be more flexible?
As of now, it seems that only f(filenames, params) and f(filenames=None, params=None) are supported. f(**kwargs) would be very handy as we could still recover the filenames and params while allowing extra parameters, and f(self, ...) would be amazing too for when your target function is actually a method.

I have prepared test cases for you.
The code below will add four context menu actions for files. Only actions 1 and 2 actually work, while 3 and 4 (the kwargs and class variants) don't. Uncomment the code in the context manager and run the code again to remove those context menu actions.

Thank you in advance!

from contextlib import contextmanager

@contextmanager
def add_context_menu_action(action_name, function):
    """Add a context menu action only for the duration of the encompassed scope.

       args:
       -----
       :action_name: (str) the label of the action button.
       :function: the function to call on action button click. Because of the
                  context-menu library requirements, this function must have
                  a `function(filenames, params)` signature. No *args or **kwargs.

       See also:
       -----
       https://github.com/saleguas/context_menu
       https://pypi.org/project/context-menu/"""

    # Creates a direct context menu entry.
    kwargs = dict(name=action_name, type="FILES")
    fc = menus.FastCommand(**kwargs, python=function)
    fc.compile()
#    yield
#    try:
#        menus.removeMenu(**kwargs)
#    except FileNotFoundError: # Prevents an error if the function could not be located.
#        pass



def _TEST1(filenames, params):

    with open("ZE_TEST 1.txt", "w") as file:
        file.write(f"filenames: {filenames}\n")
        file.write(f"params: {params}\n")
        file.write("*"*15)



def _TEST2(filenames=None, params=None):

    with open("ZE_TEST 2.txt", "w") as file:
        file.write(f"filenames: {filenames}\n")
        file.write(f"params: {params}\n")
        file.write("*"*15)



def _TEST3(**kwargs):

    filenames, params = (kwargs[key] for key in ("filenames", "params"))
    with open("ZE_TEST 3.txt", "w") as file:
        file.write(f"filenames: {filenames}\n")
        file.write(f"params: {params}\n")
        file.write("*"*15)



class MethodTester:

    def __init__(self):
        pass

    def _TEST4(self, filenames, params):
        with open("ZE_TEST 4.txt", "w") as file:
            file.write(f"filenames: {filenames}\n")
            file.write(f"params: {params}\n")
            file.write("*"*15)



if __name__ == "__main__":

    x = MethodTester()
    for n in (1, 2, 3, 4):
        name = f"ZE_TEST FastCommand {n}"
        function = {1: _TEST1,
                    2: _TEST2,
                    3: _TEST3,
                    4: x._TEST4}[n]
        with add_context_menu_action(name, function):
            pass

If i'm not wrong as of v0.1.20 registry keys should be added to HKEY_CURRENT_USER\Software\Classes. However my code (shown below) added the key to HKEY_CLASSES_ROOT.

def command(*args, **kwargs):
    print(args)
    print(kwargs)
    input()


if __name__ == '__main__':
    from context_menu import menus

    menus.FastCommand('test', type='FILES', python=command).compile()

As a side-effect, remove menu says that key doesnt exist

These directories should be excluded from git: __pycache__

The script does not escape file paths with quotes, so it does not work properly if there are problems in the file path

cm = menus.ContextMenu("Converter", type=".mp4")
cm.add_items(
    [menus.ContextCommand("to mp3", "C:/ProgramData/chocolatey/bin/ffmpeg.exe -i ? test.mp3", command_vars=['FILENAME'])]
)
cm.compile()

For file path: "C:\Users\saala\Videos\Base Profile\test123.mp4"

Execute script: C:/ProgramData/chocolatey/bin/ffmpeg.exe -i C:\Users\saala\Videos\Base Profile\test123.mp4 test.mp3
^ this dont work correctly

Is there any option where context menu would be only visible for a particular path or drive in linux?

Thank you.

I'm testing this script and so far, it seems a nice way to play with custom context menus. However, I'm having trouble getting files to open if they have spaces in the name.

Example with notepad (Foo Two):

if __name__ == '__main__':
    from context_menu import menus

    cm = menus.ContextMenu('Foo menu', type='FILES')
    cm.add_items([
        menus.ContextCommand('Foo One', command='cmd /K echo ?', command_vars=['FILENAME']),
        menus.ContextCommand('Foo Two', command='notepad ?', command_vars=['FILENAME']),
        menus.ContextCommand('Foo Three', python=foo3)
        ])
    cm.compile()

If the file is called d:\1.jpg everything works as expected (It should not looking below), if however, the file is d:\cute kittens.jpg it fails with a file not found error:

If I use Foo One I get an echo but it shows a trailing " at the end of the filename:

Due to how Windows handles context menu preference, if a file type has a default program set, context menus from this package will not show properly.

The issue is that defining individual file extensions starting from the Software\\Classes\\{EXTENSION} registry path allows them to be overridden. Instead, if the file extensions are defined at the registry path Software\\Classes\\SystemFileAssociations\\, Windows will put them in the menu at a lower priority than the default program.

See the Windows Documentation or this Stack Overflow question.

If I can get some time this weekend, I'll try to put up a PR with a fix.

In RegistryMenu, the type parameter can't be None, because there is type.upper():

class RegistryMenu:
    '''
    Class to convert the general menu from menus.py to a Windows-specific menu.
    '''
    def __init__(self, name: str, sub_items: list, type: str):
        '''
        Handled automatically by menus.py, but requires a name, all the sub items, and a type
        '''
        self.name = name
        self.sub_items = sub_items
        self.type = type.upper()
        self.path = context_registry_format(type)

However in ContextMenu, and in provided examples, it looks like the parameter type should be optional:

class ContextMenu:
    '''
    The general menu class. This class generalizes the menus and eventually passes the correct values to the platform-specifically menus.
    '''

    def __init__(self, name: str, type: str = None):
        '''
        Only specify type if it's the root menu.
        '''

        self.name = name
        self.sub_items = []
        self.type = type

It seems there is the same issue for NautilusMenu where type is passed to CodeBuilder where there is type.upper().

Is it that the correct fix would be to make the parameter type mandatory in ContextMenu ?

Windows

• adds an empty string value named Extended for key created

More on stackoverflow post

Linux

Not aware of the existance of the feature

Hello, I am trying create fast command but it seems not working. Did someone tried create context menus on VM?

My configuration:
HOST: Windows 7 64bit
GUEST: Ubuntu 20.04 64bit
Running on Virtual Box 6.1

Thank's for any help.

It would be wonderful to have commandline to remove context menus

It would be great to have macOS support without having to use Automator or Service Station. Unfortunately I have no clue on how to help but I'll do some research!

Hi, I tested this library on Windows 11 with Python 3.9 and couldn't get it to work at all.

There is no error, however the calls to winreg.CreateKey don't create anything.
It's only when I found this thread https://stackoverflow.com/questions/65929777/python-winreg-unable-to-write-to-hkey-current-user that I tried the exact same code with Python 3.8, and it worked perfectly fine.

I see you had users mentioning this problem in the issue #13 that have been closed, and while it may not be something to fix in your library, but a bug in Python, I'm opening this issue for further reference

For example:

• File type
• Location

It would be great to have examples for the directory and directory-background menus. For the directory menu, one would assume that the directory parameter would be a single string -- not a list. This can be inferred from the fact that parameters past in are not a list but a string delineated by spaces.

Ended up opening an error file with the generated exception to figure out why the code was breaking. :(

I am happy to supply my working code as an example.

The current, hard limit for how many items can be in a submenu is 16.
Could it be possible to change this somehow?

See title, for reference in how this could be done see here
Thanks for the awesome library by the way!

PD: I've noticed a limitation with the way the shell context works on Windows, since if the path to the selected destination is sufficiently long, it will just ignore the rest of the command, I don't know if this is my own wrongdoing or a limitation with the way Windows runs commands.

Windows 11 have currently 2 context menus and it would be nice if this library would support the new context menu

It would be great to have an option to call a single function while multiple files are selected (and passing a list of all file names in it) instead of calling a function once per every file... Win10 if it matters...

Hello I'm having an issue getting the context menu to be displayed in my environment.
my setup is as follows:
python3 -m pip install context_menu which successfully installs.
attempting to use the quick start given code:

fc = menus.FastCommand('Example Fast Command 1', type='FILES', command='echo Hello')
fc.compile()

Running my script python3 sample.py
running the nautilus command nautilus -q
and my file explorer closes and i reopen it and head over to a text file, I've tried other files but I'm attempting to mimic the video on the read-me to hopefully solve the issue. but I'm still having no luck, with the context menu being displayed.

ive tried to reinstall Python3, context_menu, nautilus, along with trying both of the given example scripts.

versions of stuff I'm using:

nautilus: GNOME nautilus 3.36.3
System: Ubuntu 20.04.4 LTS 64bit
GNOME: 3.36.8
Windowing system: X11
python 2.7.18 && 3.8

I'm 100% doing something incorrect on my end and not an expert when it comes to Ubuntu so apologies in advance and thank you for any clarity on my issue.

This does not work whatsoever on Windows 10: straight from the examples:

fc = menus.FastCommand('Weird Copy', type='.txt', command='touch ?x',
                       command_vars=['FILENAME'])  # opens only on .txt files
fc.compile()

It doesn't add a context menu item at all.

For lists of things ideally you want to be able to pass parameters into python functions

So, I absolutely love this project, but I have one problem: While I can pass the filename[s] to a Python function, I can't pass them to the command option. For normal Python code this isn't a big problem; however, compiling code with PyInstaller makes the python option unusable.

With that in mind, I would like it if you could add the ability to do something like this:

foo = menus.FastCommand('Foobar', type='FILES', command="foo ? ?", command_vars = ["FILENAME", "DIR"]

where command_vars is an iterable specifying the context menu-related variables (e.g. the filename or the current working directory) with which to replace the ?s in command.