semvec/pypi-packages huggingface dataset:
runpod-ssh 0.2.0
RunPod SSH config manager
Requires Python: <4.0,>=3.11

# RunPod SSH

[![PyPI version](https://badge.fury.io/py/runpod-ssh.svg?cacheBust=1)](https://badge.fury.io/py/runpod-ssh)

CLI tool to manage SSH configurations for RunPod instances.

# Usage

```bash
runpod-ssh setup
```

```bash
runpod-ssh sync
```

## Sync only a specific pod prefix

```bash
runpod-ssh sync --pod-filter my-8xh100-node
```
noisy-bnsp 0.1.0
A Python library to simulate and inference on the noisy bivariate Neyman-Scott process.
Requires Python: >=3.12
Keywords: point process, simulation, inference

# noisy-bnsp

A Python package to simulate and estimate the noisy-BNSP model.

## How to install

1. install `gsl` (also known as: gnu-scientific-library)
2. `pip install noisy-bnsp`

## Reference

- Shiotani, T., & Yoshida, N. (2024). Statistical inference for highly correlated stationary point processes and noisy bivariate Neyman-Scott processes. arXiv preprint arXiv:2410.05732.

## TODO

- Add docs by sphinx
- Add real-data example
esotericai 0.0.4
Efficient distributed inference.
Requires Python: >=3.7

# example_usage.py

```python
import asyncio
import time
from esotericai.circuit import CircuitForBatchProcessing

async def task(circuit, id):
    conv = [
        {
            "role": "user",
            "content": f"Hello! Please use number {id} in your responce."  
        }
    ]
    result = await circuit.chat(["llama8b"], conv)
    print(f"Task {id}/1 done:" + str(result))

start_time = time.time()

CircuitForBatchProcessing.dispatch(
        job_name="my_chat_job",
        task_func=task,
        num_tasks=5,
        api_url="127.0.0.1:6325"  # Nexus IP adress
)

end_time = time.time()

print(f"Total time taken: {end_time - start_time:.2f} seconds")
```
Webiks-Hebrew-RAGbot 1.1.1
A search engine using machine learning models and Elasticsearch for advanced document retrieval.
Requires Python: >=3.10

# **Webiks-Hebrew-RAGbot**

## **Overview**

This project is a search engine that uses machine learning models and Elasticsearch to provide advanced document retrieval.
You can use [Webiks-Hebrew-RAGbot-Demo](https://github.com/NNLP-IL/Webiks-Hebrew-RAGbot-Demo) to demonstrate the engine's document retrieval abilities

## **Features**

Document representation and validation
Document embedding and indexing in Elasticsearch
Advanced search using machine learning model
Integration with LLM (Large Language Model) client for query answering

## **Installation**

1.  Clone the repository:
   
`git clone https://github.com/NNLP-IL/Webiks-Hebrew-RAGbot.git`

`cd kolzchut-ragbot`

2.  Create a virtual environment and activate it:Â Â 

`python -m venv venv`

`source venv/bin/activate`

On Windows use `\venv\\Scripts\\activate\`

3.  Install the required dependencies:Â Â 

`pip install -r requirements.txt`

## **Configuration**

Set the following environment variables:Â Â 

ES\_EMBEDDING\_INDEX: The name of the Elasticsearch index for embeddings.

TOKENIZER\_LOCATION: The location of the tokenizer model.
proxy-middleman 0.0.5
Proxy rotation is a project designed to simplify working with the proxy rotation
Requires Python: >=3.7

# How to use proxy-middleman module

1. Create a connectors in scrapoxy (<a>http://185.253.7.140:8890/projects/d1bfcfdc-5f71-4a7a-a83a-252d1f25de4a/connectors/view</a>)
2. Get the IDs of the created connectors (<a>http://185.253.7.140:8080/docs#/default/list_proxies_proxies_get</a>)
3. Push proxies urls to the connectors with ids from the point '2' using API (<a>http://185.253.7.140:8080/docs#/default/create_proxies_proxies__connector_id__post</a>)
4. Install the module proxy-middleman.

```bash
pip install proxy-middleman
```

5. Import the class ProxyMiddleman from the module proxy-middleman.

```python
from proxy_middleman.proxy_rotation import ProxyMiddleman
```

6. Create an instance of the ProxyMiddleman class.

```python
proxy_middleman = ProxyMiddleman(connectors_ids=[connector_id1, connector_id2, connector_id3])
```
- connectors_ids: The list of IDs of the connectors to use.
- number_of_retries: Number of retries for proxy requests. If the response returned with status 401/403/451/503, then the proxy will be changed, it will try to do it `number_of_retries` times
- backoff_time: Base time for backoff in seconds. If the response returned with status 401/403/451/503, then this proxy will no longer be used at least `backoff_time` seconds
- exponential_backoff: Boolean indicating if exponential backoff should be used. If True, increases the backoff time exponentially (2^fails * backoff_time).
- slack_webhook_url: The URL of the Slack webhook to use for notifications.

### For example if `backoff_time = 10` and `exponential_backoff = True` then:
- 1st retry: 10 seconds
- 2nd retry: 20 seconds
- 3rd retry: 40 seconds
- 4th retry: 80 seconds
- 5th retry: 160 seconds
- 6th retry: 320 seconds
- 7th retry: 640 seconds
- 8th retry: 1280 seconds
- 9th retry: 2560 seconds

7. Use the `request` method to send requests to the target site.

```python
    try:
        response = await proxy_manager.request("http://example.com")
        print(response.text)
    except Exception as e:
        print(e)
```
8. Check the stats of the proxies using the `get_proxy_stats` method.

```python
    stats = proxy_manager.get_proxy_stats()
    print(stats)
```

# How it works

Before sending a request, we look at which proxies are currently available. If there are no available proxies, a message will be sent to slack and the wait for the first available proxy will begin. After sending a request and receiving a response, the response status is checked, if it does not satisfy us (401, 403, 451, 503), then we disable this proxy for `backoff_time` seconds. And this will continue until a good response_status is returned or attempts equal to `number_of_retries` are over (in this case, a message will be sent to slack and an exception will be raised in the code).
cxx-flow 0.8.0
C++ project maintenance, automated
Requires Python: >=3.10
Keywords: C/C++, c++, ci, cpp, dependency, developer, manager, tool

# C++ flow

[![Python package workflow badge](https://github.com/mzdun/cxx-flow/actions/workflows/python-publish.yml/badge.svg)](https://github.com/mzdun/cxx-flow/actions)
[![PyPI version badge](https://img.shields.io/pypi/v/cxx-flow.svg)](https://pypi.python.org/pypi/cxx-flow)
[![PyPI License: MIT](https://img.shields.io/pypi/l/cxx-flow.svg)](https://pypi.python.org/pypi/cxx-flow)

**C++ flow** aims at being a one-stop tool for C++ projects, from creating new
project, though building and verifying, all the way to publishing releases to
the repository. It will run a set of known steps and will happily consult your
project what do you want to call any subset of those steps.

Currently, it will make use of Conan for external dependencies, CMake presets
for config and build and GitHub CLI for releases.

## Installation

To create a new project with _C++ flow_, first install it using pip:

```sh
(.venv) $ pip install cxx-flow
```

Every project created with _C++ flow_ has a self-bootstrapping helper script,
which will install `cxx-flow` if it is needed, using either current virtual
environment or switching to a private virtual environment (created inside
`.flow/.venv` directory). This is used by the GitHub workflow in the generated
projects through the `bootstrap` command.

On any platform, this command (and any other) may be called from the root of the
project with:

```sh
python .flow/flow.py bootstrap
```

From Bash with:

```sh
./flow bootstrap
```

From PowerShell with:

```sh
.\flow bootstrap
```

## Creating a project

A fresh C++ project can be created with a

```sh
cxx-flow init
```

This command will ask multiple questions to build Mustache context for the
project template. For more information, see [the documentation](https://cxx-flow.readthedocs.io/en/latest/).
sfisop-datamodels 1.0.1
Basic time series data models for the Smart Ocean platform
Requires Python: <4.0.0,>=3.9

# SmartOcean timeseries data model

The purpose of the data model is to support the exchange of time series data in particular exchange of fragments of data 
associated with time series delivered by the SFI Smart Ocean Platform: https://smartoceanplatform.github.io/ 

The data model is implemented based on the Pydantic framework: https://docs.pydantic.dev/latest/

# Standards

The `parameter` and `unit` in the `Observation` class is to follow the Copernicus Marine in-situ TAC physical parameters list:

https://archimer.ifremer.fr/doc/00422/53381/

The `qualityCodes` is to follow the recommendations for in-situ data Near Real Time Quality Control:

https://archimer.ifremer.fr/doc/00251/36230/


The `time` object variable in the `Datapoint` class is to follow the ISO8601 standard and include timezone information.

# Example of use

The code below provides an example of ow to use the classes of the library.

```python
from sfisop.datamodels.tsdatamodel.timeseriesdata import *

a_location = Location(latitude=5.0, longitude=65)

meta_data = MetaData(description="test time series",
                     timeseries="timeseries_testdata",
                     origin="timeseries_testdata")

observation = Observation(source="test sensor",
                          source_id="test sensor id",
                          parameter="temperature",
                          value="5.0",
                          unit="celcius",
                          qualityCodes=[0])

data_point = DataPoint(dp_id="datapoint id",
                       source="test sensor hub",
                       source_id="test sensor hub id",
                       location=a_location,
                       time="2024-02-17T20:12:49.559547+01:00",
                       observations=[observation])

data_points = [data_point]

ts_data = TimeSeriesData(format="SMARTOCEAN_V1",
                         metadata=meta_data,
                         data=data_points)
```

The utility functions implemented in the `tsdata_utils.py` and `timeseriesdata.py` is to be used for serialisation and de-serialisation of time series data.

Further documentation can be found on the SFI Smart Ocean platform web pages: https://smartoceanplatform.github.io/interoperability/