semvec/pypi-packages huggingface dataset:
pytsg 0.5.0
Library to read .tsg file package

# pytsg
## Rationale
The spectral geologist (TSG) is an industry standard software for hyperspectral data analysis
https://research.csiro.au/thespectralgeologist/

pytsg is an open source one function utility that imports the spectral geologist file package into a simple object.

## Installation
Installation is via pip
```pip install pytsg```

## Usage

If using the top level importer the data is assumed to follow this structure
```
\HOLENAME
         \HOLEMAME_tsg.bip
         \HOLENAME_tsg.tsg
         \HOLENAME_tsg_tir.bip
         \HOLENAME_tsg_tir.tsg
         \HOLENAME_tsg_hires.dat
         \HOLENAME_tsg_cras.bip

```

```python
from matplotlib import pyplot as plt
from pytsg import parse_tsg

data = parse_tsg.read_package('example_data/ETG0187')

plt.plot(data.nir.wavelength, data.nir.spectra[0, 0:10, :].T)
plt.plot(data.tir.wavelength, data.tir.spectra[0, 0:10, :].T)
plt.xlabel('Wavelength nm')
plt.ylabel('Reflectance')
plt.title('pytsg reads tsg files')
plt.show()

```

If you would prefer to have full control over importing individual files the following syntax is what you need

```python

# bip files
nir = parse_tsg.read_tsg_bip_pair('ETG0187_tsg.tsg','ETG0187_tsg.bip','nir')
tir = parse_tsg.read_tsg_bip_pair('ETG0187_tsg_tir.tsg','ETG0187_tsg_tir.bip','tir')

# cras file
cras = parse_tsg.read_cras('ETG0187_tsg_cras.bip')

# hires dat file
lidar = parse_tsg.read_lidar('ETG0187_tsg_hires.dat')


```
For convienience 
## Thanks
Thanks to CSIRO and in particular Andrew Rodger for his assistance in decoding the file structures.
finch-tensor 0.2.14
Sparse Tensor Programming in Python powered by Finch.jl
Requires Python: <4.0,>=3.11

# finch-tensor

This is the beginnings of a sparse tensor library for Python, backed by the
[Finch.jl](https://github.com/finch-tensor/Finch.jl) tensor compiler.

## Source

The source code for `finch-tensor` is available on GitHub at [https://github.com/finch-tensor/finch-tensor](https://github.com/FinchTensor/finch-tensor)

## Installation

`finch-tensor` is available on PyPi, and can be installed with pip:
```bash
pip install finch-tensor
```

## Contributing

### Packaging

Finch uses [poetry](https://python-poetry.org/) for packaging.

To install for development, clone the repository and run:
```bash
poetry install --with test
```
to install the current project and dev dependencies.

### Working with a local copy of Finch.jl
The `develop.py ` script can be used to set up a local copy of Finch.jl for development.

```
Usage:
    develop.py [--restore] [--path <path>]

Options:
    --restore   Restore the original juliapkg.json file.
    --path      Path to the local copy of Finch.jl [default: ../Finch.jl].
```

### Publishing

The "Publish" GitHub Action is a manual workflow for publishing Python packages to PyPI using Poetry. It handles the version management based on the `pyproject.toml` file and automates tagging and creating GitHub releases.

#### Version Update

Before initiating the "Publish" action, update the package's version number in `pyproject.toml`. Follow semantic versioning guidelines for this update.

#### Triggering the Action

The action is triggered manually. Once the version in `pyproject.toml` is updated, manually start the "Publish" action from the GitHub repository's Actions tab.

#### Process and Outcomes

On successful execution, the action publishes the package to PyPI and tags the release in the GitHub repository. If the version number is not updated, the action fails to publish to PyPI, and no tagging or release is done. In case of failure, correct the version number and rerun the action.

#### Best Practices

- Ensure the version number in `pyproject.toml` is updated before triggering the action.
- Regularly check action logs for successful completion or to identify issues.

### Pre-commit hooks

To add pre-commit hooks, run:
```bash
poetry run pre-commit install
```

### Testing

Finch uses [pytest](https://docs.pytest.org/en/latest/) for testing. To run the
tests:

```bash
poetry run pytest
```
pyenv-inspect 0.5.0
An auxiliary library for the virtualenv-pyenv and tox-pyenv-redux plugins
Requires Python: >=3.9
Keywords: pyenv

# pyenv-inspect

An auxiliary library for the [virtualenv-pyenv][virtualenv-pyenv] and [tox-pyenv-redux][tox-pyenv-redux] plugins

## Limitations

Only CPython is supported at the moment.


[virtualenv-pyenv]: https://github.com/un-def/virtualenv-pyenv
[tox-pyenv-redux]: https://github.com/un-def/tox-pyenv-redux
dark-send 1.2.0
A Command Line Interface for Telegram
Requires Python: >=3.8

# dark-send 

Dark-send is a CLI telegram client written in python. It sends messages and files through your personal telegram account using a daemon that maintains a connection in the background, much like the stock telegram desktop app.

## Dependencies 

``` shell 
pip3 install -r requirements.txt 
``` 

## Installation 

Install directly from PyPi
```shell 
pip3 install dark-send 
```

Or 

Clone the repository to a local directory
``` shell
git clone https://github.com/mindhuntr/dark-send 
```

For system wide installation 
```shell
python3 setup.py install
```

For user specific installation 
```shell
python3 setup.py install --user 
```


## Configuration

dark-send requires a daemon process running in the background. The daemon can be initialized using a parameter 

```shell
dark-send --daemonize
```

Once the config file is generated, it is more robust to create a systemd-unit file that automatically executes the daemon once the system is up 

```

[Unit]
Description=Daemon for dark-send
After=network.target

[Service]
Type=simple
User=YOUR_USER
ExecStart=/usr/bin/python3 -m dark_send.daemon
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
```

Create a file called dark-send.service with the above content and place it in "/etc/systemd/system". Replace "YOUR_USER" with your username and execute the following commands

```shell
systemctl daemon-reload 
systemctl enable dark-send.service
systemctl start dark-send.service
```


## Usage 

Display help: 
``` shell 
dark-send --help 

``` 
To send a message:
``` shell
dark-send Hello!
``` 

![Demo](https://raw.githubusercontent.com/mindhuntr/dark-send/refs/heads/master/demos/send.gif)

To send an image: 
``` shell 
dark-send -i /path/to/image 

``` 
To send files as album: 
``` shell 
dark-send -a -f /path/to/file /path/to/file 
``` 

![Demo](https://raw.githubusercontent.com/mindhuntr/dark-send/refs/heads/master/demos/send_file.gif)

To send a video directly without selecting from the chats list
``` shell 
dark-send -v /path/to/file -c "Alienists" 
```
You can also send messages or files to topics within a group 

![Demo](https://raw.githubusercontent.com/mindhuntr/dark-send/refs/heads/master/demos/send_topic.gif)

## Note 

dark-send now supports bot logins from v1.2.0. It leverages the user client to fetch chats and then the bot account to send messages and files. Users can initialize several bot accounts and use them by names they designate. 

```shell 
dark-send -b FelineBot -f /path/to/file 
```
qimage-hwc-bgrx-8888-ndarray-interop 0.1.0a0
Zero-copy conversion between Qt QImage (in `Format_RGB32`/`Format_ARGB32`) and NumPy ndarray (in HWC BGRX 8888 format).
Requires Python: >=2

# `qimage-hwc-bgrx-8888-ndarray-interop`

Zero-copy conversion between Qt QImage (in `Format_RGB32`/`Format_ARGB32`) and NumPy ndarray (in HWC BGRX 8888 format).

## Features

- Zero-copy: Memory is shared between objects - no pointless data copying!
- Cross-binding: Supports PyQt6, PyQt5, PyQt4, PySide6, PySide2, or PySide.
- Safety: Explicit checks for packing and format - no surprises.

## Installation

Install your preferred Qt binding, then run:

```bash
pip install qimage-hwc-bgrx-8888-ndarray-interop
```

## Usage

```python
# coding=utf-8
from qimage_hwc_bgrx_8888_ndarray_interop import (
    qimage_to_hwc_bgrx_8888_ndarray_view,
    qimage_to_hwc_bgrx_8888_ndarray,
    hwc_bgrx_8888_ndarray_to_qimage_view,
    hwc_bgrx_8888_ndarray_to_qimage,
)

# Convert a QImage to numpy.ndarray (zero-copy view):
arr_view = qimage_to_hwc_bgrx_8888_ndarray_view(qimage)

# Convert a QImage to a copy of image data:
arr = qimage_to_hwc_bgrx_8888_ndarray(qimage)

# Convert a contiguous (H, W, 4) uint8 ndarray back to a QImage (zero-copy view):
qimg_view = hwc_bgrx_8888_ndarray_to_qimage_view(arr)

# Convert ndarray to a QImage (copies data):
qimg_copy = hwc_bgrx_8888_ndarray_to_qimage(arr)
```

## Safety & Caveats

- Endianness: Only little-endian systems are supported (typical modern computers).
    - On unsupported (big-endian) systems, `RuntimeError` is raised at import time.
- Tightly packed images only: QImage must have `bytesPerLine == width * 4` for zero-copy view.
- **Memory lifetime matters:**
    - Do **not** let the QImage or ndarray be garbage collected while the other exists and references its buffer.
    - If in doubt, use the `copy()` variants.

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
testpulcli 0.1.2
A professional CLI for managing Bittensor subnet pool operations
Requires Python: >=3.10
Keywords: bittensor, blockchain, cli, cryptocurrency, pool

# TestPulCLI
A command-line tool built with Click to [describe its purpose, e.g., process inputs or perform tasks].

## Installation
pip install testpulcli

## Usage
testpulcli [arguments]