semvec/pypi-packages huggingface dataset:
robustranking 0.2
Package for ranking algorithms
Requires Python: >=3.9

# Robust Ranking

!Warning! This package is currently still under heavy development. 

A Python package for robust ranking. 

## Installation

```
pip install git+https://github.com/jeroenrook/robustranking
```

## Example usage

```
from robustranking.benchmark import Benchmark
from robustranking.comparison import BootstrapComparison

# Load benchmark data
benchmark = Benchmark()
benchmark.from_pandas(df, "algorithm", "instance", "pqr10")
print(benchmark.show_stats())

comparison = BootstrapComparison(benchmark,
                                 alpha=0.05,
                                 minimise=True,
                                 bootstrap_runs=10000,
                                 aggregation_method=np.mean)

robust_ranks = comparison.get_ranking()

print(robust_ranks)

```
magvar 1.1
Magnetic variation (aka declination) for aviation navigation
Requires Python: >=3.1

# The magvar module

This module provides the function

	`magnetic_variation(date, latitude, longitude, elevation)`

`date` must be a float - the Julian date.  Example: 2022.1 is in February.

`latitude` is in radians, positive for north, negative for south.

`longitude` is in radians, positive for east, negative for west.

`elevation` is in meters.

This returns what the geo-scientists would call 'declination' but what
aviators call 'magnetic variation'.

The result is in radians, and is negative for EAST "east is least" and
positive for WEST.

For example:

```
>>> from geomag import magnetic_variation
>>> from math import degrees, radians

>>> degrees(magnetic_variation(2022.05,
                               radians(25.7953611),
                               radians(-80.2901158),
                               3)
6.9474...
```

This shows the magnetic variation for the Miami Internation Airport (KMIA)
as 6.9 degrees WEST, which matches what the sectional chart for January 2022.



## Building from COF files

This distribution includes WMM2010.COF, WMM2015.COF, WMM2020.COF, and
WMM2025.COF.

These files were downloaded from the National Centers for Environmental
Information (NCEI), formerly known as the National Geophysical Data Center
(NGDC).

	[NCEI](https://www.ncei.noaa.gov/products/world-magnetic-model)

The file `wmm.c` contains static data compiled from these .COF files.

To generate the file from scratch, use the `compile-cof' script:

```
$ ./compile-cof WMM2010.COF WMM2015.COF WMM2020.COF WMM2025.COF >wmm.c
```

This incorporates all models, so you can get the magnetic variation
for any latitude and longitude from any date from January 1, 2010.

If you're tight on space, and only need the current magnetic model:

```
$ ./compile-cof WMM2025.COF >wmm.c
```


## Testing the Software

The `test` subdirectory has test values from the NCEI.

Test the Python:

```
$ cd test
$ python3 test_values.py *.txt
```

Test the C code:

```
$ cd test
$ make
$ ./test_magvar *.txt
$ make clean
```
xgcondb-driver 0.1.0
XuGu Database Python Driver
Requires Python: <3.12,>=3.6
Keywords: DB, XuGu, xgcondb

# xgcondb

<a href="#"><img src="https://flat.badgen.net/badge/os/win-x86_64/cyan?icon=windows" /></a>
<a href="#"><img src="https://img.shields.io/badge/os-linux_x86_64-white?style=flat-square&logo=linux&logoColor=white&color=rgb(35%2C189%2C204)" /></a>
<a href="#"><img src="https://img.shields.io/badge/os-linux_arm64-white?style=flat-square&logo=linux&logoColor=white&color=rgb(35%2C189%2C204)" /></a>
<a href="#"><img src="https://flat.badgen.net/badge/python/3.6|3.7|3.8|3.9|3.10|3.11/blue" /></a>
<a href="#"><img src="https://flat.badgen.net/badge/pypi/v1.0.0/blue" /></a>
<a href="https://pepy.tech/project/xgcondb" ><img src="https://static.pepy.tech/badge/xgcondb" /></a>
<a href="#" ><img src="https://flat.badgen.net/badge/test/pass/green?icon=github" /></a>

XuGu Database Python Driver

虚谷数据库Python接口驱动

### 安装

```bash
pip install xgcondb -i https://pypi.tuna.tsinghua.edu.cn/simple --trusted-host=pypi.tuna.tsinghua.edu.cn
```

### 使用
```python
import xgcondb as xg


def connect():
    try:
        conn = xg.connect(host='127.0.0.1',
                          port=5138,
                          database='SYSTEM',
                          user='SYSDBA',
                          password='SYSDBA')
        conn.close()
        print('Succeeded!')
    except Exception as e:
        print('Failed!', e)


if __name__ == '__main__':
    connect()
```

具体使用参考链接 [Python标准接口开发指南](https://help.xugudb.com/documents/python-development-guide/program-guide-01)
pimidipy 0.1.2.post4
pimidipy MIDI processing library
Requires Python: >=3.9

# pimidipy

`pimidipy` is a Python library developed by [**Blokas**](https://blokas.io/) for Linux ALSA that makes interacting with MIDI devices extremely simple, taking care of all the low-level details for you.

Check out the full online documentation of `pimidipy` at https://blokas.io/pimidi/docs/pimidipy/.

If you're looking to expand your Raspberry Pi's MIDI capabilities, check out [**Pimidi**](https://blokas.io/pimidi/) HAT by Blokas. Pimidi is a hardware add-on that adds 2 MIDI inputs and 2 MIDI outputs to your Raspberry Pi, and it can be stacked up to 4 units high for even more MIDI I/O.

## Features

The `pimidipy` library offers:

* A very simple API for working with MIDI data.
* Automatic handling of device disconnects and reconnects.
* Available as a [**Patchbox OS**](https://blokas.io/pimidi/docs/pimidipy-patchbox-module/) module by Blokas for easy auto-run setup.

## A Quick Example

Here's a very short example of how scripting using `pimidipy` would look like. This works seamlessly with **Pimidi** hardware on Raspberry Pi:

```py3
#!/usr/bin/env python3
from pimidipy import *
pimidipy = PimidiPy()

input = pimidipy.open_input('pimidi0:0')   # Pimidi IN A
output = pimidipy.open_output('pimidi0:1') # Pimidi OUT B

def forward(event):
    print(f'Forwarding event {event} from {input.name} to {output.name}')
    output.write(event)

input.add_callback(forward)

pimidipy.run()
```

This is pretty much the base foundation upon which you may build your custom MIDI processing. See the online [API Reference](https://blokas.io/pimidi/docs/pimidipy-reference/) for details on every API.

## Contributing

We warmly invite the open-source community to help us improve and extend the `pimidipy` library. Whether you want to add new features, fix bugs, or improve documentation, we welcome your contributions!

### Getting Started
1. **Install prerequisites** (if not already installed):
   Make sure `pip` for Python 3 is available on your system. You can install it using:
   ```bash
   sudo apt update
   sudo apt install python3-pip
   ```

2. **Fork** the repository and clone it to your local machine:
   ```bash
   git clone https://github.com/your-username/pimidipy.git
   cd pimidipy
   ```

3. **Install the library locally** in editable mode using `pip`:
   ```bash
   pip3 install --break-system-packages -e .
   ```

   This allows you to make changes to the library and test them immediately without needing to reinstall it.

4. **Make your changes** and test them locally.

5. **Submit your changes** as a pull request.

6. Join the conversation in our [community forums](https://community.blokas.io/c/pimidi/26) to discuss ideas, get support, or share your projects.

Your contributions will help make `pimidipy` even better for everyone. Thank you for being part of the Blokas community!
python-cbibs 0.0.3
Python wrapper for interacting with the CBIBS API
Requires Python: >=3.8

# python-cbibs
Python module to interact with the CBIBS API.

- [CBIBS](https://www.buoybay.noaa.gov/)
- [API Documentation](https://www.buoybay.noaa.gov/data/api)

## Installation ##
To get the package, execute:
```shell
pip install python-cbibs
```

## Usage ##
View the CBIBS API documentation on [CBIBS](https://www.buoybay.noaa.gov/data/api). By default the response output will 
be in JSON format. If you would like XML, configure your instance to use XML (see example below).

Then set up an CBIBS instance, set your API key, and make any available requests.

```python
from cbibs.buoy import Cbibs

# Create CBIBS instance
buoy = Cbibs(api_key='API_KEY')
buoy_xml = Cbibs(api_key='API_KEY', response_format='xml')

# Get all current readings from all stations
latest_all = buoy.get_current_readings_all_stations()

# Get the latest station readings from AN
station_readings = buoy.get_station_readings('AN')

# Query a specific station with parameters
station_variable = buoy.query_station(
    station_name="AN",
    start_date='2020-04-01T10:00:00z',
    end_date='2020-04-01T20:00:00z',
    variable="sea_water_temperature"
)
```
yabp 0.1.1
Yet another batch processor. Small python module to do batch processing. Use this when you want something lightweight and quick to setup. For usecases when writing batch processing boilerplate code is too repetitive and boring and Apache Beam/Ray is overkill
Requires Python: >=3.6

# YABP - Yet another Batch Processor
I wrote this because I needed a generic way to process large data (often in the form of lists) in batches. 
Other libraries are generally more suited for complexer problem and often require more effort to setup and is 
often overkill for small projects. Also provides a decorator for even more simple usage.

Another library that is similar and also accomplish the same goal: https://github.com/gillespied/batch_please/tree/main

This module provides functionality for processing data in batches with options for progress tracking, retries, and saving results to a file. It includes a `BatchProcessor` class and a `batch_processor_decorator` for easy integration into your projects.

## Installation
```
pip install yabp==0.1
```

## Usage

### BatchProcessor Class

1. **Import the BatchProcessor:**

   ```python
   from batchprocessor import BatchProcessor
   ```

2. **Define a function to process each batch:**

   ```python
   def process_batch(batch):
       # Your processing logic here
       return {"processed": batch, "status": "success"}
   ```

3. **Initialize the BatchProcessor:**

   ```python
   processor = BatchProcessor(
       iterable=your_data,
       batch_size=5,
       progress=True,
       save_to_file="output.json",
       retries=2,
       retry_delay=1.0,
   )
   ```

4. **Process the batches:**

   ```python
   results = processor.process(process_batch)
   print("Final Results:", results)
   ```

### Decorator version

1. **Import the decorator:**

   ```python
   from batchprocessor import batch_process
   ```

2. **Decorate your batch processing function:**

   ```python
   @batch_process(
       batch_size=5,
       progress=True,
       save_to_file="output_decorator.json",
       retries=2,
       retry_delay=1.0,
   )
   def process_batch(batch):
       # Your processing logic here
       return {"processed": batch, "status": "success"}
   ```

3. **Call the decorated function with your data:**

   ```python
   process_batch(your_data)
   ```

## Features

- **Batch Processing:** Process data in specified batch sizes.
- **Progress Tracking:** Optionally display a progress bar.
- **Retries:** Automatically retry failed batch processing with a specified delay.
- **Save Results:** Save batch results to a JSON file.