semvec/pypi-packages huggingface dataset:
notifyhub 0.0.5
Notification on instant messaging platforms
Requires Python: >=3.6

# NotifyHub

Library to send you messages from your python scripts.

## Setup

### For contributors:

```bash
conda create -n notifyhub python==3.6.6  # works with RPi
conda activate notifyhub
pip install -r requirements.txt
```

### For users:

```bash
cd ..  # parent directory
pip install notifyhub
```

## Usage

```python
from notifyhub import send, watch

CONFIG_FP = '<CONFIG_FP>'  # config .json file
send(message="hello there", config_fp=CONFIG_FP)  # sends message 'hello there'


# watch program to check if it crashes/completes
@watch(config_fp=CONFIG_FP)
def main():
    print('do something')
```

### Telegram

Your telegram configuration file should look like:
```
{
    "bot": "telegram",
    "bot-token": "<BOT TOKEN>",
    "chat-id": <CHAT ID>
}
```


### Discord
Your discord configuration file should look like:
```
{
    "bot": "discord",
    "bot-token": "<BOT TOKEN>",
    "chat-id": <CHANNEL ID>
}
```
qlsc 1.0.6
A Python implementation of the quadrilateralized spherical cube scheme.
Requires Python: >=3.6

The quadrilateralized spherical cube (QLSC) is a geospatial indexing scheme for segmenting a sphere into pixels with the aim of optimized spatial indexing and queries. QLSC is an implementation of this scheme in a Python package. Parts of it are based on code from Sergey Koposov’s Q3C, a PostgreSQL extension that implements QLSC indexing. In addition to sphere segmentation, this package provides the catalog indexing functionality of Q3C without the need to install a PostgreSQL database.

This package also enables fast local cone searches on astronomical catalogs without the need to install any other dependencies, supporting essentially unlimited numbers of coordinates (i.e. if you're familiar with Q3C, the same can be performed without PostgreSQL).
pylogin-sys 1.0
The universel login system

# Pylogin


### The project
Pylogin is colection of codes that provide a simple login system for your web app - site.

### How to use
After executing the Pylogin initialization script(pylogin)  you can implement you Reactjs project under the Link tag inside log/src/Dashboard.js

### Bugs
In case that you find a bug report it on github, or send an e-mail to pylogin@protonmail.com


### Instalation
To install Pylogin, run in a terminal 
	`pip install pylogin`

----------------------------
### More information
To more information - documentation go to ouer site or github

| name   |      link      |  Description |
|----------|:-------------:|------:|
| Site |  pylogin.netlify.app/ | Big documentation - General inf. |
| Github | github.com/jazzman07/pylogin/      |  Code - Small Documentation  |
kronecker 0.0.2
Create boolean tensors / sparse matrices from index expressions
Requires Python: >=3.8

# Kronecker

A small library that provides a convenient syntax for creating boolean tensors / sparse matrices.

## Examples

```Python
i, j = kronecker.indices(4, 4)
arr = (i >= j * 2 - 1).to_numpy()

np.array_equal(arr, np.array([
        [1, 0, 0, 0],
        [1, 1, 0, 0],
        [1, 1, 0, 0],
        [1, 1, 1, 0]
    ]).astype(bool))
> True
```

```Python
i, j, k = kronecker.indices(2, 2, 3)
arr = (i >= j + k - 1).to_numpy()

np.array_equal(arr, np.array([
        [[1, 1, 0], [1, 0, 0]],
        [[1, 1, 1], [1, 1, 0]]
    ]).astype(bool))
> True
```

```Python
# would run out of memory if created as a numpy array
i, j = kronecker.indices(1_000_000, 1_000_000)
x = (i * 5 == j).to_sparse()
assert x.sum() == 200000
```

## Limitations
* When creating sparse matrices linear expressions in the indices are simplified and evaluated once per row, giving a complexity of O(n_rows * n_True_per_row). For non-linear expressions (including ones that contain integer division `//`) a slower, O(n_rows * n_cols), path is used. This is mostly useless, creating a numpy array and converting is much faster (but uses more memory).
* Only the operators {`+`, `-`, `*`, `/`, `//`, `**`} are supported.
* Multiple comparisons (`i < j < 2 * i`) are not supported.
snappyzones 0.0.8
a Linux window manager based on Microsoft's FancyZones
Requires Python: >=3.8

# Snappy Zones

## FancyZones for Linux

This project is an attempt to emulate the functionality Windows users get from FancyZones. Users can drag and drop windows into predefined zones, and have SnappyZones fit the window to the zone specs. Users can also snap windows left/right between zones.

How to use:

Snappy Zones can be started from either the console command `snappy` or by calling the module `python -m snappyzones`. These two starting methods are essentially synonymous.

On first use, we'll need to configure our zones. This can be done by calling `snappy config zones -n <ZONE_COUNT>` where `<ZONE_COUNT>` is the number of zones to generate. Snappy Zones will generate a number or blank Xorg windows equivalent to the `<ZONE_COUNT>`. Drag these windows around your screen as you would any other window. When your zones are placed, type `save` into the terminal to save the zone configuration. You can also type `exit` to exit without saving.

With our zones configured, we can now call `snappy` to start Snappy Zones as a terminal process. With snappy running, we can hold `Shift_L` to activate snapping. Holding this keybinding, we can drag windows to our zones, and upon releasing the mouse click the window will snap to the dimensions of the predefined zones. We can also press `Left/Right` arrow keys so to rotate the current active window across zones.

Snappy Zones can also be run as a background process. `snappy start` Pushes Snappy Zones to a background process. `snappy stop` kills the process.

This project is currently under active development, please check back for more updates and features soon.

`Note:` This package requires access with the Xorg server bindings, so it should only be used on Xorg-based Unix Systems or systems with sufficient Xorg backwards compatibility.