semvec/pypi-packages huggingface dataset:
streamdeck-sdk-cli 0.0.2
Command Line Interface for streamdeck-python-sdk.
Requires Python: >=3.8
Keywords: streamdeck sdk cli, streamdeck test project, python, sdk, streamdeck, streamdeck-sdk, streamdeck_sdk, stream deck sdk, stream deck, elgato, elgato sdk, elgato stream deck, streamdeck-python-sdk, streamdeck_python_sdk, streamdeck python sdk

<p align="center">
    <a href="https://pypi.org/project/streamdeck-sdk-cli" target="_blank">
        <img src="https://img.shields.io/pypi/v/streamdeck-sdk-cli" alt="PyPI">
    </a>
    <a href="https://pypi.org/project/streamdeck-sdk-cli" target="_blank">
        <img src="https://static.pepy.tech/badge/streamdeck-sdk-cli" alt="PyPI">
    </a>
    <a href="https://opensource.org/licenses/Apache-2.0" target="_blank">
        <img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="Apache">
    </a>
    <a href="https://docs.elgato.com/sdk" target="_blank">
        <img src="https://badgen.net/badge/Elgato/doc/blue" alt="Elgato">
    </a>
</p>

# streamdeck-python-sdk-cli

Command Line Interface for [streamdeck-python-sdk](https://github.com/gri-gus/streamdeck-python-sdk).

**PyPi**: https://pypi.org/project/streamdeck-sdk-cli

**Supported operating systems:**

* MacOS: 10.14 or later
* Windows: 10 or later

**Supported Python versions:** 3.8 or later

## Installation

> ⚠️ For correct operation on Windows, it is recommended to enable `LongPaths` support in
> the system: [manual](https://www.backupery.com/how-to-enable-ntfs-long-paths-in-windows/).
> Without this setting, problems with installation and use may occur!

```shell
pip install streamdeck-sdk-cli
```

---

See full description and usage examples on
[GitHub](https://github.com/gri-gus/streamdeck-python-sdk-cli)
computer2mqtt 0.1.2
This project is a multi-system and multi-OS adaptation of mac2mqtt. It allows you to execute any command on your system, providing endless possibilities for automation and control.
Requires Python: >=3.12

# Computer2Mqtt

This project is a multi-system and multi-OS adaptation of [mac2mqtt](https://github.com/bessarabov/mac2mqtt). It allows you to execute any command on your system, providing endless possibilities for automation and control.


## Requirements

This assumes you have [direnv](https://direnv.net/) and [uv](https://github.com/astral-sh/uv) installed

Simply run `direnv allow` to setup the environment, you can read the contents of [.envrc](.envrc) to see what it does behind the scenes.


## Setup

1. Clone this repository to your local machine.
2. Run `direnv allow` in the project directory. This will set up the Python environment using `pyenv`.
3. Create a `computer2mqtt.yaml` by copying [computer2mqtt-example.yaml](computer2mqtt-example.yaml) configuration file in the project root.
There are 2 important sections first the mqtt config, and second the commands you want to run.
In the example below these are commands for macs to turn on/off the display. This should be changed to commands for your target system. Possibility is endless.

```yaml
mqtt:
  ip: 192.168.1.100
  port: 1883
  user: username
  password: password


commands:
  # Example mac command to wake/sleep display
  displaysleep: "pmset displaysleepnow"
  displaywake: "caffeinate -u -t 1"
```

4. Run `computer2mqtt` and note down the `Sanitized hostname: Mac-mini`, Mac-mini in this case.
5. Set up Home Assistant Scripts to trigger commands. Here is an example from my `scripts.yaml` file in Home Assistant

```yaml
macmini_displaysleep:
  alias: Mac Mini Display Sleep
  icon: mdi:laptop
  sequence:
    - service: mqtt.publish
      data:
        topic: "mac2mqtt/{device_name}/command/displaysleep"
        payload: "displaysleep"

macmini_displaywake:
  alias: Mac Mini Display Wake
  icon: mdi:laptop
  sequence:
    - service: mqtt.publish
      data:
        topic: "mac2mqtt/{device_name}/command/displaywake"
        payload: "displaywake"
```
Replace {device_name} with the name of your device from the previous step!

# Running in the background

To run the script in the background, you can use the screen command. screen is a full-screen window manager that multiplexes a physical terminal between several processes.

1. Start a new screen session with name of your choice with the command `screen -S {mysession}`.
1. Run the script with the command `computer2mqtt`.
1. Detach from the screen session with the command Ctrl-a d.
1. You can reattach to the session at any time with the command `screen -r {mysession}`. This will keep the script running in the background, even if you close the terminal.
postman-github-sync 0.1.0.3
This script automates the process of setting up GitHub Actions workflows for Postman collections. It supports both GitHub repository integration and local workflow setup, allowing for flexible usage in various scenarios.
Requires Python: >=3.7

# PostmanxGithub Action Automatic Sync

This Python package automates the process of setting up GitHub Actions workflows for Postman collections. It supports both GitHub repository integration and local workflow setup, allowing for flexible usage in various scenarios.

## Features

- Export Postman collections using a UID or from a local file
- Add Postman collections to GitHub repositories (new or existing)
- Create or update GitHub Actions workflows
- Set up workflows locally without GitHub interaction
- Use custom YAML templates for GitHub Actions workflows
- Support for both new and existing repositories

## Installation

You can install the package using pip:

```bash
pip install postman-github-sync
```

## Usage

After installation, you can use the package in two ways:

1. As a command-line tool:

```bash
postman_github_sync [--local] [--template PATH_TO_TEMPLATE]
```

2. As a Python module:

```python
from postman_github_sync import main

main()
```

### Command-line Options

- `--local`: Set up the workflow files locally without interacting with GitHub.
- `--template PATH_TO_TEMPLATE`: Use a custom YAML template for the GitHub Actions workflow.

### Environment Variables

- `GITHUB_TOKEN`: Your GitHub personal access token (required for GitHub operations)
- `POSTMAN_API_KEY`: Your Postman API key (required for exporting collections by UID)

## Examples

1. Setting up a workflow in a GitHub repository:
   ```bash
   postman_github_sync
   ```

2. Setting up a local workflow:
   ```bash
   postman_github_sync --local
   ```

3. Using a custom template for GitHub setup:
   ```bash
   postman_github_sync --template my_template.yml
   ```

## Development

To set up the development environment:

1. Clone the repository:
   ```bash
   git clone https://github.com/yourusername/postman_github_sync.git
   cd postman_github_sync
   ```

2. Create a virtual environment and activate it:
   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   ```

3. Install the package in editable mode with development dependencies:
   ```bash
   pip install -e ".[dev]"
   ```

4. Run tests:
   ```bash
   pytest
   ```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
harlequelrah 0.1
Package personnalisé pour faciliter la programmation et le développement avec python
Requires Python: >=3.10

# Harlequelrah

PassionÃ© par la programmation et le dÃ©veloppement avec python je me lance dans la crÃ©ation progressive d'une bibliothÃ¨que personnalisÃ©e pour m'ameliorer , devenir plus productif et partager mon expertise

# Installation

- Avec Github : git clone https://github.com/Harlequelrah/My_Python_Library"
- Avec pip : pip install harlequelrah

# Utilisation

from harlequelrah import une_fonction

# Contact ou Support

Pour des questions ou du support, contactez-moi Ã  maximeatsoudegbovi@gmail.com ou au (+228) 91 36 10 29.
glm-cli 0.1.0
Genelec GLM API (works over virtual midi, expects app to be open)
Requires Python: >=3.12

# glm cli

Genelec GLM cli (works over virtual midi, expects app to be open)

## Requirements

This assumes you have [direnv](https://direnv.net/) and [uv](https://github.com/astral-sh/uv) installed

Simply run `direnv allow` to setup the environment, you can read the contents of [.envrc](.envrc) to see what it does behind the scenes.

## Usage

1. Open the Genelec GLM app

2. Open Audio Midi Setup -> Window show Midi Studio -> Make sure IAC Driver is online, you can look at image below to verify

![iac-driver](./docs/iac-driver.png)

3. Open Settings -> Midi Settings on GLM app, make sure Enable GLM Midi interface is checkend, and the virtual midi device from the previous step is selected.

![glm-midi-settings](./docs/glm-midi-settings.png)

4. Run `glm-cli --help` to see the available commands
random-english-word-generator 1.0.1
A Python package to generate random English words based on word length and count
Requires Python: >=3.6

# Random English Word Generator

🎉 **Random English Word Generator** is a Python package that generates random English words based on the length and number of words you specify! 🎉

This package leverages the `nltk` corpus to generate real English words, making it perfect for tasks like text augmentation, random text generation, and adding random noise to datasets.

## Features

- **Custom Word Length**: You can specify the word length for each word generated.
- **Generate Multiple Words**: Generate a list of random words by specifying how many you need.
- **Lightweight & Easy to Use**: No external dependencies other than `nltk`, and easy to set up.

## Installation

Install the package using pip:

```bash
pip install random-english-word-generator
```

## Usage

```python
from random_english_word_generator import generate_words

# Generate 5 random words of length 6
words = generate_words(word_length=6, num_words=5)
print(words)
# Output: ['planet', 'system', 'orange', 'monkey', 'banana']
```

## Contributing

If you have any suggestions for improving this package, feel free to open an issue or submit a pull request on GitHub. We appreciate your contributions!

## Links

For more tools and features, visit our website: 👉 [randomgenerator.ai](https://randomgenerator.ai)
zisnmf 0.1.2
Zero-inflated Supervised Non-negative Matrix Factorization
Requires Python: >=3.6

# LSNMF

This package implements Zero-inflated Supervised Non-negative Matrix Factorization (ZISNMF) for Python using PyTorch. ZISNMF is a supervised matrix factorization method that can discover marker genes associated with specific contexts such as cell types and disease states from single-cell RNA-seq data.

## Installation

Users can download the code and install it using pip:
```bash
pip install zisnmf
```

## Usage

The usage of `zisnmf` is similar to scikit-learn's `NMF`:

```python
from zisnmf import ZISNMF

# Load your data matrix X and label matrix L
# ...

# Create a LSNMF instance
model = ZISNMF(n_cells, n_features, n_classes, n_extra_states,  zero_inflated=True, device='cuda')

# Fit the model
num_epochs = 30
batch_size = 2048
learning_rate = 0.001
alpha = 0.2
W, H = model.fit_transform(X, L, num_epochs=num_epochs, batch_size=batch_size, learning_rate=learning_rate, alpha=alpha)
tiniestsegmenter 0.3.0
Compact Japanese segmenter
Requires Python: >=3.8
Keywords: tokenizer, NLP, ngram, Japanese

# TiniestSegmenter

A port of [TinySegmenter](http://chasen.org/~taku/software/TinySegmenter/) written in pure, safe rust with no dependencies. You can find bindings for both [Rust](https://github.com/jwnz/tiniestsegmenter/tree/master/tiniestsegmenter) and [Python](https://github.com/jwnz/tiniestsegmenter/tree/master/bindings/python/).

TinySegmenter is an n-gram word tokenizer for Japanese text originally built by [Taku Kudo](http://chasen.org/~taku/) (2008). 


<b> Usage </b>

`tiniestsegmenter` can be installed from PyPI: `pip install tiniestsegmenter`

```Python
import tiniestsegmenter

tokens = tiniestsegmenter.tokenize("ジャガイモが好きです。")
```

With the GIL released on the rust side, multi-threading is also possible.

```Python
import functools
import tiniestsegmenter

tokenizer = functools.partial(tiniestsegmenter.tokenize)

documents = ["ジャガイモが好きです。"] * 10_000
with ThreadPoolExecutor(4) as e:
    list(e.map(encoder, documents))
```
topicpy 0.3.1
Package to extract information from topic models.
Requires Python: >=3.6

![Python application](https://github.com/fvalle1/topicpy/workflows/Python%20application/badge.svg)
![CodeQL](https://github.com/fvalle1/topicpy/workflows/CodeQL/badge.svg)
[![made-with-sphinx-doc](https://img.shields.io/badge/Made%20with-Sphinx-1f425f.svg)](https://topicpy.readthedocs.io/en/latest/)
[![GitHub](https://img.shields.io/github/license/fvalle1/topicpy)](LICENSE)

# topicpy
Python package for topic modelling pre and post processing

# Install

This is available trough [pip](https://pypi.org/project/topicpy/)
`pip install topicpy`

# Modules

This package consists of multiple modules:

- converter: handels gene name conversions
- geneontology: uses GSEA to perform gene ontologies
- gtex: handle GTEx data
- hsbmpy: handle ouput of hierarchical stochastic block model
- hypergeom: perform hypergeometric tests
- lda: Run sklearn LatenDirichletAllocation with some more parameters
- tableanalyser: study distributions of a RNA-Seq data
- TCGA_files: handle TCGA metadata

# Documentation
[https://topicpy.readthedocs.io/en/latest/](https://topicpy.readthedocs.io/en/latest/)

# Test
Run unittest with

``` python
python test/test.py
```

# License
See [LICENSE](LICENSE)
ngc 0.21
Python New General Common Tool
Requires Python: >=3.8

# Python New General Common Tool

A simple common py-tool mainly formed with easy functions for users who like to write small scripts, with less class and complex things.

Please use the newest version of python to use. It is being improved.

It use lambda in general. It includes functions of multi-regions like os as dirlist(traverse folder), IO, string operating, data struct operating and web operating.
matter-persistence 1.7.0
Matter persistance library.
Requires Python: >=3.10
Keywords: async, orm, pydantic, redis, sql

# matter-persistence

[![PyPI - Version](https://img.shields.io/pypi/v/matter-persistence.svg)](https://pypi.org/project/matter-persistence)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/matter-persistence.svg)](https://pypi.org/project/matter-persistence)

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install matter-persistence
```

## Usage

**CacheManager** and **DatabaseManager** are the two central objects in matter_persistence.

**CacheManager** encapsulates a connection pool to Redis, and exposes methods to save, retrieve, and delete values from Redis.

*Check usage example for redis* **CacheManager** *in [examples/redis](./examples/redis.ipynb).*

**DatabaseManager** encapsulates a Sqlalchemy connection pool to a relational database (e.g. Postgresql),
and exposes methods to obtain
a [Connection](https://docs.sqlalchemy.org/en/20/core/connections.html#sqlalchemy.engine.Connection) or
a [Session](https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.Session).

Furthermore, there is a **CustomBase** in matter_persistence/sql/base.py, which is a convenient Base class for Sqlalchemy
ORM classes. It has an "id" primary key field, which is of type UUID, a "created", "updated" field that is inherited
from sqlalchemy_utils' Timestamp, and a "deleted" field, which is of type nullable timezone aware DateTime.

The **get** and **find** functions in matter_persistence/sql/utils.py
assume a deleted field!

*Check usage example for* **DatabaseManager** *and some of the utility functions in [examples/sql](./examples/sql.ipynb).*

## Contributing

for contributions, check the [CONTRIBUTING.md](CONTRIBUTING.md) file
h5xp-extractor 0.1.0
A script to extract waves from an Igor Pro 8 or later .h5xp file
Requires Python: >=3.8

The script h5xp_extractor.py extracts wave data from an Igor Pro HDF5 file (h5px).

It exports all or selected data folders and mirrors the folder structure of source file.

Datasets are exported as follows: 

- 1D waves: XY pairs (scaling included) to .txt files
- 2D waves: lossless .tif images (preserving bit resolution).
- 3D waves: .tif stacks (preserving bit resolution)
- String, variables and textwaves are currently ignored.
 
A detailed export .log files is written in the root export directory.

**usage: h5xp_extractor.py [-h] [-r ROOT] [-m META] h5px outdir**

Metadata are written in README.txt files for every (sub-)folder (default, optionally use -m 0 (--meta) flag to skip README files).

Set the optional flag -r RootFolder (--root) to select another base "root" folder
for the export. Use single quotes for literal names (names with special characters 
and spaces) and a semicolon (:) as a directory separator (e.g. folder1:Sample123:'Dataset after heating').

To export only the subfolder 'Dataset after heating' of the parent 
folder Sample123, use the optional argument -r Sample123:'Dataset after heating'.

**N.B: Skip the root: folder (Igor's root folder) when using the -r to specify Igor Pro folders**

positional arguments:
  - h5px                  Igor Pro .h5xp file. Partial or full path
  - outdir                Output folder (create/overwrite)

optional arguments:
  - -h, --help            show this help message and exit
  - -r ROOT, --root ROOT  Root folder
  - -m META, --meta META  Export metadata (0 = No, 1 = Yes [default])
mlmaid 0.1.2.3
ML-MAID : ML - Miniature Automatic Installer for Dependencies

# ML-MAID : ML - Miniature Automatic Installer for Dependencies
- Install dependencies without having to issue a zillion `pip install` commands.
- Re-implement ML-Maid compliant workflows and repositories without a sweat.
- No need to use Conda and Docker unless you really have to.
- Requirement files don't solve the problem.
- Setup CUDA automatically. <img src='https://img.shields.io/badge/pending-red'/> 

## Why ML MAID ?
ML Maid aimed to be a complete and unique tool that aims to automatically install dependencies in Python with specific focus on ML environments. It aims to solve the problem of environment re-creation from old code without the hassle of manually building docker containers unless really required. The idea behind ML-Maid is to implicitly enforce checks to keep the environment setup as simple as possible, so that it is easy to replicate. It also aims to completely automate the environment replication process. It aims to keep the environment simple starting from the production phase of the software life-cycle to save developer time. 

## Is ML-Maid a Replacement for Docker / Conda / Python Venv : NO
ML Maid aims to automate the use of tools like Docker / Conda / Python venv **without adding any additional complexity** so that the developer can focus on writing code.

## Installation
```bash
pip install mlmaid
```

## Usage
⚫ In your main Python script add the following to automatically install / check the dependencies before any other code is run:
```python
from mlmaid import install
install(script_path=__file__, python_version='3.10.12', sys_reqs=['cuda==11.8'])
```
(Change Python version and cuda version according to your requirements)

⚫ Import your modules
```python
import my_local_module # local_module
from PIL import Image # pillow==1.0.2
```
- Add the `# local_module` tag to modules that are local imports
- If a module's import name is different from its installation name, just add the installation name as a comment
- By default the latest version of all (non-local) modules will be installed, if you want a specific version, specify it as a comment after import statement. like : `import PIL # pillow==1.0.2`
igc2kml 0.1.0
Convert IGC files from glider flights to KML files, which can be viewed in Google Earth.
Requires Python: >=3.7

IGC -> KML converter
==========

Simple command line tool to convert .IGC files from a flight logger (e.g. a paragliding vario) to .KML files, so your track can be viewed on Google Earth.

Usage
----

```igc2kml file1.igc```

Use ```igc2kml --help``` to see all available options. 

Launch site detection
-----

The parser will automatically detect the nearest known paragliding launch-site and use it for the filename and the KML description.
To extend this list, simply open the file with a text editor and add your site to the list at the top.
djangocms-blog-view-restrictions 0.3.0
Control who can view your djangocms-blog posts

Control who can view your djangocms blog posts

----

## Install

* Install the package
    ```bash
    python3 -m pip install djangocms-blog-view-restrictions
    ```

* Add it in your `INSTALLED_APPS`:
    ```python
    "djangocms_blog_view_restrictions",
    ```

* Run the migration:
    ```sh
    python3 manage.py migrate djangocms_blog_view_restrictions
    ```

## Usage

When creating/editing a blog post, a new "View restriction" section allows you to define multiple users/groups that are allowed to view the post.
The user is allowed to view the post if any of the restrictions are met.

You are then responsible to hide partially or totally the post's content in your `djangocms_blog/post_detail.html` template:
```html
{% extends "djangocms_blog/post_detail.html" %}
{% load blog_view_restrictions_tags %}


{% block content_blog %}
  <article>
    {{ post.abstract }}

    {% if request.user|can_view_post:post %}
      {% if post.app_config.use_placeholder %}
        <div class="blog-content">{% render_placeholder post.content %}</div>
      {% else %}
        <div class="blog-content">{% render_model post "post_text" "post_text" "" "safe" %}</div>
      {% endif %}
    {% else %}
      This post is for subscribers only.
    {% endif %}

    ...

  </article>
{% endblock content_blog %}
```