semvec/pypi-packages huggingface dataset:
symbolic-music 0.1.0
Rust library with Python bindings for symbolic music processing
Requires Python: >=3.8

# Symbolic Music

A high-performance Rust library with Python bindings for fast symbolic music format conversion, designed specifically for high performance machine learning applications. 


## Setup and Development

### Prerequisites

- **Rust**: Install from [rustup.rs](https://rustup.rs/)
- **Python 3.8+**: Required for the Python bindings
- **uv**: Fast Python package manager

### Steps

1. **Clone and navigate to the project:**
   ```bash
   git clone git@github.com:Nintorac/symbolic_music.git
   cd symbolic_midi
   ```

2. **Install dependencies:**
   ```bash
   uv sync
   ```

3. **Build the project for development:**
   ```bash
   uv run maturin develop
   ```

4. **Test the installation:**
   ```bash
   uv run python -c "import symbolic_music; print(symbolic_music.hello_world())"
   ```

## Usage

### ARIA Tokenizer - AbsTokenizer

The AbsTokenizer provides absolute time-based tokenization for MIDI data:

```python
from symbolic_music.aria import MidiDict, AbsTokenizer, normalize_midi_dict

# Initialize the tokenizer
tokenizer = AbsTokenizer()

# Load MIDI file
midi_dict = MidiDict.from_midi("path/to/your/file.mid")

# Normalize MIDI data (recommended preprocessing step)
normalized_midi_dict = normalize_midi_dict(
    midi_dict=midi_dict,
    ignore_instruments=tokenizer.config["ignore_instruments"],
    instrument_programs=tokenizer.config["instrument_programs"],
    time_step_ms=tokenizer.time_step_ms,
    max_duration_ms=tokenizer.max_dur_ms,
    drum_velocity=tokenizer.config["drum_velocity"],
    quantize_velocity_fn=tokenizer._quantize_velocity,
)

# Tokenize MIDI data to sequence
sequence = tokenizer.tokenize(normalized_midi_dict, remove_preceding_silence=False)

# Detokenize sequence back to MIDI
reconstructed_midi_dict = tokenizer.detokenize(sequence)

# Save reconstructed MIDI
reconstructed_midi_dict.to_midi().save("path/to/output.mid")
```

## Building for Production

To build wheels for distribution:
```bash
uv run maturin build --release
```

## Development Commands

- `uv sync` - Install all dependencies
- `uv run maturin develop` - Build and install for development
- `uv run maturin build` - Build wheel packages
- `uv run python -m pytest` - Run tests (when added)
smume 0.1.8
A package for Saint Martin's University Mechanical Engineering students to create a custom flowchart for their academic plan.
Requires Python: <4.0,>=3.12

# SMUME: Saint Martin's University Mechanical Engineering Curriculum Planner

SMUME is a Python-based tool for visualizing and managing Mechanical Engineering degree plans at Saint Martin’s University. It supports students, advisors, and faculty by offering a flexible and programmable way to define curricula, create student-specific academic plans, and generate dependency-aware flowcharts.

---

## 🔧 Features

### For Students & Advisors
- **Student Plans**: Generate a personalized academic plan from a catalog year and start term (e.g., Fall 2024).
- **Prerequisite Checking**: Automatically detect and highlight missing or improperly sequenced prerequisites, corequisites, and concurrent prerequisites.
- **Flowchart Generation**: Render academic plans as dependency graphs with color-coded course categories, term clustering, and visual indicators for completion and violations.

### For Faculty
- **Curriculum Definition**: Easily define new curriculum structures using Python—no GUI builder required.
- **Generic Plans**: Assign default term-by-term layouts for catalog years.
- **Extensibility**: Add metadata like full course names, notes, and categories (Core, Math/Science, GE, ME, Other).

---

## 📁 Project Structure

- `smume/curricula/` – Defines catalog year curricula (e.g. `_2024_25.py`)
- `smume/generic_plans/` – Maps courses to default terms
- `smume/student_plan.py` – Logic for student-specific academic planning
- `smume/graph_builder.py` – Graphviz-based flowchart generation

---

## 📌 Notes

- Term formats are flexible: both `Fall` and `F`, and `2025` or `25` are valid.
- Curriculum and plan objects are fully programmable—ideal for integration into other workflows or GUIs.
- Graphs highlight completed courses (gray, checkmarks), unmet dependencies (red), and visually group courses by academic term.

---

## 📚 Example

<img src="img/2024-25.svg" width="100%" />

---

## 👥 Who It's For

- **Students**: Visualize and adjust your academic plan semester by semester.
- **Advisors**: Confirm course sequencing and verify prerequisite compliance.
- **Faculty**: Define and revise curriculum plans in code with minimal friction.

---

## 🛠️ Future Work

- Web frontend
- Support for electives and transfer credit
- Improved drag-and-drop UI for plan adjustment

---

## 🚀 Quick Start

Install the package with pip:

```bash
pip install smume
```

For development:

```bash
git clone https://github.com/YOUR_USERNAME/smu-curriculum-flowcharts.git
cd smu-curriculum-flowcharts
poetry install
```

Usage examples:

```bash
# Clone and install
poetry install

# Example: generate a graph for the 2024–25 curriculum
poetry run python scripts/generate_generic_graph.py 2024-25

# Example: create and render a student plan
poetry run python scripts/generate_student_graph.py 2024-25 --start-year 2024 --start-term Fall
```

---

MIT Licensed · Developed by Dr. Rico Picone and collaborators
keyslide 0.7
Encrypt text by shifting keys on the QWERTY keyboard.

# Keyslide

## Description

**Keyslide** is a Python package offering a playful approach to text encryption and decryption—think Caesar cipher, but mapped to the physical QWERTY keyboard! Shift letters left or right across keyboard rows, either programmatically or via command line. Useful for simple obfuscation, puzzles, or just for fun.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Features](#features)
- [Contributing](#contributing)
- [License](#license)

## Installation

Install from PyPI:

```bash
pip install keyslide
```

## Usage

### Python API

```python
from keyslide import encrypt, decrypt

text = "Hello, World!"
key = 2  # Shift right by 2 keys

cipher = encrypt(text, key)
print(cipher)  # Encrypted text

plain = decrypt(cipher, key)
print(plain)   # Should print: Hello, World!
```

### Command Line

Encrypt:

```bash
keyslide.encrypt "Hello, World!" 1
```
_Output:_  
`Jr;;p. Ept;f@`

Decrypt:

```bash
keyslide.decrypt "Jr;;p. Ept;f@" 1
```
_Output:_  
`Hello, World!`

**Notes:**
- Negative keys shift left: `keyslide.encrypt "Hello, World!" -1`
- Unknown characters (not on QWERTY) are unchanged.

## Features

- 🔤 **Keyboard-based encryption**: Shift letters based on their QWERTY row positions.
- 🛠️ **Easy API**: Use `encrypt()` and `decrypt()` in your Python code.
- 💻 **CLI ready**: Quick command-line access with `keyslide.encrypt` and `keyslide.decrypt`.
- ➡️ **Customizable key**: Shift any number of steps, positive (right) or negative (left).

## Contributing

Contributions are welcome!  
- Open issues for bugs or feature requests.
- Submit pull requests for improvements.

## License

This project is licensed under the MIT License.
takit 0.1.0
Technical analysis library for financial data.
Requires Python: >=3.10

# takit

[![Ruff][ruff-badge]](https://github.com/astral-sh/ruff)
[![PyPI][pypi-badge]](https://pypi.org/project/takit/)
[![Python versions][python-versions-badge]](https://github.com/ivarurdalen/takit)
[![MIT License Badge][license-badge]][license]

Technical analysis library for Python.

## Definitions

The library is structured around the following definitions:

- **Indicator**: Produces a continuous value based on the input data to indicate trend, momentum, volatility, etc.
- **Signal**: Produces a discrete value like 1, 0, -1 to signal trend change, overbought, oversold, etc.

These functions are located in the different subpackages `indicators` and `signals`.

## Features

- Validation of input pandas Series / DataFrames to indicators and signals
- Ready to use signal calculations based on the indicator values

## Installation

```bash
pip install takit
# or with optional group `data` for fetching data
pip install "takit[data]"
```

## Usage

To use the following example you need to install the library with the optional group `data`.

```python
import pandas as pd

import takit

# Fetch data
ohlc = takit.data.fetch_data(
    data_source="binance", ticker="BTCUSDT", interval="1d", start="2023-01-01", end="2025-07-01"
)

# Calculate indicators
df = pd.concat(
    [
        ohlc,
        takit.bb(ohlc["close"], include_width=True, include_percentage=True),
        takit.wvf(ohlc),
        takit.rsi(ohlc["close"]),
    ],
    axis=1,
)

print(df.tail(40))
```

[ruff-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
[license]: ./LICENSE
[license-badge]: https://img.shields.io/badge/License-MIT-blue.svg
[python-versions-badge]: https://img.shields.io/pypi/pyversions/takit.svg
[pypi-badge]: https://img.shields.io/pypi/v/takit
pickaxe-mcp-open-alex 0.1.4
A fully open catalog of the global research system
Requires Python: >=3.12

# PXE OpenAlex

Provides access to the OpenAlex API

## Installation

uvx:

```
{
  "mcpServers": {
    "pickaxe-mcp-open-alex": {
      "command": "uvx",
      "args": [
        "pickaxe-mcp-open-alex@latest"
      ]
    }
  }
}
```
pytplot-mpl-temp 2.2.79
A python version of IDL tplot libraries
Requires Python: >=3.9
Keywords: tplot, maven, lasp, IDL, spedas

[![build](https://github.com/MAVENSDC/PyTplot/workflows/build/badge.svg)](https://github.com/MAVENSDC/PyTplot/actions)
[![DOI](https://zenodo.org/badge/68843190.svg)](https://zenodo.org/badge/latestdoi/68843190)

# pytplot - matplotlib version

Pytplot is a python package which aims to mimic the functionality of the IDL "tplot" libraries for analysis and visualization of heliophysics time series data.

This is the modified (matplotlib) version of the pytplot package. This version is used in the pyspedas project, which is a python rewrite of the IDL SPEDAS software.

Pytplot can be used in python scripts, or interactively through IPython and the Jupyter notebook.


## How It Works

Data is read into pytplot by using the "store_data" command.  Each dataset is assigned a unique name by the user.

The data is stored in a "tplot variable" class.  The tplot variables contain all the information required to create a plot of the dataset.  The details of the plot, such as axis titles, types, line colors, etc, can be changed through other functions in pytplot.


## Install Python

You need to install Python 3.8 or later.


## Install pytplot

Open up a terminal, and type::

	pip install pytplot-mpl-temp

This will install pytplot and all of it's dependencies.

Since this version is designed to be used with pyspedas, you can also install it by installing pyspedas:

	pip install pyspedas

To update the package to the latest released version, use:

	pip install pytplot-mpl-temp --upgrade
	pip install pyspedas --upgrade


## Running pytplot

To start using pytplot in a similar manner to IDL tplot, start up an interactive environment through the terminal command:

	ipython

or, if you prefer the jupyter interactive notebook:

	jupyter notebook

then, just import the package by typing the command:

	import pytplot


## Contact

If you have any suggestions or notice any problems, don't hesitate to contact Jim Lewis: jwl@ssl.berkeley.edu

The original version of pytplot was developed by Bryan Harter: harter@lasp.colorado.edu


## License

Released under the MIT license.


## Additional Information

PySPEDAS: https://github.com/spedas/pyspedas