semvec/pypi-packages huggingface dataset:
platingsoc 0.0.1
For find plating SoCs in anode hald cells
Requires Python: >=3.8

# platingSoC

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

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install platingsoc
```

## License

`platingsoc` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
dasp-stacker 0.1.1
Dimensionally aligned signal projection library
Requires Python: >=3.9
Keywords: signal processing,signal,visualization

# Dimensionally Aligned Signal Projection (DASP)

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


## Summary
Dimensionally aligned signal projection (DASP) algorithms are used to analyze fast Fourier transforms (FFTs) and generate visualizations that help focus on the harmonics for specific signals. At a high level, these algorithms extract the FFT segments around each harmonic frequency center, and then align them in equally sized arrays ordered by increasing distance from the base frequency. This allows for a focused view of the harmonic frequencies, which, among other use cases, can enable machine learning algorithms to more easily identify salient patterns. This work seeks to provide an effective open-source implementation of the DASP algorithms as well as functionality to help explore and test how these algorithms work with an interactive dashboard and signal-generation tool.

The DASP library is implemented in Python and contains four types of algorithms for implementing these feature engineering techniques: fixed harmonically aligned signal projection (HASP), decimating HASP, interpolating HASP, and frequency aligned signal projection (FASP). Each algorithm returns a numerical array, which can be visualized as an image. For consistency FASP, which is the terminology used for the short-time Fourier transform, has been implemented as part of the library to provide a similar interface to the STFT of the raw signal. Additionally, the library contains an algorithm to generate artificial signals with basic customizations such as the base frequency, sample rate, duration, number of harmonics, noise, and number of signals.

Finally, the library provides multiple interactive visualizations, each implemented using IPyWidgets and work in a Jupyter environment. A dashboard-style visualization is provided, which contains some common signal-processing visual components (signal, FFT, spectogram) updating in unison with the HASP functions (see Figure 1 below). Seperate from the dashboard, an independent visualization is provided for each of the DASP algorithms as well as the artifical signal generator. These visualizations are included in the library to aid in developing an intuitive understanding how the algorithms are affected by different input signals and parameter selections.

A detailed breakdown of how these algorithms work can be seen in 'example/algorithm_walkthrough'

## Features
* Dashboard-style interactive visualization (Figure 1)
* Numerical array output for each algorithm
* Interactive visualization for FASP only
* Interactive visualization for HASP algorithms (selecting one at a time)
* Interactive visualization for sine wave generation

## Examples

An example of each feature available, and how to use them, can be seen in 'examples/dasp_example_notebook.ipynb'

## Installation
```python
pip install dasp-stacker
```

## Citation
bitsidy-sdk 1.0.0
A Python SDK for Bitsidy API
Requires Python: >=3.8

# Bitsidy Python SDK

Bitsidy SDK is a toolkit for integrating Bitsidy's cryptocurrency invoice services into your Python projects. Whether you are using npm for dependency management or prefer manual inclusion, this SDK is designed for easy integration.

## Project Structure

- `bitsidy_sdk/sdk.py`: The core SDK file.
- `examples/example.py`: An example script demonstrating SDK usage.
- `examples/callback.py`: An example script demonstrating how to handle received callback data.
- `pyproject.toml`: The configuration file for packaging tools.

## Requirements

The dependencies are specified in the __requirements.txt__ file. To install them manually, run:

```bash
pip install -r requirements.txt
```

To run the `examples/callback.py` example script, which demonstrates handling callback data, the following specific requirements must be met:

```bash
pip install flask
```

## Installation

### Using PyPi

To install via PyPi, run:

```bash
pip install bitsidy-sdk
```

Then, require the SDK in your script:

```python
from bitsidy_sdk import BitsidySDK
```

### Manual Installation

1. Download or clone the Bitsidy SDK repository.
2. Place the SDK folder in your project directory.
3. In your Python file, use require to include the SDK. Assuming the SDK folder is named bitsidy_sdk and it's placed in your project's root directory, the code to include it would be:

```python
from src.bitsidy_sdk import BitsidySDK
```

## Usage

Refer to examples/example.py for a practical demonstration on using the Bitsidy SDK to create invoices and handle responses. For understanding how our server communicates invoice status updates, consult examples/callback.py.

## Contributing

Contributions to the Bitsidy SDK are welcome. Please ensure that your code adheres to the project's coding standards and include tests for new features or bug fixes.

## License

This project is licensed under the GPLv3.

For more information and updates, visit the project repository.
gronk-gclark0812 0.0.1
Quality of content LLM application infrastructure
Requires Python: >=3.8

# Gronk Overview

## 🚨 Problem

The next generation of LLM application infrastructure will be software that makes LLM apps generate higher quality content. However, the state of the art for implementing quality of content content requires deep, specific knowledge of the following techniques:
1. A way to verify the quality of dynamically generated content at runtime
2. A way to improve the performance and sourcing of RAG applications as compared to what you get out of the box
3. A way to automatically optimize prompts at runtime given *i* max cycles or *t* max runtime
4. Create and string together thought chains (CoT) and thought trees (ToT).
5. Implement an [active CoT]([url](https://arxiv.org/abs/2302.12246)) toolkit 
6. Use specific CoT/ToT technique that improve content beyond what you get out of the box
7. Build and mantain a debugging app for the LLM application to iterate and improve content

## 💡 Solution

To solve these problems, developers need access to a robust toolkit that's **easy to use and understand** and **performs significantly better than vanilla implementations**. This toolkit should allow developers to solve these problems in just a few lines of code, in a way that's easy for them to explain to their team.

## 🤯 The Next Generation of LLM Application Infrastructure

Currently, here's the state of play for LLM application infrastructure

| Software | |
| ------------ | ----------- |
| Application | Above the fold |
| **Quality of Content Infrastructure** | this repo |
| **Quality of Life Infrastructure** | RAG, prompt chains, prompt lifecycle management, agents, etc. |
| **Core Functionalities** | vector databases, synthetic data, similarity search, LLM libraries, etc. |
| LLM(s) | Below the fold |

Each of these layers provides critical functionalities for LLM developers. The Quality of Content layer is just now being discovered as something that's needed by developers, and there exists an opportunity to build and deploy this level of infrastructure in a way that will grately benefit the development community.
stlrcore 1.0.1
Create and process audio transcriptions with word timings
Requires Python: >=3.11

# stlr-core

## Overview

`stlrcore` is a toolkit designed as a wrapper to [`whisper-timestamped`](https://github.com/linto-ai/whisper-timestamped) and [`stable-whisper`](https://github.com/jianfch/stable-ts) which aims to provide a more convenient interface between them. It serves as the foundation for [`stlrapps`](https://github.com/lilellia/stlrapps) (a suite of tools for automatic subtitle generation, etc.)

## Installation

## Usage

```python
from pathlib import Path
from typing import Iterator

from stlrcore import Transcription
from stlrcore.transcribe import WordTiming, Segment

# create a transcription from an audio file
transcription = Transcription.from_audio("path/to/audio.ext")

# Transcription objects are iterable, and they iterate over WordTimings
word_timings: Iterator[WordTiming] = iter(transcription)

# For just the actual words themselves:
words: list[str] = transcription.words
text: str = str(transcription)

# You can also create Segments, which are consecutive words without pauses.
segments: Iterator[Segment] = transcription.get_segments(tolerance=0.0)

# Find the timing for a particular substring of words
segment: Segment = transcription.get_fragment(fragment="...")

# Transcriptions can be exported as json, Audacity cue, or Audition cue
transcription.export(filestem="transcription", mode="json")      # -> transcription.json
transcription.export(filestem="transcription", mode="audacity")  # -> transcription.txt
transcription.export(filestem="transcription", mode="audition")  # -> transcription.csv

# Similarly, Transcriptions can be created from these exported files:
transcription = Transcription.from_json(Path("transcription.json"))
transcription = Transcription.from_audacity_cue(Path("transcription.txt"))
transcription = Transcription.from_audition_cue(Path("transcription.csv"))

# A convenience wrapper around these is also provided:
# `mode` should be one of "audio", "json", "audacity", "audition"
transcription = Transcription.load(Path(...), mode=...)

# Because Transcriptions are constructed out of words, not as segments, direct export
# to SRT is not supported. While it may be preferable to manually (or otherwise) determine
# the proper segment split points, the following can be used:
Transcription.write_srt(segments=transcription.get_segments(), dest="transcription.srt")
```