semvec/pypi-packages huggingface dataset:
chafe 1.0.0
Encrypts and decrypts files using a pass phrase.
Requires Python: >=3.8
Keywords: encrypt, decrypt, chacha

A CHAcha File Encryptor
=======================

This Python package provides tools for encrypting and decrypting files with
Daniel Bernstein's ChaCha20 stream cipher, using a key derived from a pass
phrase. Encrypted files include a Poly1305 authentication tag to detect
tampering with an encrypted file.

Warning
-------

This is still a work in progress, published here for testing only.  Do not use
it for anything important.  The file formats and encryption algorithms are
subject to change, which could leave you with encrypted files that you cannot
decrypt.

Installation
------------

Install this package with pip:

``python3 -m pip install --pre chafe``

The pypi package name is "chafe".  The python module installed with
this command is named "chacha".  The --pre option is needed because
the current version of this package is a pre-release.

Usage  
----- 
The package provides two entry points named encrypt and decrypt. That
means that if this module is in your Python path then the module can
be used as follows:

To encrypt a file named myfile:

 ``% python3 -m chacha.encrypt myfile``

You will be prompted for a password, and an encrypted file named
*myfile.cha* will be created.  The password will be visible until the
encryption is finished, then erased.  (So write it down on a piece of
paper before it disappears!)  Note that the erasure uses ANSI escape
sequences which will not work correctly if the terminal window is
too narrow.

To decrypt myfile.cha:

  ``% python3 -m chacha.decrypt myfile.cha``

You will be prompted for the password, and a decrypted file named *myfile*
will be created.  The password will be visible until the decryption is
finished, then erased.

If you install this module with pip and have configured your path to make
your pip-installed scripts available, then the commands will simply be:

  ``% chacha-encrypt myfile``

and

  ``% chacha-decrypt myfile.cha``
cbar-rates 1.3.0
Python library to work with AZN (Azerbaijani manat) official rates
Requires Python: >=3.7
Keywords: cbar-rates, AZN, Azerbaijan, AZN-Rates, CBAR, Manat, Mezenne

# CBAR Rates

[![PyPI - Version](https://img.shields.io/pypi/v/cbar-rates)](https://pypi.org/project/cbar-rates)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cbar-rates)](https://pypi.org/project/cbar-rates)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/cbar-rates)](https://pypistats.org/packages/cbar-rates)
[![License](https://img.shields.io/pypi/l/cbar-rates)](LICENSE.md)

A Python library to work with Azerbaijani manat (AZN) official exchange rates based on [CBAR](https://cbar.az/currency/rates?language=en) (The Central Bank of the Republic of Azerbaijan).

## Features

- Retrieve official CBAR exchange rates for the Azerbaijani manat (AZN).
- Compare exchange rates between two dates and calculate differences.
- Filter results by specific currency codes (e.g., USD, EUR).

## Requirements

- Python 3.7 or higher
- `requests` library

## Installation

Install the library using pip:

```bash
pip install cbar-rates --upgrade
```

For isolated installations, use a virtual environment:

```bash
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install cbar-rates
```

## Examples

### Usage of `get_rates()`

```python
from datetime import date
import cbar

rates_date = date.today()
currencies = ["USD", "EUR"]

rates = cbar.get_rates(rates_date, currencies)

print(rates)
# Output:
{
    "date": "18.11.2024",
    "currencies": {
        "USD": {
            "nominal": "1",
            "rate": 1.7
        },
        "EUR": {
            "nominal": "1",
            "rate": 1.7919
        },
    }
}
```

### Usage of `get_rates_with_diff()`

```python
from datetime import date
import cbar

previous_date = date(2024, 11, 25)
date_ = date(2024, 11, 26)
currencies = ["USD", "EUR"]

rates = cbar.get_rates_with_diff(previous_date, date_, currencies)

print(rates)
# Output:
{
    "previous_date": "25.11.2024",
    "date": "26.11.2024",
    "currencies": {
        "USD": {
            "nominal": "1",
            "previous_rate": 1.7,
            "rate": 1.7,
            "difference": 0.0,
        },
        "EUR": {
            "nominal": "1",
            "previous_rate": 1.7814,
            "rate": 1.7815,
            "difference": 0.0001,
        },
    }
}
```

### Usage of `convert()`

```python
from datetime import date
import cbar

amount = 100
from_currency = "USD"
to_currency = "AZN"
conversion_date = date(2024, 11, 25)

converted_amount = cbar.convert(amount, from_currency, to_currency, conversion_date)

print(converted_amount)
# Output:
170.0  # 1 USD = 1.7 AZN
```

You can find all available currency codes on the [CBAR website](https://www.cbar.az/currency/rates?language=en)

## License

This project is licensed under the [MIT License](https://github.com/TahirJalilov/cbar-rates/blob/main/LICENSE.md).
pydantic-sqlalchemy-deco 0.0.4
Seamlessly use Pydantic 2 models in a Postgres SQLAlchemy model
Requires Python: >=3.11

# pydantic-sqlalchemy-type-decorator
Seamlessly use Pydantic 2 models in a Postgres SQLAlchemy model

## Installation

The package is available on [pypi](https://pypi.org/p/pydantic_sqlalchemy_deco).

You can install this package using pip:

```bash
pip install pydantic_sqlalchemy_deco
```

### Requirements

This library requires:
- Pydantic 2+
- SQLAlchemy (2.0+?)
- Postgres with JSONB support

Other versions may be supported as well, but please open an [issue](https://github.com/kevinhikaruevans/pydantic-sqlalchemy-type-decorator/issues) if you run into any problems.

## Usage

Given some Pydantic model called `MyCustomModel`, you can specify your columns like:

```python
from pydantic_sqlalchemy_deco.decorator import PydanticJSON

...

# Define Pydantic model somewhere:
class MyCustomModel(BaseModel):
    custom_id: int = 0


# Define your SQLAlchemy model:
class MyEntry(Base):

    custom_data: Mapped[MyCustomModel] = mapped_column(PydanticJSON(MyCustomModel))
```

Then, you can use the `custom_data` column as you'd expect:

```python
entry = MyEntry(
    custom_data=MyCustomModel(custom_id=1234)
)

...

print(entry.custom_data.custom_id)

```


# BaseModel changes

If your `BaseModel` has custom serializers, you can specify this using the `T` parameter:

```python
    custom_data: Mapped[MyCustomModel] = mapped_column(PydanticJSON[CoolerBaseModel](MyCustomModel))
```
trig 0.1.0
Trig provides many trigonometric functions.
Requires Python: >=3.7

# Trig

`trig` is a package that provides a variety of common and lesser-known
trigonometric functions.

The included functions are:

- sine (`sin`)
- cosine (`cos`)
- tangent (`tan`)
- secant (`sec`)
- cosecant (`csc`)
- cotangent (`cot`)
- versine (`ver`)
- coversine (`cvs`)
- vercosine (`vcs`)
- covercosine (`cvc`)
- haversine (`hvs`)
- hacoversine (`hcv`)
- havercosine (`hvc`)
- hacovercosine (`hcc`)
- exsecant (`exs`)
- excosecant (`exc`)
- chord (`crd`)

each of which also has a hyperbolic (suffixed with `h`), inverse (prefixed
with `a`) and inverse hyperbolic variant.
cvectors 9.1.2
A simple complex vector package.
Requires Python: >=3.9

# Cvectors

Cvectors is a Python package for 2D vectors. It provides a class,
`Vector`, which uses `complex` internally.

Usage is as follows:

```python
>>> from cvectors import Vector
>>> foo = Vector(4, 3)
>>> foo
Vector(4.0, 3.0)
>>> foo.x
4.0
>>> foo.y
3.0
>>> foo.r
5.0
>>> bar = Vector(4, 5)
>>> foo + bar
Vector(8.0, 8.0)
>>> foo.dot(bar)
31.0
>>> import math
>>> foo.rotate(math.pi / 2)
Vector(-2.9999999999999996, 4.0)
>>> Vector.from_polar(r=3, theta=5) - Vector.from_polar(r=5, theta=2)
Vector(2.9317207391253906, -7.423259958117824)
>>> Vector(5, 6).perp_dot(Vector(-6, 1))
41.0
>>> abs(foo)
5.0
>>> Vector(1, -9).rec()
(1.0, -9.0)
>>> Vector(1, -9).pol()
(9.055385138137417, -1.460139105621001)
>>> Vector(3, 2).perp()
Vector(-2.0, 3.0)
>>> Vector(3.142, 2.718).round()
(3, 3)
>>> Vector(3.142, 2.718).round(1)
(3.1, 2.7)
```
breakfast-puzzles 0.2.5
Breakfast Puzzles is a script for laying out a selection of puzzles from
Requires Python: >=3.8

# Breakfast Puzzles

This is a script for laying out a selection of puzzles from Simon
Tatham’s Portable Puzzle Collection onto a page.

It outputs PostScript to a file, which can then be printed out.

To use it, ensure you have
[the puzzle collection](https://www.chiark.greenend.org.uk/~sgtatham/puzzles/)
installed, then run `breakfast-puzzles FILENAME`.

The supported puzzles are:

- Bridges
- Dominosa
- Filling
- Galaxies
- Keen
- Keen Multiply
- Killer
- Light Up
- Magnets
- Map
- Pattern
- Pearl
- Range
- Rectangles
- Signpost
- Singles
- Slant
- Sudoku
- Sudoku X
- Jigsaw
- Jigsaw Killer
- Tents
- Towers
- Tracks
- Unequal
- Adjacent
- Unruly

---

Breakfast Puzzles
Copyright (C) 2021 Tom Fryers

This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.

You should have received a copy of the GNU General Public License along
with this program. If not, see <https://www.gnu.org/licenses/>.
family_parkrun 0.1.0
Generate a summary of the Parkrun performances of a group of people.
Requires Python: >=3.9

# Family Parkrun Summary

To use:

- Ensure you have [Python][] installed.
- Create a file containing a newline-separated list of runner ID numbers.
  These are the numbers at the end of the URL for their personal page.
- Run `family-parkrun` with the `-d` argument, followed by the filename
  of your runner list, and wait for it to download.
  ```bash
  python family-parkrun -d runners.txt
  ```
- View `summary.html` in your browser.

[python]: https://www.python.org
DeepAssimilate 0.1.0
Description of DeepAssimilate package
Requires Python: >=3.6

# DeepAssimilate

This package integrates station data into gridded data using deep learning techniques.

## Installation
```bash
pip install .
```
## Usage
```
from deepassimilate import DataAssimilation

assimilator = DataAssimilation()
result = assimilator.assimilate(gridded_data, station_data)
```
## Literature Review

FUXI-DA (https://arxiv.org/pdf/2404.08522) is a fully DL-native DA framework targeting a simplified, end-to-end pipeline for assimilating satellite data into ML forecasting models.

FENGWU-4DVAR (https://arxiv.org/pdf/2312.12455) merges ML models with a classical 4D-Var setup, preserving the variational optimization approach and its theoretical foundations.

Manshausen et al. (https://arxiv.org/pdf/2406.16947) demonstrate “score-based data assimilation” using a diffusion generative model trained purely from analysis states and then integrating sparse station observations at inference time to produce km-scale analyses, showcasing a zero-shot, generative approach distinct from both purely ML-native end-to-end frameworks and classical variational methods.
cytosummarynet 0.0.4
Capturing cell heterogeneity in representations of cell populations for image-based profiling using contrastive learning
Requires Python: >=3.10

# CytoSummaryNet

A PyTorch-based deep learning library for learning an optimal way to aggregate single-cell features into population-level profiles.


## Installation

```bash
pip install cytosummarynet
```

## Quick Start

To try out CytoSummaryNet with sample data:

1. Generate sample data:
```bash
python examples/generate_sample_data.py
```

2. Run the example pipeline:
```bash
python examples/example_pipeline.py
```

This will create a sample dataset and train a model using the default parameters.
ragui 0.1.0
Add your description here
Requires Python: >=3.12

# RagUI

RagUI is a Python framework that transforms your RAG (Retrieval Augmented Generation) pipelines into production-ready web applications. It's framework-agnostic and works seamlessly with popular LLM frameworks like LangChain and LlamaIndex.

## Features

- **Instant Web Interface**: Get a polished chat UI for your RAG pipeline with zero frontend code
- **Production Ready**: Built on FastAPI and async Python for high performance
- **Developer Focused**: Focus on your RAG logic while we handle the infrastructure
- **Framework Agnostic**: Works with LangChain, LlamaIndex, or your custom LLM implementation
- **Flexible Integration**: Adapt any existing RAG pipeline with minimal changes

**Coming Soon:**
- 🔒 Authentication & User Management
- 📊 Admin Dashboard
- 💾 Conversation History & Analytics
- 💰 Subscription Management
- 🔄 Feedback Collection & Fine-tuning
- 📈 Usage Metrics & Monitoring

## Quick Start

```bash
pip install ragui
```

Create a pipeline (`main.py`):

```python
from ragui import RagUI
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

ragui = RagUI()

# Define your LangChain components
prompt = ChatPromptTemplate.from_messages([
    ("user", "Context: {context}\nQuestion: {user_message}")
])
chain = prompt | ChatOpenAI() | StrOutputParser()

@ragui.pipeline("RAG Pipeline")
async def rag_pipeline(query, message_history, user_context):
    async for chunk in chain.astream({
        "context": "Your retrieved context here",
        "user_message": query
    }):
        yield chunk
```

Launch your application:

```bash
ragui main.py
```

Visit `http://localhost:8000` to interact with your pipeline.

## Why RagUI?

- **Save Development Time**: Focus on your RAG logic instead of building UI/infrastructure
- **Production Ready**: Built with production use-cases in mind
- **Future Proof**: As we add features, your application automatically gets upgrades
- **Full Control**: Customize and extend any aspect of the framework

## Roadmap
- [ ] Simple UI for text input/output
- [ ] Feedback collection
- [ ] Support files input
- [ ] Support for multiple pipelines
- [ ] Support for audio input
- [ ] Messages persistence (database)
- [ ] Conversation history
- [ ] User authentication
- [ ] Admin dashboard
- [ ] Add to website support (little chat bubble on the corner)
- [ ] Usage metrics
- [ ] Subscription management
rstbebe 0.2.0
RST baby! Let's go!
Requires Python: >=3.9

# RST Baby!

bébé (noun, french): "baby"

`rstbebe` is a tool for all y'all who work in a polyglot environment with
markdown, restructured text, and maybe other markup languages (e.g. docbook).

## What's it do?

It's a linter and [`pre-commit`](https://pre-commit.com) hook for catching
`rst` files which have incorrect or undesirable syntax.

Right now, it will help you catch this incorrect use of backticks:
```
Use `snorkwozzle()` to `frob` your `multifropnibab`!
```

### Wait, aren't single-backticks valid RST syntax?

Depends what you mean.

It *is* valid syntax, but it creates a `title_reference`.
Usually, when people use single-backticks, if they're used to markdown, they
are making a mistake and mean to have inline code with double-backticks.

## How can I use it?

CLI:

```
pipx run rstbebe bad-backticks [FILES...]
```

or pre-commit config:

```yaml
- repo: https://github.com/sirosen/rstbebe
  rev: 0.1.0
  hooks:
    - id: bad-backticks
      files: changelog\.d/.*\.rst
```

## Contributing

`rstbebe` is maintained by one guy in his spare time. Be nice.

### Can it also check for $COMMON_RST_MISTAKE ?

Open an issue! Let's see what we can do.

### Can it also autofix $COMMON_RST_MISTAKE_WITH_CLEAR_FIX ?

Yep, that also sounds like a good idea!
For now it's a linter, but it can become a fixer as long as we can come up with
good (safe) rules.