semvec/pypi-packages huggingface dataset:
rrprettier 0.1.0
My awesome Python project
Requires Python: >=3.7,<4.0

# RRPrettier
A tool to prettify data of python objects

A simple example:

```python
import rrprettier
data={
"name": "John Doe",
"age": 30,
"city": "New York",
"isStudent": False,
"courses": ["Math", "Science", "English"],
"address": {
    "street": "123 Main St",
    "zipCode": "10001"
}
}
rrprettiernew.pprint(data)
```
MayakApiClient-test 0.0.3
This is the simplest module for quick work with files.
Requires Python: ==3.11
Keywords: mayak_api_test

# mayak_api

python_version = 3.12

# Р”РѕРєСѓРјРµРЅС‚Р°С†РёСЏ v. 0.0.1

С‚РµСЃС‚ РѕР±РЅРѕРІР»РµРЅРёСЏ РїР°РєРµС‚Р°
contextcrunch 1.0.4
Access to the ContextCrunch Prompt Compression API from Python
Requires Python: >=3.8

# ContextCrunch Python Client
Use the [ContextCrunch API](https://contextcrunch.com) easily with python!

## Prerequsites
- You need an API key from [https://contextcrunch.com/console/keys](https://contextcrunch.com/console/keys)
- Install contextcrunch with `pip install contextcrunch`
## Quick Start
```python
from contextcrunch import ContextCrunchClient
client = ContextCrunchClient('API_KEY_HERE')

compressed = client.compress(
  context=['compress this text'],
  prompt='last message',
  compression_ratio=0.95
)
print(f'Although this text is too short to compress, we can see the API works! {compressed}')
```

## Uploading to PyPi

```bash
python3 -m build
python3 -m twine upload dist/*
```

Username: `__token__`
generax 0.1.2
Generative Models using Jax
Requires Python: >=3.7

# generax
generax provides implementations of flow based generative models.  The library is built on top of [Equinox](https://github.com/patrick-kidger/equinox) which removes the need to worry about keeping track of model parameters.
```python
key = random.PRNGKey(0) # JAX random key
x = ... # some data

# Create a flow model
model = NeuralSpline(input_shape=x.shape[1:],
                     n_flow_layers=3,
                     n_blocks=4,
                     hidden_size=32,
                     working_size=16,
                     n_spline_knots=8,
                     key=key)

# Data dependent initialization
model = model.data_dependent_init(x, key=key)

# Take multiple samples using vmap
keys = random.split(key, 1000)
samples = eqx.filter_vmap(model.sample)(keys)

# Compute the log probability of data
log_prob = eqx.filter_vmap(model.log_prob)(x)
```

There is also support for probability paths (time-dependent probability distributions) which can be used to train continuous normalizing flows with flow matching.  See the examples on flow matching and multi-sample flow matching for more details.

![Samples](notebooks/ppath.png)

# Installation
generax is available on pip:
```bash
pip install generax
```

# Training
Generax provides an easy interface to train these models:
```python
trainer = Trainer(checkpoint_path='tmp/model_path')

model = trainer.train(model=model,              # Generax model
                      objective=my_objective,   # Objective function
                      evaluate_model=tester,    # Testing function
                      optimizer=optimizer,      # Optax optimizer
                      num_steps=10000,          # Number of training steps
                      data_iterator=train_ds,   # Training data iterator
                      double_batch=1000,        # Train these many batches in a scan loop
                      checkpoint_every=1000,    # Checkpoint interval
                      test_every=1000,          # Test interval
                      retrain=True)             # Retrain from checkpoint
```
See the examples folder for more details.
amazon-product-review-analyzer 1.0.0
Amazon Product Reviews Analyzer
Keywords: python,amazon,review,analyzer,sentiment,analysis,amazon review analyzer


# Amazon Review Analyzer

Welcome to the Amazon Review Analyzer, a Python program designed to help you make informed decisions about purchasing products on Amazon.

## Overview

This program takes an Amazon product link as input and analyzes the reviews, providing insights into whether the product is a good buy. However, the ultimate decision to purchase rests entirely with you.

## How It Works

1. **Input the Product Link:** When you provide the Amazon product link, the program initiates a web scraping process to extract reviews.

2. **Scraping and Data Storage:** The scrapper extracts reviews from the [amazon.in/product-reviews/asin](amazon.in/product-reviews/asin) page. The unique ASIN (Amazon Standard Identification Number) is extracted from the link using Python's regular expressions. Due to pagination, the program iterates through the pages, storing the reviews in a CSV file named `reviews.csv`.

3. **User Agent:** Replace **headers** variable  in  `scrapper.py` with your user agent to know what is your user agent simply google **my user agent**

4. **Sentiment Analysis:** The program uses the `vaderSentiment` Python package to analyze the tone of the reviews. Additionally, the `demoji` package is employed to handle emojis present in the reviews.
Review-Analyzer 1.0.0
Amazon Product Reviews Analyzer
Keywords: python,amazon,review,analyzer,sentiment,analysis,amazon review analyzer


# Amazon Review Analyzer

Welcome to the Amazon Review Analyzer, a Python program designed to help you make informed decisions about purchasing products on Amazon.

## Overview

This program takes an Amazon product link as input and analyzes the reviews, providing insights into whether the product is a good buy. However, the ultimate decision to purchase rests entirely with you.

## How It Works

1. **Input the Product Link:** When you provide the Amazon product link, the program initiates a web scraping process to extract reviews.

2. **Scraping and Data Storage:** The scrapper extracts reviews from the [amazon.in/product-reviews/asin](amazon.in/product-reviews/asin) page. The unique ASIN (Amazon Standard Identification Number) is extracted from the link using Python's regular expressions. Due to pagination, the program iterates through the pages, storing the reviews in a CSV file named `reviews.csv`.

3. **User Agent:** Replace **headers** variable  in  `scrapper.py` with your user agent to know what is your user agent simply google **my user agent**

4. **Sentiment Analysis:** The program uses the `vaderSentiment` Python package to analyze the tone of the reviews. Additionally, the `demoji` package is employed to handle emojis present in the reviews.
dlp_data_scraper 0.1.3
A simple data scraper for the DLP website
Requires Python: >=3.11,<4.0

# DLP Data Scraper and Generator

DLP Data Scraper and Generator is a Python tool designed to scrape and generate data for data loss prevention (DLP) purposes. It has two modules:

* It fetches DLP test sample data from specified URLs, saves the data in text format, and then converts these text files into PDFs. 
* It uses an OpenAI Assistant to generate DLP mock data 


The output is suitable for benchmarking DLP systems or Generative AI Language Learning Models (GenAI LLMs) for prompt injection testing.

## Features

- Web scraping from specified URLs.
- Data extraction and saving in text format.
- Conversion of text data to PDF format, ideal for benchmarking DLP systems or GenAI LLMs.

## Installation

To install DLP Data Scraper, clone the repository and install the required packages:

```bash
git clone https://github.com/BenderScript/DLPDataScraper.git
cd DLPDataScraper/dlp_data_scraper
pip3 install -r requirements.txt
```

## Usage

To use the DLP Data Scraper:

```python
from dlp_data_scraper import Umbrella

pdf_data = "pdf_data"
text_data = "text_data"
url = ('https://support.umbrella.com/hc/en-us/articles/4402023980692-Data-Loss-Prevention-DLP-Test-Sample-Data-for'
       '-Built-In-Data-Identifiers')

scraper = Umbrella(url=url, text_data=text_data, pdf_data=pdf_data)
html_content = scraper.initialize_browser()
scraped_data = scraper.scrape_data()
scraper.save_data_to_files()
scraper.convert_txt_to_pdf()

print("Scraping and conversion to PDF completed.")
```

This example demonstrates initializing the scraper, scraping data from the specified URL, saving the data to text files, and then converting those text files to PDFs in specified directories.

## Contributing

Contributions to DLP Data Scraper are welcome. Please feel free to submit pull requests or open issues to improve the project.

---
python-solarfrontier 0.1.1
Library to communicate with Solar Frotier inverters
Requires Python: >=3.8

# Solar Frontier Inverter API

<div align="center">

  <img src="https://github.com/ernestasga/python-solarfrontier/blob/main/images/solar-frontier-logo.png?raw=true" alt="solar-frontier-logo" >

  <a href="https://github.com/ernestasga/python-solarfrontier/actions/workflows/test.yml">
    <img src="https://github.com/ernestasga/python-solarfrontier/actions/workflows/test.yml/badge.svg" alt="Tests">
  </a>
  <img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="Python Version">
  <a href="https://pypi.org/project/python-solarfrontier/">
    <img src="https://img.shields.io/pypi/v/python-solarfrontier.svg" alt="PyPI Version">
  </a>

</div>
<p align="center">
  Python Library to retrieve data from "Solar Frontier" inverters on LAN. Able to get measurements, yield data, system info.
</p>


# Installation
Available on PyPi
```bash
pip install python-solarfrontier
```

# Compatibility
**Confirmed to work with:**

* SF-WR-5503x

# Example
Initiate the API instance with host. Authentication not supported.

```
import asyncio

from python_solarfrontier.api import SolarFrontierAPI
from python_solarfrontier.utils import UnitConverter

async def main():
    host = '192.168.0.101' # IP address of the inverter
    api = SolarFrontierAPI(host)

    # Test if we can connect with the host
    test = await api.test_connection()
    print(f"Test connection: {test}")

    # Get system information
    system_info = await api.get_system_info()
    print(f"System information: {system_info}")

    # Get measurement data
    measurements = await api.get_measurements()
    print(f"Measurement data: {measurements}")

    # Get the yield of the current day
    yield_day = await api.get_yield_day()
    print(f"Yield of the current day: {yield_day}")

    # Get the yield of the current month
    yield_month = await api.get_yield_month()
    print(f"Yield of the current month: {yield_month}")

    # Get the yield of the current year
    yield_year = await api.get_yield_year()
    print(f"Yield of the current year: {yield_year}")

    #Get total yield
    yield_total = await api.get_yield_total()
    print(f"Total yield: {yield_total}")

    # Close the session
    await api.close()


    # Get measurement values and units
    unit_converter = UnitConverter()
    total_yield_value, total_yield_unit = unit_converter.parse_measurement(yield_total)
    print(f"Total yield value: {total_yield_value}, unit: {total_yield_unit}")

# Run the async main function
asyncio.run(main())
```

# Contribution
Feel free to contribute with PR to `dev` brach.
pyVoIP 2.0.0a4
PyVoIP is a pure python VoIP/SIP/RTP library.
Requires Python: >=3.8

# pyVoIP
PyVoIP is a pure python VoIP/SIP/RTP library. Currently, it supports PCMA, PCMU, and telephone-event.

This library does not depend on a sound library, i.e. you can use any sound library that can handle linear sound data such as pyaudio or even wave. Keep in mind PCMU/PCMA only supports 8000Hz, 1 channel, 8 bit audio.

## Getting Started
Simply run `pip install pyVoIP`, or if installing from source:

```bash
git clone https://github.com/tayler6000/pyVoIP.git
cd pyVoIP
pip install .
```

Don't forget to check out [the documentation](https://pyvoip.readthedocs.io/)!

### Basic Example
This basic code will simple make a phone that will automatically answer then hang up.

```python
from pyVoIP.credentials import CredentialsManager
from pyVoIP.VoIP.call import VoIPCall
from pyVoIP.VoIP.error import InvalidStateError
from pyVoIP.VoIP.phone import VoIPPhone, VoIPPhoneParamter

class Call(VoIPCall):

  def ringing(self, invite_request):
      try:
          self.answer()
          self.hangup()
      except InvalidStateError:
          pass

if __name__ == "__main__":
  cm = CredentialsManager()
  cm.add(<SIP server username>, <SIP server password>)
  params = VoIPPhoneParamter(<SIP server IP>, <SIP server port>, <SIP server user>, cm, bind_ip=<Your computers local IP>, call_class=Call)
  phone = VoIPPhone(params)
  phone.start()
  input('Press enter to disable the phone')
  phone.stop()
```

### Sponsors

- [Nabu Casa](https://www.nabucasa.com/)
- [Home Assistant](https://www.home-assistant.io/)
schelling-model 0.0.1
Schelling model of neightbours segregation
Keywords: python,schelling,segregation


# schellings-model
schellings model of racial segregation

# Description
In this project i'm gona a developa a simulation of Schellings model of racial segregation to study witch factorm lead to the segregation of the population in citys.
The project will have a firs version where the only parameter that will be taken in acount is the satisfaction ratio that defins how satisfaid is a person with is neighbors, the parametes defins the minimal number of same kinf neighborus each egent neads to be happy in the position that is raight now and if it's not happy with the position the agent will move to a vacant position, this proces will be repited until all the agents are happy or until ther is no more vacant places where to be happy.

# Graphic interface
Using the streamlit library we can play with the vaues of diferent paraemters to see what happends on each case.

# Version 2

In this version 2 i will aplay the clasic Schelling, considerein only one muvment at a time and onli moving if there is a position where it will be happy.
Youtube-comment-word-frequency 0.0.3
how to debut a PyPI for chemistry
Requires Python: >=3.7

# Youtube_comment_word_frequency

# PyPI Overview: The purpose of this PyPI is to analyze the frequency of words in Youtube comments to help improve the content of videos.
# Recently, youtube has become a mainstream video-sharing website, and there are many people who profit from video postings and advertisements from companies. In such a situation, words of both approval and disapproval gather in the comments section of videos, and it is difficult to check all the comments on popular videos. This package enables you to extract word frequency and analyze the opinions and impressions of many people at a glance based on the number of words.

How it works:
Install the library
pip install google-api-python-client
searchpi 0.0.3
A command-line tool for searching your Raspberry Pi in a local network
Requires Python: >=3.9

# searchpi

[![Downloads](https://static.pepy.tech/badge/searchpi/month)](https://pepy.tech/project/searchpi)
[![Downloads](https://static.pepy.tech/badge/searchpi)](https://pepy.tech/project/searchpi)
[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/searchpi?branch=main)](https://hitsofcode.com/github/pomponchik/searchpi/view?branch=main)
[![Python versions](https://img.shields.io/pypi/pyversions/searchpi.svg)](https://pypi.python.org/pypi/searchpi)
[![PyPI version](https://badge.fury.io/py/searchpi.svg)](https://badge.fury.io/py/searchpi)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

This is a very stupid CLI tool that is designed to search for SSH-ready devices on your local network, starting with those with the most senior local IP addresses.

Before using this tool, install [`nmap`](https://nmap.org/) on your computer. Then install the tool by [`pip`](https://pip.pypa.io/en/stable/installation/):

```bash
pip install searchpi
```

And use:

```bash
searchpi 192.168.1.0/24 pomponchik ~/.ssh/id_rsa.pub --one
```

Here `192.168.1.0/24` means the range of addresses we are looking at, `pomponchik` is the username and `~/.ssh/id_rsa.pub` is the name of the SSH key file. The `--one` option means that only the first address will be outputed to a console.

The command will print to the standard output the command that you will need to execute to connect to the remote machine via SSH:

```bash
>>> searchpi 192.168.1.0/24 pomponchik ~/.ssh/id_rsa.pub
ssh pomponchik@192.168.1.16
```

You can save your energy if you try to call the received command in the same line of code:

```bash
eval "$(searchpi 192.168.1.0/24 pomponchik ~/.ssh/id_rsa.pub --one)"
```
mambo-minhhai 0.0a36
A small example package
Requires Python: >=3.8

# README #

This README would normally document whatever steps are necessary to get your application up and running.

### What is this repository for? ###

* Quick summary
* Version
* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)

### How do I get set up? ###

* Summary of set up
* Configuration
* Dependencies
* Database configuration
* How to run tests
* Deployment instructions

### Contribution guidelines ###

* Add source code to /src
* Run the following command for building the package:
    `bash ./bash/build.sh`

* Run the following command for uploading the package to the Pypi hub:
    `bash ./bash/upload.sh`
    Enter the following user name and password:
        - User name: __token__
        - Password: 
### Who do I talk to? ###

* Repo owner or admin
* Other community or team contact