semvec/pypi-packages huggingface dataset:
gnome-hud 1.4.1
Unity like HUD menu for the GNOME Desktop Environment

# Gnome HUD
Unity like HUD menu for the GNOME Desktop Environment.

### Screenshots
HUD menu running with the default menu handler (GTK3).

![Screenshot](/screenshot.png)

HUD menu running with the [Rofi](https://github.com/DaveDavenport/rofi) menu handler.

![Settings](/screenshot-rofi.png)

## Dependencies
```
gtk3 bamf linkeybinder3 python python-gobject python-dbus
```

## Installation
Install the package with the Python Package Index using `pip` command.
```
pip install gnome-hud
```

### Post installation
After the package installation, follow the instructions below:

- Install bamf daemon (It is strongly recommend to add bamf daemon to autostart)
- Install GTK module using instructions below
- To get QT menus to work, install your distribution's qt4 and qt5 appmenu packages

**UBUNTU**

* Install [unity-gtk-module](https://launchpad.net/unity-gtk-module) with `sudo apt-get install unity-gtk2-module unity-gtk3-module`
* Follow instructions in [appmenu-gtk-module](https://github.com/rilian-la-te/vala-panel-appmenu/blob/master/subprojects/appmenu-gtk-module/README.md), but replace any occurence of `appmenu-gtk-module` to `unity-gtk-module`

**ARCH LINUX**

* Install [appmenu-gtk-module](https://www.archlinux.org/packages/community/x86_64/appmenu-gtk-module) for GTK appmenu support
* Install [appmenu-qt4](https://www.archlinux.org/packages/community/x86_64/appmenu-qt4) for Qt4 appmenu support
* Install [libdbusmenu-gtk2](https://www.archlinux.org/packages/community/x86_64/libdbusmenu-gtk2) and [libdbusmenu-gtk3](https://www.archlinux.org/packages/community/x86_64/libdbusmenu-gtk3) for GTK2 and GTK3 dbusmenu support
* Install [libdbusmenu-qt4](https://www.archlinux.org/packages/extra/x86_64/libdbusmenu-qt4) and [libdbusmenu-qt5](https://www.archlinux.org/packages/extra/x86_64/libdbusmenu-qt5) for Qt4 and Qt5 dbusmenu support

*The post installation instructions above are adapted from [Vala Panel Application Menu](https://github.com/rilian-la-te/vala-panel-appmenu).*

### Packages
Arch Linux: [AUR package](https://aur.archlinux.org/packages/gnome-hud)

## Usage
After the installation is completed, you will have 3 executables and a gnomehud.desktop file available.

* Open the GTK3 menu dialog with `gnomehud`
* Open the Rofi menu dialog with `gnomehud-rofi`
* Start the AppMenu service with `gnomehud-service`

The desktop file launches `gnomehud-service` and can be used to add it to the startup applications in gnome-tweaks. The dialog commands can be used for custom keyboard shortcuts in keyboard settings.

When running the dialog commands from a terminal the keybinding is <kbd>Ctrl</kbd> + <kbd>Alt</kbd> + <kbd>Space</kbd>.

## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/hardpixel/gnome-hud.

## License
Gnome HUD is available as open source under the terms of the [GPLv3](http://www.gnu.org/licenses/gpl-3.0.en.html)
CapPy-Python 0.0.6
Python package for easy window capturing

# CapPy
A Pillow wrapper for easy window capturing and window data acquisition.

Examples:
```
import cappy as cpy
window = cpy.match_window('notepad.exe')
```
---
```
import cappy as cpy
window = cpy.match_window('mspaint.exe')
print(window.process, window.pid, window.tid, window.hwnd)
>mspaint.exe 9024 6024 1048826
```
---
```
import cappy as cpy
window = cpy.match_window('GTA5.exe')
while(window.alive):
    cpy.cv2_record(window)
cpy.cv2_dispose()
```
---
```
import cappy as cpy
windows_out = []
cpy.retrieve_windows(windows_out)
for window in windows_out:
    print(window.name)
>Calculator
>Untitled - Notepad
>#general - Discord
>Google - Mozilla Firefox
>Steam
>...
```
deep-filter 1.0.1
Removes values from nested dicts and lists
Requires Python: >=3.5,<4.0
Keywords: filter,remove,nested,recursively,delete,dicts,lists

# deep-filter
A simple package that filters out values from dicts/lists, including all dicts/lists nested within it.

## Usage
```python
from deep_filter import deep_filter
x = {
    'nope': 69,
    'yep': [
        69,
        {'maybe': None},
        99
    ]
}
def filter_func:
    return value != 69
result = deep_filter(x, filter_func)
print(result)
# {'yep': [{}, 99]}
```

### deep_filter(dict_or_list, filter_func=default_filter_func)
- **dict_or_list**: A dictionary or list
- **filter_func**: An optional callback function. It will take a value as an argument, and return `True` if the value will be kept and `False` if not. If omitted, `None` values will be filtered out.

Returns your dict or list, filtered.

## Dev instructions

### Get started

1. Install Python (Python 3.7 works, probably other versions too)
2. Install [Poetry](https://poetry.eustace.io). Poetry is used to manage dependencies, the virtual environment and publishing to PyPI
3. Run `poetry install` to install Python package dependencies

I recommend running `poetry config virtualenvs.in-project true`, which makes Poetry store your Python virtual environment inside the project folder. Additionally, it lets VSCode's Python extension detect the virtual environment if you set the `python.pythonPath` setting to `${workspaceFolder}/.venv/bin/python` in your settings.

### Running

To test if things work, you can run the following command to open the Python REPL. Then you can write Python, such as the usage examples:

```
poetry run python
```

### Releasing a new version

1. Consider updating the lockfile by running `poetry update`, then check if thing still work
2. Bump the version number:
    ```
    poetry version <version>
    ```
3. Update `CHANGELOG.md`
4. Build:
    ```
    poetry build
    ```
5. Commit and create git tag
6. Create GitHub release with release notes and attach the build files
7. Publish to PyPi:
    ```
    poetry publish
    ```
mlderes.dstoolkit 0.3.0.dev0
A library of tools that I use to manage files,clean datasets and do exploratory data analysis

[![Known Vulnerabilities](https://snyk.io/test/github/MLDERES/dstoolkit/badge.svg?targetFile=requirements.txt)](https://snyk.io/test/github/MLDERES/dstoolkit?targetFile=requirements.txt)

# DSToolkit - utilities for better analytics projects
A library of tools that I use to manage files, clean datasets and do exploratory data analysis

## Table of Contents
* [General info](#general-info)
* [Technologies](#technologies)
* [Usage](#usage)
* [Contributions](#contributions)
* [Todo](#todo)
* [License](#license)

## General Info
This library is a set of tools for managing files, cleaning data and doing exploratory data analysis.

This all started because I found myself creating lots and lots of versions of data files in various states of completeness.  I would scrape some data, write it a file (in the data/raw folder) then work on it some and save it to the data/processed folder.  After a few iterations, I couldn't remember if it was data/raw/scraped_page1.csv or data/raw/scraped_page101.csv that was the latest.  So I started to name the files with a timestamp appendage scraped_page_01011850.csv (for a file that was created on Jan 1 at 6:50pm).  So I needed a utility to create the timestamps and then get the lastest version of the file.  I copied this code so much that I decided to use it as a way to learn about creating real Python projects, GitHub hooks, Visual Studio Code, Docker Containers and more.

## Technologies
* Python 3.7
* [Pandas](https://pandas.pydata.org)

## Usage
`pip install -U mlderes.dstoolkit`

In your module:
``` 
from mlderes.dstoolkit import get_latest_data_filename, DataFolder, make_ts_filename, write_data

data_folder = DataFolder('./data') # root data folder
DATA_RAW = data_folder.RAW
DATA_EXTERNAL = data_folder/'external'

# Get the filename (path) of the file like foo* in the ./data/raw directory
fp = get_latest_data_filename(DATA_RAW, 'foo')
```

## Contributions
This project was developed using [Visual Studio Code](https://code.visualstudio.com/Download) and leverages the support the platform has for developing in containers, so if you have [Docker Desktop](https://hub.docker.com) installed, you should be able to fork this repo, download a copy to locally and open the folder in a container.  All the dependencies are there, nothing to install, no need to worry about specific versions of libraries, creating venvs on your machine.  Heck you don't even need Python installed!

Contributions to documentation, utilities and issues are welcome.  All pull requests must include unittests and all existing tests must pass before being considered.

## Todo
* Make documentation as part of build
* Add more samples to documentation

## License
This work is licensed under the [GPL](license), which guarentees end users the freedom to study, share, and modify the software for your own use.