semvec/pypi-packages huggingface dataset:
muoblp 1.0.3
Implementation of multi objective linear programming module
Requires Python: >=3.11

# MUlti OBjective Linear Programming (MUOBLP)

This package contains core model used to define MUOB linear programs and some utility methods.

---

### Installation
See  [PyPi](https://pypi.org/project/muoblp/) project page for details

```shell
pip install muoblp
```

### Example
Example instance of PB election defined as multi objective linear program [source](./example/define_pb.py)
ynab-csv-converter 1.0.5
Convert bank record CSV files in various formats to YNAB CSV format
Requires Python: <4,>=3.11

# YNAB CSV Converter

Converts bank record CSV files in various formats to YNAB CSV format.

Any previously converted files will be looked up so that a converted
export only contains unique transactions with respect to already
converted exports.

## Installation

```sh
pipx install ynab-csv-converter
```

## Usage

Usage: `ynab-csv-converter [options] FORMULA INFILE...`

## Formula

```yml
format: sparekassen
outpath: /home/andsens/converted
archivepath: /home/andsens/archive
outprefix: sparekassen-euro
factor: 7.45
```

All settings except `factor` are mandatory.
The above formula looks for converted files in `/home/andsens/converted/sparekassen-euro-[daterange]`
and removes transactions from the inputfiles that already exist in those converted
files.
All amounts are multiplied by 7.45 (EUR -> DKK).
Once converted from "sparekassen" format to "ynab" format,
the transactions are written to `/home/andsens/converted/sparekassen-euro-[daterange]`,
while the original file is archived at `/home/andsens/archive/sparekassen-euro-[daterange]`.

The `daterange` corresponds to the dates of the latest and earliest transaction
(in that order, so that newest exports are sorted last).

## Supported formats

- DanskeBank (key: danskebank)
- Sparekassen (key: sparekassen)
- Lån & Spar (key: laanspar)
- Nordnet (key: nordnet)
- HypoVereinsbank (key: hypovereinsbank)
- SaxoTraderGo Account Statement (key: saxotradergo)
proseka 0.1.0
A WIP API wrapper for Hatsune Miku: Colorful Stage! global servers.
Requires Python: >=3.12

# Proseka
[![Athena Award Badge](https://img.shields.io/endpoint?url=https%3A%2F%2Faward.athena.hackclub.com%2Fapi%2Fbadge)](https://award.athena.hackclub.com?utm_source=readme)  
A WIP API wrapper for the game Hatsune Miku: Colorful Stage (Global Server). Currently has very limited functionality outside of general account creation and maintenance. 

## Installation
~~`python -m pip install proseka`~~ (soon)
## Installation from source
1. Clone the repository  
`git clone https://github.com/tailhaver/proseka`
2. Navigate to the created folder  
`cd proseka`
3. Install the plugin  
`pip install .`
## Building from source
### Prerequisites
 - [uv](https://docs.astral.sh/uv/getting-started/installation/)  
### Install Instructions
1. Clone the repository  
`git clone https://github.com/tailhaver/proseka`
2. Navigate to the created folder  
`cd proseka`
3. Install the plugin  
`uv build`

## Features
### Functional
- [x] Account creation and login
- [x] Transfer ID creation and validation
- [x] Account name, description, and title updates
- [x] Area conversation and story reading
- [x] Account lookup by ID and friend requests
- [x] Login bonus claims
- [x] Present opening
### Partially Implemented
- [ ] Card training and mastery (no skill up, no validation)
- [x] Event information (self only)
- [ ] Event shop purchases (no validation)
- [ ] Green room claims (no validation or easy usage)
- [ ] Stamp and costume purchases (no validation)
### Planned Features
- [ ] (!!) Sekai Client to wrap API requests (!!)
- [ ] (!!) Better API method documentation (!!)
- [ ] Area item purchases
- [ ] Energy restore (items and crystals)
- [ ] Event leaderboards
- [ ] Friend request listing and accepting
- [ ] Gacha listing and pulling
- [ ] Live show playback
- [ ] Song and cover purchases
- [ ] Team construction and modification
- [ ] Virtual live attendance

## why?
i am so fucking autistic. is that good enough, athena reviewer?  
in all seriousness, this has been something ive wanted to make (or been trying to make!) for over 3 years now. back in 2023-2024, i tried to manually extract the encryption keys from the game apk. lets just say im very bad at that. worlds best compsci major here!  
[when the global server api keys were finally leaked in late 2024](https://github.com/mos9527/sssekai/issues/8), i immediately begun chipping away at reverse engineering the api. after over a year, four entire codebase rewrites, multiple bans, and tens of hours banging my head against a wall, we're finally here. there is a _heavy_ emphasis on this being a WIP, since i wanted to publish this before the [hack club athena](https://award.athena.hackclub.com/) deadline. 

## how?
[http toolkit](https://httptoolkit.com/), wsa, and a dream. two dreams actually the first dream is to look like saki tenma in real life.  
ive had so many sleepless nights making this stupid taptap game wrapper. i have no clue how im alive. i did get to learn how to make my own api wrapper though! ive experimented with it a bit before (hyperion, an abandoned hypixel api), but never to this extent.
polars-darwin-core 4.1.0
Helpers for working with Darwin Core (DwC) CSVs using Polars.
Requires Python: >=3.10
Keywords: biodiversity, csv, darwin-core, gbif, polars

# polars-darwin-core

Helpers for working with [Darwin Core](https://dwc.tdwg.org/) CSV data using [polars](https://pola.rs/).

## Usage

### Reading a single Darwin Core CSV file

```python
from polars_darwin_core import DarwinCoreLazyFrame

lf = DarwinCoreLazyFrame.from_csv("occurrence.csv")
print(lf.collect())
```

### Working with Darwin Core Archives (DwC-A)

```python
import polars as pl
from polars_darwin_core import DarwinCoreLazyFrame

# Path to an unpacked Darwin Core Archive directory (containing meta.xml)
archive_path = "path/to/dwc/archive"

# Load the core file from the archive
lf = DarwinCoreLazyFrame.from_archive(archive_path)

# Work with the data
df = lf.filter(pl.col("kingdom") == "Animalia").collect()
print(df)
```

## Development

```shell
# Create a virtualenv however you prefer, then:
pip install -e .[dev]

# Run the test-suite
python -m unittest
```

The project follows the standard [PEP 517](https://peps.python.org/pep-0517/) build flow via [Hatch](https://hatch.pypa.io/):

```shell
python -m build    # create sdist and wheel in ./dist/
```
spear-python 0.1.1
SPEAR: Structured Primitives for Efficient Architecture Research
Requires Python: >=3.10
Keywords: cuda, kernels, linear-algebra, machine-learning, pytorch

<p align="center">
  <img width=500 alt="Spear Logo" src="https://raw.githubusercontent.com/RadicalNumerics/assets/refs/heads/main/svg/spear-logo.svg" />
</p>


SPEAR is a collection of kernels for AI model architectures developed by Radical Numerics.


## Installation

You may use PyPI to install SPEAR:

```bash
pip install spear-python
```

Note that it will take few minutes to compile kernels for your specific GPU architecture.


You may also install it locally using the following method to install the package in development mode:

```bash
git clone https://github.com/radicalnumerics/spear.git && cd spear # clone the repository
uv venv && source .venv/bin/activate # virtual env with uv (recommended)
uv pip install -e '.[dev]' # install in development mode
```


### Caching

We use `ccache` by default. To use it and enable faster compilation (see explanation on the [vLLM docs](https://docs.vllm.ai/en/latest/getting_started/installation/gpu.html#set-up-using-python-only-build-without-compilation:~:text=%2De%20.-,Tip,-Building%20from%20source)), run:
```bash
CCACHE_NOHASHDIR="true" uv pip install --no-build-isolation -e '.[dev]'
```


## Quick Start

```python
import torch
from spear.nn.phalanx import Phalanx

device = "cuda:0" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16

dim = 512  # Must be divisible by 16 (head_dim is fixed at 16)
length = 128
batch_size = 1024
layer = Phalanx(dim=dim, length=length, dtype=dtype).to(device)

x = torch.randn(batch_size, length, dim, dtype=dtype, device=device)
y = layer(x)
print(f"Input: {x.shape} -> Output: {y.shape}")
```

### Development

We include pre-commit hooks for linting and formatting (Python, C++, CUDA). To install:

```bash
uv run pre-commit install
```

To run (note they will be run automatically on commit, so not necessary to run manually):

```bash
uv run pre-commit run --all-files
```

To run tests

```bash
uv run pytest
```

## Structure

```
csrc/        # kernels: CUDA/C++ or other DSLs
spear/
├─ ops/      # low-level wrappers per op family
│  └─ <op>/
└─ nn/       # layers built from ops (parametrized)
   └─ <layer>/
```


## Target Architectures

Currently supported hardware includes compute capabilities 9.0 (Hopper) and 10.0 (Blackwell).

| Kernel Name       |  (NVIDIA) sm9.0 |  (NVIDIA) sm10.0 |  (NVIDIA) sm10.3 |
| ----------------- | :-----: | :-----: | :-----: |
| `swr.btp.fwd.bf16.bdl.hd16-bl16.sm90` | ✔︎ |  ~ |  ⛔|
| `swr.btp.bwd.bf16.bdl.hd16-bl16.sm90`  | ✔︎ | ~ |  ⛔ |

* ✔︎: optimized
* ~: working but not fully optimized
* ⛔: not available


---

<p align="center">
  <img width=350 alt="Radical Numerics Logo" src="https://raw.githubusercontent.com/RadicalNumerics/assets/refs/heads/main/svg/rn-logo-desktop-vector-animated.svg" />
</p>