semvec/pypi-packages huggingface dataset:
epa-syllabicate 0.2.2
Automatic syllabification module for Spanish words
Requires Python: >=3.8
Keywords: linguistics, nlp, spanish, syllabification, text-processing

# EPA Syllabicate

Módulo Python para la silabificación de palabras.

## Uso

```python
from epa_syllabicate import syllabicate

# Ejemplo de uso
word = "ehemplo"
silabes = syllabicate(word)
print(silabas)  # ['e', 'hem', 'plo']
```

## Desarrollo

### Instalación para desarrollo

Para contribuir al proyecto, primero clona el repositorio y luego instala las dependencias de desarrollo:

```bash
git clone https://github.com/tu-usuario/epa-syllabicate.git
cd epa-syllabicate
python -m env .venv
source .venv/bin/activate
python -m pip install -e ".[dev]"
```

### Ejecución de tests

Para ejecutar los tests:

```bash
# Ejecutar todos los tests
pytest

# Ejecutar tests con cobertura
pytest --cov=epa_syllabicate
```

## Requisitos

- Python >= 3.8

## Licencia

Este proyecto está licenciado bajo la Licencia GPL v3 - ver el archivo [LICENSE](LICENSE) para más detalles.
blisswebui 2025.6.0
Web User Interface for BLISS
Requires Python: >=3.8

# blisswebui

![blisswebui](images/blisswebui.png 'blisswebui')

Bliss Web UI provides a simple web user interface to consume the bliss [REST API](https://bliss.gitlab-pages.esrf.fr/bliss/master/blissapi.html).
needlr 0.2.1
Needlr provides a unified cross-experience Microsoft Fabric SDK.
Requires Python: >=3.8

# Needlr: A Unified SDK for Microsoft Fabric

The Needlr packages provides a unified, cross-experience Microsoft Fabric SDK. The goal of Needlr is to simplify the way you work with Fabric APIs and support deployments and automation allowing you to focus on solving your business problems.


## Quickstart
Needlr is available on [PyPi](https://pypi.org/project/needlr/) and can be installed via `pip install needlr`.

With needlr installed, you first authenticate by creating a Fabric client. You can use either [FabricInteractiveAuth](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.interactivebrowsercredential?view=azure-python) to use your personal credentials or `FabricServicePrincipal` to use a service principal (which is supported for most but not all APIs).

```python
from needlr import auth, FabricClient
from needlr.auth import FabricInteractiveAuth

fc = FabricClient(auth=auth.FabricInteractiveAuth())
for ws in fc.workspace.ls():
    print(f"{ws.name}: Id:{ws.id} Capacity:{ws.capacityId}")
```
You use Service Principals in a similar way by bringing in the app id, secret, and tenant id. Replace the strings below with your service principals information.

```python
from needlr import auth, FabricClient
from needlr.auth import FabricServicePrincipal

auth = FabricServicePrincipal("APP_ID", "APP_SECRET", "TENANT_ID")
fc = FabricClient(auth=auth)
for ws in fc.workspace.ls():
    print(f"{ws.name}: Id:{ws.id} Capacity:{ws.capacityId}")
```

Needlr supports many of the Fabric REST APIs and we appreciate contributions to help us close that gap.

Some of our best supported APIs include:

* Data Warehouse
* Data Engineering
* Real-time Intelligence

Needlr has been designed to support Fabric deployment and automation and follows a convention to make it easier to discover and connect APIs.

* List items like workspaces, tables: `fc.<item>.ls()` as in `fc.workspace.ls()`
* Create items like lakehouses, event streams: `fc.<item>.create()` as in `fs.lakehouse.create('NameOfLakehouse')`
* Delete items: `fc.<item>.delete()` as in `fc.warehouse.delete(worskspace_id, warehouse_id)`

Get started with more of our [samples](https://github.com/microsoft/needlr/tree/main/samples) and please be sure to share your ideas with us on what you need to support your Fabric deployments by creating an [issue](https://github.com/microsoft/needlr/issues).

## Additional Resources

* [Contributing](https://github.com/microsoft/needlr/blob/main/CONTRIBUTING.md) to the project
* Official [Fabric REST API](https://learn.microsoft.com/en-us/rest/api/fabric/articles/) docs
jax-radio-tools 0.1.3
Tools used for radio emission of air showers in the JAX framework

# jax_radio_tools : A JAXified version of radiotools (in progress!)

Utility functions for radio emission of cosmic rays in the JAX framework. Based on [radiotools](https://github.com/nu-radio/radiotools/tree/master).

## Installation

The tool can easily be installed via `pip`:

```
pip install -U jax_radio_tools
```

which will also install the necessary packages for installation.

## Dependencies
- `jax`
- `jaxlib`
- `numpy >=1.20`
- `typing_extensions`
- `python>=3.11` (May be possible with older python versions, but not yet tested)

## Current implementations

Currently, the following tools are implemented:

### Trace Utilities

These can be accessed via `jax_radio_tools.trace_utils`.

- zero padding
- bandpass filter
- hilbert envelope
- resampler
- trace centering
- relative trace centering 
- signal window truncation

### Shower Utilities

These can be accessed via `jax_radio_tools.shower_utils`.

- calculating arrival times
- calculating gaisser hillas functions (coreas formalism, LR formalism)
    - change: updated the functions to make it more numerically stable
- calculating fluences
- calculating cross correlations

### Atmosphere model
Following radiotools, an importable module to define the atmosphere. 

These can be accessed via `jax_radio_tools.atmosphere.Atmosphere`.

Current features implemented are:
- calculation of distance from grammages
- calculation of cherenkov angle
- calculation of vertical heights
- calculation of density
- calculation of refractive index
- all atmospheric models from radiotools are supported
- additionally, GDAS atmospheric files are also now supported

### Coordinate system
Following radiotools, we define a cstrafo object that takes care of coordinate systems. This is defined
by a zenith angle, azimuthal angle, and magnetic field vector.

These can be accessed via `jax_radio_tools.cstrafo`.

Further calculations that are in the `coordinate_transformations`:
- transformation from GEO/CE <-> vxB / vxvxB axis in the shower plane
- function to get the normalised angle (for accurate angles when porting from e.g. CoREAS)

More implementations to come!

## TODOS

- [ ] include documentation
- [ ] include CI/CD pipeline
- [ ] implement other useful radiotools functions
- [ ] make the cstrafo object jax-compatible with zenith & azimuth angles

## LICENSE

This code is under the BSD-3 License. See [LICENSE](LICENSE) for more details.
quicklst 0.0.3
Read lst files produced by FAST ComTec's mpa system.
Requires Python: >=3.7

# Quicklst

Quicklst ist a python library for reading .lst files produced by FAST ComTec's mpa system. It uses numba to accelerate
the reading of the file and supports block or chunk wise loading of large files.

Limitations: Both MPA3 and MPA4A files are supported, but they need to be in binary form not in ASCII encoding, the real
time clock is not implemented either.

Basic usage is demonstrated in `examples/Quickstart.ipynb`.
bhqrprt 4.2.6
Logging system for Blender extensions
Requires Python: >=3.11
Keywords: bpy, logging

<!--
SPDX-FileCopyrightText: 2025 Ivan Perevala <ivan95perevala@gmail.com>

SPDX-License-Identifier: GPL-3.0-or-later
-->

# Python Logging and Blender Integration Package

[![PyPI](https://img.shields.io/pypi/v/bhqrprt.svg)](https://pypi.org/project/bhqrprt/)
[![Status](https://img.shields.io/pypi/status/bhqrprt.svg)](https://pypi.org/project/bhqrprt/)
[![License: GPL-3.0-or-later](https://img.shields.io/badge/license-GPLv3-yellow.svg)](https://www.gnu.org/licenses/gpl-3.0-standalone.html)
[![Documentation Status](https://readthedocs.org/projects/lib-bhqrprt/badge/?version=latest)](https://lib-bhqrprt.readthedocs.io/latest)
[![Spell Check](https://github.com/ivan-perevala/lib_bhqrprt/actions/workflows/spellcheck.yml/badge.svg)](https://github.com/ivan-perevala/lib_bhqrprt/actions/workflows/spellcheck.yml)
[![Blender Addon Testing](https://github.com/ivan-perevala/lib_bhqrprt/actions/workflows/blender-test.yml/badge.svg)](https://github.com/ivan-perevala/lib_bhqrprt/actions/workflows/blender-test.yml)
<!-- ![Tests](https://github.com/ivan-perevala/lib_bhqrprt/actions/workflows/python-tests.yml/badge.svg) -->

<p align="center">
    <img src="https://raw.githubusercontent.com/ivan-perevala/lib_bhqrprt/main/.github/images/logo-dark.svg" alt="Logo" style="width:50%; height:auto;">
</p>

Python package designed to streamline the process of logging for Blender extension development. It provides advanced logging features such as automatic log file management, colored console outputs, and a specialized API for seamless integration with Blender.

Links:

* Documentation: [lib-bhqrprt.readthedocs.io/latest](https://lib-bhqrprt.readthedocs.io/latest/)

* Project is [available on PyPI](https://pypi.org/project/bhqrprt/):

    ```powershell
    pip install bhqrprt
    ```

© 2025 Ivan Perevala (ivan95perevala@gmail.com)
macro-gen 0.1.0
A tool to record and replay mouse and keyboard actions
Requires Python: >=3.6

# Macro Generator

A tool for recording and replaying mouse and keyboard actions.

## Features

- Record mouse movements, clicks, and keyboard inputs
- Pause and resume recording
- Generate macros to replay recorded actions
- Single execution mode (triggered by keypress)
- Loop execution mode (continuous replay)
- Pause/resume during playback
- Manage recordings and macros (list, run, remove)

## Installation

### From source

1. Clone the repository:
   ```bash
   git clone https://github.com/0xTristo/macro-gen.git
   cd macro-gen
   ```

2. Install with pip:
   ```bash
   pip install .
   ```

3. System-wide installation (requires root privileges):
   ```bash
   sudo pip install .
   ```

### Dependencies

Macro-Gen requires the following Python packages that will be automatically installed:
- pynput: For capturing and simulating keyboard and mouse inputs
- configparser: For reading configuration files

### System Requirements

- Python 3.6 or higher
- X Window System (on Linux) for mouse and keyboard control
- Administrator privileges may be required on Windows
- For Mac, accessibility permissions will need to be granted

## Quick Start

### Recording

To start recording mouse and keyboard actions:

```bash
macro-gen record
```

Controls:
- **F9**: Start/stop recording
- **F8**: Pause/resume recording
- **ESC**: Exit program

### Generating Replay Script

To generate a replay script from a recording:

```bash
macro-gen generate
```

You'll be prompted to select a recording file, choose execution mode, and configure trigger keys.

### Managing Recordings and Macros

List all recorded action files:
```bash
macro-gen list-history
```

List all generated macro scripts:
```bash
macro-gen list-macros
```

Run a specific macro:
```bash
macro-gen run macro_name
```

Remove a specific macro:
```bash
macro-gen rm-macro macro_name
```

Remove a specific recording:
```bash
macro-gen rm-recording recording_name
```

### File Locations

- Configuration: `~/.config/macro-gen/config.conf`
- Macros: `~/.local/share/macro-gen/macros/`
- Recordings: `~/.local/share/macro-gen/history/`

### Example Configuration File

```ini
[recorder]
mouse_trps = 50

[playback]
default_trigger_key = f10
default_pause_key = f8

[paths]
history_dir = history
macros_dir = macros
```

## License

MIT
jax_zero_contour 2.0.0
Find and follow a zero value contour for any 2D function written in Jax.

[![DOI](https://zenodo.org/badge/976508586.svg)](https://doi.org/10.5281/zenodo.15410802)

# Jax-Zero-Contour

Find and follow a zero value contour for any 2D function written in Jax.  This package provides a function that takes in any 2D Jax function, its gradient, and an initial guess, finds the closest zero of the function, and follows that zero contour with a fixed step size until it either:

1. closes back on itself
2. hits an end point (e.g. a discontinuity in the function)
3. reaches some maximum number of steps

See the [documentation](https://ckrawczyk.github.io/Jax-Zero-Contour/) for more details.

## Installation

```bash
pip install jax_zero_contour
```
cedalion 25.1.0
A fNIRS analysis framework
Requires Python: >=3.11

<p align="center">
    <img src="docs/img/IBS_clr_small.png" />
</p>

# cedalion - fNIRS analysis toolbox

To avoid misinterpretations and to facilitate studies in naturalistic environments, fNIRS measurements will increasingly be combined with recordings from physiological sensors and other neuroimaging modalities.
The aim of this toolbox is to facilitate this kind of analyses, i.e. it should allow the easy integration of machine learning techniques and provide unsupervised decomposition techniques for
multimodal fNIRS signals.

## Documentation

The [documentation](https://doc.ibs.tu-berlin.de/cedalion/doc/dev) contains
[installation instructions](https://doc.ibs.tu-berlin.de/cedalion/doc/dev/getting_started/installation.html) as
well as several [example notebooks](https://doc.ibs.tu-berlin.de/cedalion/doc/dev/examples.html)
that illustrate the functionality of the toolbox.
For discussions and help you can visit the [cedalion forum on openfnirs.org](https://openfnirs.org/community/cedalion/)


## Development environment

To create a conda environment with the necessary dependencies run:

```
$ conda env create -n cedalion -f environment_dev.yml
```

Afterwards activate the environment and add an editable install of `cedalion` to it:
```
$ conda activate cedalion
$ pip install -e .
$ bash install_nirfaster.sh CPU # or GPU
```

This will also install Jupyter Notebook to run the example notebooks.

If conda is too slow consider using the faster drop-in replacement [mamba](https://mamba.readthedocs.io/en/latest/).
If you have Miniconda or Anaconda you can install mamba with:
'''
$ conda install mamba -c conda-forge
'''
and then create the environment with
```
$ mamba env create -n cedalion -f environment_dev.yml
```
Please note: If this does not socceed there is another route to go:
Install the libmamba solver
'''
$ conda install -n base conda-libmamba-solver
'''
and then build the environment with the --solver=libmamba
```
$ conda env create -n cedalion -f environment_dev.yml --solver=libmamba
```

## How to cite Cedalion
A paper for the toolbox is currently in the making. If you use this toolbox for a publication in the meantime, please cite us using GitHub's  "Cite this repository" feature in the "About" section. If you want to contact us or learn more about the IBS-Lab please go to https://www.ibs-lab.com/
sbcli-test-bdev 1.0.0
CLI for managing SimplyBlock cluster


# SBCLI (SimplyBlock CLI)

Simplyblock provides a feature-rich CLI (command line interface) to deploy SimplyBlock Cluster and to manage the SimplyBlock Control plane

## Install

The CLI can be installed using pypi package [sbctl](https://pypi.org/project/sbctl/)

```
pip install --upgrade sbctl
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
The list of all the available CLI options can be here [CLI docs](./simplyblock_cli/README.md)

## SimplyBlock Web API

Web app that provides API to manage the cluster. More about this in [README.md](./simplyblock_web/README.md)


### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```
setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.

```
sudo docker compose -f docker-compose-dev.yml up --build -d
```
colav-proto 0.0.4
A package for generation, serialization and deserialization of colav protobuf messages.
Requires Python: >=3.8

# colav-proto

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

A project for generating, serializing and deserializing COLAV protobuf interfaces. Providing interfaces for generation of all the different protos required as well as different types and constants related.

-----

## Table of Contents

- [Installation](#installation)
- [Structure](#structure)
- [Usage](#usage)
- [License](#license)

## Installation

```bash
pip install colav-proto
```

## Structure

The source code in [colav_proto](https://github.com/RyanMcKeeQUB/colav-proto) is organized into the following main directories:


## Usage

Once the package has been installed into your environment, usage is simple.

### Imports

```python
```

### Sample Mission Request Creation

```python
```

### Sample Serialization

```python
serialized_msg = serialize_protobuf(mission_req_proto)
```

### Sample Deserialization

```python
deserialized_msg = deserialize_protobuf(serialized_msg)
```

## License

`colav-proto` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.