semvec/pypi-packages huggingface dataset:
audiocrosscoeff 0.0.1
The Pearson correlation coefficient (PCC) for 2 audio signals
Requires Python: >=3.12.3

# How to install

```bash
pip install audiocrosscoeff
```

![](https://raw.githubusercontent.com/tonypithony/audiocrosscoeff/main/justcorr/formula6.png)


# How to use

```bash
python audiocrosscoeff.py -a1 tests/611.wav -a2 tests/611wm.wav
```

# Output

### Pearsons correlation: 0.999710


# Help

```bash
python audiocrosscoeff.py -h
```

## Requirements

* pandas==2.2.2
* scipy==1.13.0
* numpy==1.26.3
* librosa==0.10.1

# Read more

* [Pearson Correlation Test Between Two Variables](https://www.geeksforgeeks.org/python-pearson-correlation-test-between-two-variables/)
* [Visualize data from CSV file in Python](https://www.geeksforgeeks.org/visualize-data-from-csv-file-in-python/)
sqrl 0.2.0
a lightweight sqlite API that can do just about everything you need and allows you to fill in any gaps
Requires Python: >=3.8

# SQrL 🐿️
a lightweight sqlite API for Python

### Getting Started
```python
from sqrl import SQL # database API
db = SQL("sample.db")
```
### Quick Intro
#### Select Statements
```python
from sqrl import SQL

db = SQL("sample.db")

db.select(
    "track", ["title", "duration", "artist_id"], order_by="track_number"
)  # SELECT title, duration, artist_id FROM track ORDER BY track_number;

db.select("album")  # SELECT * FROM album;

# get as funky as you want with it
db.select(
    "album ab join artist ar on ab.artist_id = ar.id",
    ["ab.title", "ar.name"],
    order_by="year",
    asc=False,
    where="ab.genre = 'soul'",
    limit=10,
    return_as_dict=True
)
# set 'row_factory' to None to get value tuples
# or return_as_dict to get dictionary objects


# and of course, writing completely raw sql still available
# reccomended for parameterization at the moment
db.fetch("SELECT * FROM album WHERE year >= ? AND artist_id = ?;", 2000, 57)

# you specify whether fetchall, fetchone or fetchmany is used with 'n'
db.fetch("SELECT * FROM artist WHERE id = ?", 57, n=1, return_as_dict=True)
```
#### CrUD
insert, update and delete from tables using dedicated methods.
built with Flask and JSON REST APIs in mind.
```python
from sqrl import SQL

db = SQL("sample.db")

# insert into database
db.insert(
    table_name="album",
    data={
        "id": 1,
        "title": "myalbum",
        "artist_id": 10,
        "year": 2024,
        "genre": "alternative"
    }
)
# parameterization safe! generated under the hood ->
db.execute(
    "INSERT INTO album (id, title, artist_id, year, genre) VALUES (?, ?, ?, ?, ?);",
    1, "myalbum", 10, 2024, "alternative",
    as_transaction=True
)

# update something in a table
db.update(
    table_name="album",
    data={
        "title": "a new title"
    },
    where=f"id = {1}"
)
# delete from table
db.delete(
    table_name="album", where=f"id = {1}"
)
# although the param dictionary for update is parameterized, the where clause is not. so you can use db.execute
# to execute full SQL statements i.e. db.execute("DELETE FROM album WHERE id = ?", 1)
```

#### Aggregations
perform aggregations on a chosen table with dedicated methods
```python
from sqrl import SQL

db = SQL("sample.db")
db.max(table_name="invoice", column="amount")
db.min("invoice", "amount")
db.avg("invoice", "amount", 2)  # ROUND(AVG(amount), 2)
db.count("invoice")
db.sum("invoice", "amount")
```

#### Exporting
```python
from sqrl import SQL

db = SQL("sample.db")

db.export_to_csv()  # exports every table in database to csv as [tablename].csv
db.export_table_to_csv("tracks")  # export just a single table
db.dump()  # writes the entire database schema to .sql, can specify 'out_file' by default will by named after database file
```
bp-libc-got 0.0.1
Breakpoint at the address in the .got.plt section of the libraries loaded in the target process
Requires Python: >=3.8

# bp_libc_got

Set Breakpoint at the address in the .got.plt section of the libraries loaded in the target process.

# Features

libc arg is optional, if not specified, the script will attempt to find the libc paths in the target process. (default : None)

flag arg is optional too, if True : make breakpoints work after any preceding breakpoint is hit. / False : make breakpoints work immediately. (default : False)

it returns 1 if successful, 0 if not.

# Usage

## In a pwntools script

```python
from pwn import *
import bp_libc_got

p = process("chal")
_, gdb_api = gdb.attach(p, gdbscript="b *vuln", api=True)

bp_libc_got.bp_got(gdb_api = gdb_api, libc = "libc.so.6", flag = True)
```
monopriors 0.1.0
Monocular Geometric Priors
Requires Python: >=3.10.0

# Monopriors
A library to easily get monocular priors such as scale-invariant depths, metric depths, or surface normals. Using Rerun viewer, Pixi and Gradio for easy use
<p align="center">
  <img src="media/depth-compare.gif" alt="example output" width="480" />
</p>


## Installation
Easily installable via [Pixi](https://pixi.sh/latest/).
```bash
git clone https://github.com/pablovela5620/monoprior.git
cd monoprior
pixi run app
```

## Demo
Hosted Demos can be found on huggingface spaces

<a href='https://huggingface.co/spaces/pablovela5620/depth-compare'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue'></a>


To run the gradio frontend
```bash
pixi run app
```

To see all available tasks
```bash
pixi task list
```

## Acknowledgements
Thanks to the following great works!

[DepthAnything](https://github.com/LiheYoung/Depth-Anything)
```bibtex
@inproceedings{depthanything,
      title={Depth Anything: Unleashing the Power of Large-Scale Unlabeled Data}, 
      author={Yang, Lihe and Kang, Bingyi and Huang, Zilong and Xu, Xiaogang and Feng, Jiashi and Zhao, Hengshuang},
      booktitle={CVPR},
      year={2024}
}
```

[Unidepth](https://github.com/lpiccinelli-eth/UniDepth)
```bibtex
@inproceedings{piccinelli2024unidepth,
    title     = {{U}ni{D}epth: Universal Monocular Metric Depth Estimation},
    author    = {Piccinelli, Luigi and Yang, Yung-Hsu and Sakaridis, Christos and Segu, Mattia and Li, Siyuan and Van Gool, Luc and Yu, Fisher},
    booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
    year      = {2024}
}
```

[Metric3D V2](https://github.com/YvanYin/Metric3D)
```bibtex
@article{hu2024metric3dv2,
  title={Metric3D v2: A Versatile Monocular Geometric Foundation Model for Zero-shot Metric Depth and Surface Normal Estimation},
  author={Hu, Mu and Yin, Wei and Zhang, Chi and Cai, Zhipeng and Long, Xiaoxiao and Chen, Hao and Wang, Kaixuan and Yu, Gang and Shen, Chunhua and Shen, Shaojie},
  journal={arXiv preprint arXiv:2404.15506},
  year={2024}
}
```
pyproject-pip 0.1.28
Install and manage pyproject.toml with pip commands.
Requires Python: >=3.8

# pyproject-pip (WIP)

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

-----

Install and manage pyproject.toml with pip commands.

See usage:

```
pypip --help
```


## Table of Contents

- [pyproject-pip (WIP)](#pyproject-pip-wip)
  - [Table of Contents](#table-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
  - [License](#license)

## Installation

```console
pip install pyproject-pip
```

## Usage

```console
pypip --help
```

```
Usage: pypip [OPTIONS] COMMAND [ARGS]...

Options:
  -v, --hatch-env TEXT  Specify the Hatch environment to use
  --help                Show this message and exit.

Commands:
  find       Find a package on PyPI and optionally sort the results.
  info       Get information about a package from PyPI.
  install    Install packages and update requirements.txt and...
  show       Show the dependencies from the pyproject.toml file.
  uninstall  Uninstall packages and update requirements.txt and...
```

## License

`pyproject-pip` is distributed under the terms of the [apache-2.0](https://spdx.org/licenses/apache-2.0.html) license.
hypothesis-testing-tool 0.1.2
A tool for doing hypothesis testing
Requires Python: <4.0,>=3.11

```python
import sys
import os
sys.path.append(os.path.abspath(os.path.join('..')))
```

<br>
<br>

# Description

<span style="color: #00BFC4;">**A package to run hypothesis testing for one and two samples.**</span>

<br>

## One Sample Hypothesis Testing


```python
from hypothesis_testing_tool.compute_stats.one_sample_statistics import OneSampleTest
```

<br>

<span style="color: #00BFC4;">**Let's see an example of how you can use the `OneSampleTest` class.**</span>



```python
import random

# Set the seed for reproducibility
seed_value = 42
random.seed(seed_value)

random_sample = [random.gauss(mu = 5, sigma = 1) for _ in range(1000)]
```


```python
t_test = OneSampleTest(
        data = random_sample,
        null_population_mean = 3.5
        ).t_test_results

print(f"p-value: {t_test.pvalue:.2f}")
print(f"t-statistic: {t_test.statistic:.2f}")
```

    p-value: 0.00
    t-statistic: 45.96


<br>

<span style="color: #00BFC4;">**The default is with alternative = "two-sided", but that can change to a one tail test.**</span>


```python
t_test_less = OneSampleTest(
        data = random_sample,
        null_population_mean = 3.5,
        alternative = "less"
        ).t_test_results

print(f"p-value: {t_test_less.pvalue:.2f}")
print(f"t-statistic: {t_test_less.statistic:.2f}")
```

    p-value: 1.00
    t-statistic: 45.96



```python
t_test_greater = OneSampleTest(
        data = random_sample,
        null_population_mean = 3.5,
        alternative = "greater"
        ).t_test_results

print(f"p-value: {t_test_greater.pvalue:.2f}")
print(f"t-statistic: {t_test_greater.statistic:.2f}")
```

    p-value: 0.00
    t-statistic: 45.96


<br>

<span style="color: #00BFC4;">**You can also compute the confidence interval (default = 95%) for the mean, using the `calculate_ci` method.**</span>

<span style="color: #00BFC4;">**The `calculate_ci` method takes an optional argument `alpha` to adjust to 99% CI (alpha = 0.01) or any other.**</span>



```python
confidence_interval = OneSampleTest(
        data = random_sample,
        null_population_mean = 3.5
        ).calculate_ci()
confidence_interval
```




    {'lower_bound': 4.918459428969473,
     'point_estimate': 4.9817306915192265,
     'upper_bound': 5.04500195406898,
     'null_population_mean': 3.5}



<br>

<span style="color: #00BFC4;">**Finally, you can create a plot with the CI and save it to a local path.**</span>


```python
from hypothesis_testing_tool.presentation.create_plots import create_one_sample_hypothesis_plot

```


```python
create_one_sample_hypothesis_plot(
    path_to_save_plot = "artifacts/one_sample_plot.png",
    ci_dict = confidence_interval,
    width = 10,
    height = 5
)
```




    (<Figure size 1000x500 with 1 Axes>,
     <Axes: title={'center': '95% Confidence Interval (CI) for the Mean of One Sample'}, xlabel='Values'>)



<img src="https://raw.githubusercontent.com/vamvas/hypothesis-testing-tool/master/description/artifacts/one_sample_plot.png" >

**In the plot above the 95% confidence interval includes 3.5, so we do not reject the null hypothesis.**
dataset2vec 1.0.0
Package for training and further usage of Dataset2Vec meta-model.
Requires Python: >=3.9

# Dataset2Vec

## Introduction
This package aims to implement the approach proposed in *Dataset2Vec: Learning Dataset Meta-Features by Jomaa et al*. This package makes the training Dataset2Vec dataset encoder much more approachable by providing an API that is compatible with ``pytorch-lightning``'s ``trainer`` API. The output logs including tensorboard and checkpoints are stored in ``lightning_logs`` or in ``default_root_dir`` from ``pytroch_lightning.Trainer`` if specified.

## Installation
To install the package run the following command (you need Python 3.9 or higher):
```
pip install -r requirements.txt
```

## Usage
Here is a simple example of the usage of the package:
``` Python
from pathlib import Path

from pytorch_lightning import Trainer

from dataset2vec import (
    Dataset2Vec,
    Dataset2VecLoader,
    RepeatableDataset2VecLoader,
)

train_loader = Dataset2VecLoader(Path("data/train"))  # Path with .csv files
val_loader = RepeatableDataset2VecLoader(
    Path("data/val")
)  # Path with .csv files

model = Dataset2Vec()

trainer = Trainer(
    max_epochs=2, log_every_n_steps=1, default_root_dir="output_logs"
)  # output of the training will be stored in output_logs

trainer.fit(model, train_loader, val_loader)
```

## Development
Here are the snippets useful for the development of the package:
* `./scripts/check_code.sh` - runs code quality checking using `black`, `flake8`, `isort` and `mypy`.
* `pytest` - runs all unit tests
* `cd docs && make html` - generates documentation
* `python -m build` - build the package
* `twine upload dist/*` - uploads the package to PyPI
jaziw 0.0.2
Special opportunities for the Karakalpak language
Keywords: karakalpak, language, python


# Tokens Example



```python

from jaziw import tokenize



text = "Asslawma áleykum! Aqılı pútin, ziyalı qáwim."

tokens = tokenize(text)

print(tokens)



# Result

# [Substring(start=0, stop=8, text='Asslawma'), Substring(start=9, stop=16, text='áleykum'), Substring(start=16, stop=17, text='!'), Substring(start=18, stop=23, text='Aqılı'), Substring(start=24, stop=29, text='pútin'), Substring(start=31, stop=37, text='ziyalı'), Substring(start=38, stop=43, text='qáwim'), Substring(start=43, stop=44, text='.')]

```



# Sentences Example



```python

from jaziw import sentenize



text = "Asslawma áleykum! Aqılı pútin, ziyalı qáwim."

sentences = sentenize(text)

print(sentences)



# Result

# [Substring(start=0, stop=17, text='Asslawma áleykum!'), Substring(start=18, stop=44, text='Aqılı pútin, ziyalı qáwim.')]

```



# Normalize Example



```python

from jaziw import normalize



bad_text = """– Há, júwermek qatqır-aw, tursań bolmay ma, 

mollańa keshiktiń ǵoy! – degen anamnıń sesi tatlı uyqımdı bóldi. 



Ol bunday sózdi tek ashıwı kelgende ǵana aytatuǵın edi. 

                Anamnıń ǵarǵısınan beter «molla» degen sózin esitkennen-aq, quyqam juwlap, uyqım shayday ashıldı. Qorqınısh denemdi qaplap turdı. Bunnan 7-8 kún burın pallaqqa asılǵandaǵı tut shıbıqtan tilingen eki ayaǵım sol qálpinde matalıp jatqanday bolıp sezildi. Haqıyqatında da, ayaǵımnıń tilikleri pite qoyǵan joq edi. Aqsap zorǵa júretuǵın edim.

"""



print(normalize(bad_text))



# Result

# – Há, júwermek qatqır-aw, tursań bolmay ma, mollańa keshiktiń ǵoy! – degen anamnıń sesi tatlı uyqımdı bóldi. Ol bunday sózdi tek ashıwı kelgende ǵana aytatuǵın edi. Anamnıń ǵarǵısınan beter «molla» degen sózin esitkennen-aq, quyqam juwlap, uyqım shayday ashıldı. Qorqınısh denemdi qaplap turdı. Bunnan 7-8 kún burın pallaqqa asılǵandaǵı tut shıbıqtan tilingen eki ayaǵım sol qálpinde matalıp jatqanday bolıp sezildi. Haqıyqatında da, ayaǵımnıń tilikleri pite qoyǵan joq edi. Aqsap zorǵa júretuǵın edim.

```



# Recommended

```python

from jaziw import normalize, tokenize, sentenize





filename = "a-shamuratov-lat.txt"

with open(filename, "r", encoding="utf-8") as file:

    text = file.read()

    

    normalized_text = normalize(text)

    tokenized_text = tokenize(normalized_text)

    sentenized_text = sentenize(normalized_text)



    with open("normalized-" + filename, "w", encoding="utf-8") as new_file:

        new_file.write(text)

```
staff-cli 0.1.1
Staff is a toolkit for dead-simple usage out of the box promts and llms in your project and command line.
Keywords: llm, ai, ollama

**Staff** is a toolkit for dead-simple usage out of the box promts and llms in your project and command line.

DRY & magic flow is a core principle.

Current state is WIP.

## Idea/Vision

Any good prompt combined with a llm is a pure magic. And you don't need to repeat yourself and find a good prompt, you can find well-prepared by community grimoires (combination of prompt, agents, functions & llms or only a prompt) then you learn this grimoire and can you use it on any text. Staff can help you with mastering your grimoires. Be brave in your path.

Structure of the Grimoire 0.1 version:

```md
---
title:
description:
tags: []
author:
---

[//]: # (SYSTEM)\n
Here any System prompt...

[//]: # (USER)\n
Here any User prompt...
```

You can use a grimoire with such packed of knowledge structure or it can be just a simple text without any metatags or SYSTEM/USER prompts. In that case everything is a SYSTEM prompt.

In the future version I want to add support for models & functions.

## Installation

You can install it from [pip](https://pypi.org/), [cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html)

```bash
# pip install staff-cli
# cargo install staff-cli --locked # Not available yet
```

Or you can build ast-grep from source. You need to install rustup, clone the repository and then

````bash
cargo install --path ./crates/cli --locked


## USAGE

How to get ideas from the youtube video? You need to have installed [youtube_transcript_api](https://github.com/jdepoix/youtube-transcript-api)

```bash
youtube_transcript_api TY0o3Zs8u78 --languages en --format text | tr '\n' ' ' | xargs cargo run -- cast -n extract_wisdom
````

## FOR CONTRIBUTORS

About GigaChat model:

On UBUNTU/DEBIAN we need to install libssl-dev

```bash
sudo apt-get install libssl-dev
```

Install certificates

https://www.gosuslugi.ru/crt