semvec/pypi-packages huggingface dataset:
expected-value-tb 0.0.1
A simple package which calculates the total probability and expected value of the outcome data type
Requires Python: >=3.8

# Expected Value Package

This is a simple package which offers functions to calculate the expected value and the total probability for the outcome data type. 

# Importing

You can import the expected value package by:
``` 
from expected_value import expected_value
```

# Using Expected Value

You can use the Expected Value command using:
```
o1 = outcome.Outcome("win", float(2), probability.Probability(.5))
o2 = outcome.Outcome("tie", float(10), probability.Probability(.1))
o3 = outcome.Outcome("lose", float(-1), probability.Probability(.4))

os = [o1, o2, o3]

print(expected_value(os))
```
which will output 1.6.

You can use the permutations (where order does matter) command using:
```
o1 = outcome.Outcome("win", float(2), probability.Probability(.5))
o2 = outcome.Outcome("tie", float(10), probability.Probability(.1))
o3 = outcome.Outcome("lose", float(-1), probability.Probability(.4))

os = [o1, o2, o3]

print(total_probability(os))
```
which will output 1.0.
sbcli-dm-alsh 1.1.8
CLI for managing SimplyBlock cluster


# Simply Block
[![Docker Image Build](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/docker-image.yml)

[![Python Unit Testing](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml/badge.svg)](https://github.com/simplyblock-io/sbcli/actions/workflows/python-testing.yml)


## Install
Add the package repo from AWS CodeArtifact using [awscli](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

```bash
aws codeartifact login --tool pip --repository sbcli --domain simplyblock --domain-owner 565979732541 --region eu-west-1
```
Install package
```bash
pip install --extra-index-url https://pypi.org/simple sbcli-dev
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
Please see this document
[README.md](../main/simplyblock_cli/README.md)


## Simply Block Web API
Please see this document
[README.md](../main/simplyblock_web/README.md)



### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```

setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.


```
sudo docker compose -f docker-compose-dev.yml up --build -d
```
shinylive-deploy 2024.8.8
CLI utility to help deploy py-shinylive apps to hosted webservers via SSH.

shinylive export ./src_dev/app2 ./staging/app2 && rm -r ./src_test_webserver/shinyapps/app2 && mv ./staging/app2 ./src_test_webserver/shinyapps/

### Separate Commands
- Fresh deploy
```shell
shinylive export ./src_dev/app2 ./staging/app2
mv ./staging/app2 ./src_test_webserver/shinyapps/
```

- Redeploy
```shell
shinylive export ./src_dev/app2 ./staging/app2
rm -r ./src_test_webserver/shinyapps/app2
mv ./staging/app2 ./src_test_webserver/shinyapps/
```

### Single Commands
- Fresh deploy
```shell
shinylive export ./src_dev/app2 ./staging/app2 && \
mv ./staging/app2 ./src_test_webserver/shinyapps/
```

- Redeploy
```shell
shinylive export ./src_dev/app2 ./staging/app2 && \
rm -r ./src_test_webserver/shinyapps/app2 && \
mv ./staging/app2 ./src_test_webserver/shinyapps/
```

### SSH/SFTP/PSCP
- Copy directory and contents using Putty PSCP
```
pscp -r -i staging\app1\ user@host:/homes/user/docker_volumes/shinyapps/
```
eventiq-msgpack 0.2.0
MessagePack encoder for eventiq
Requires Python: >=3.9

![Tests](https://github.com/asynq-io/eventiq-msgpack/workflows/Tests/badge.svg)
![Build](https://github.com/asynq-io/eventiq-msgpack/workflows/Publish/badge.svg)
![License](https://img.shields.io/github/license/asynq-io/eventiq-msgpack)
![Mypy](https://img.shields.io/badge/mypy-checked-blue)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
![Python](https://img.shields.io/pypi/pyversions/eventiq-msgpack)
![Format](https://img.shields.io/pypi/format/eventiq-msgpack)
![PyPi](https://img.shields.io/pypi/v/eventiq-msgpack)

# eventiq-msgpack

MessagePack encoder for eventiq


## Installation

```shell
pip install eventiq-msgpack
```
pygentest 0.0.8
Python test generators
Requires Python: >=3.8
Keywords: Python test, generator, testing, competitive programming, test generation, pygentest, test library

pygentest - Python Test Generators
===

<p>
<code>pygentest</code> is a Python library supporting several data generators. 

With <code>pygentest</code>, you can generate several type of data, from the simple like random ***character*** or ***string***, to the more complex such as ***graph***, ***tree***, ***convex lattice polygon***.
</p>

**You are very welcome to:**
- Install and use <code>pygentest</code>.
- Give feedbacks.
- Report issues and bugs.
- Provide ideas to improve this library.

<h2> Installation </h2>

<p>
You can simply install <code>pygentest</code> with <a href="https://pypi.org/project/pip/">pip</a>.

```
pip install pygentest
```
</p>

<h2> Other information </h2>

Currently, documentation is written for every function and class in <code>pygentest</code>. You can access it by using Python built-in <code>help</code> function. You can also read the documentation <a href=#Documentation>here</a>.

Detailed instruction has not been written yet, and it will be completed soon.

In the future, I will write a document that analyzes intuition, complexity, and efficiency of each generator.

The inspiration of this personal project comes from my task as an Algorithm Collaborator in <a href="https://www.facebook.com/code.mely/">Code Mely</a>: prepare problems for a contest and generate tests for each problem. I decided to write a Python library that could help generate complex structures, instead of rewrite the code many times.
eventiq-fastapi 0.1.0
FastAPI integration for eventiq
Requires Python: >=3.9
Keywords: eventiq, fastapi

![Tests](https://github.com/asynq-io/eventiq-fastapi/workflows/Tests/badge.svg)
![Build](https://github.com/asynq-io/eventiq-fastapi/workflows/Publish/badge.svg)
![License](https://img.shields.io/github/license/asynq-io/eventiq-fastapi)
![Mypy](https://img.shields.io/badge/mypy-checked-blue)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
![Python](https://img.shields.io/pypi/pyversions/eventiq-fastapi)
![Format](https://img.shields.io/pypi/format/eventiq-fastapi)
![PyPi](https://img.shields.io/pypi/v/eventiq-fastapi)

# eventiq-fastapi

FastAPI integration for eventiq


## Installation

```shell
pip install eventiq-fastapi
```

## Usage

```python
from fastapi import FastAPI
from eventiq import Service, CloudEvent
from eventiq_fastapi import ServiceDependency, get_service_lifespan


service = Service(...)
app = FastAPI(lifespan=get_service_lifespan(service))

# possibly in dirrerent file/router, service will be injected
@app.post("/send-email")
async def send_mail(service: ServiceDependency):
    await service.send({"some": "data"}, topic="commands.send-email")
```
PQEnalyzer 0.7.0
A package that help analyze PQ energy and parameter output.
Requires Python: >=3.10

<img src="https://raw.githubusercontent.com/MolarVerse/PQEnalyzer/main/PQEnalyzer/icons/icon.png" width="200">

[![CI](https://github.com/MolarVerse/PQEnalyzer/actions/workflows/ci.yml/badge.svg)](https://github.com/MolarVerse/PQEnalyzer/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/MolarVerse/PQEnalyzer/graph/badge.svg?token=GMLrCKFfPA)](https://codecov.io/gh/MolarVerse/PQEnalyzer)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# PQEnalyzer
Energy and Parameter Analyzer for Molecular Dynamic Trajectories - PQ

## Installation
    
Install with pip:

    pip install PQEnalyzer

## Usage

Open the GUI by calling the PQEnalyzer via the CLI and supplying a .en file from the PQ trajectory:

    pqenalyzer pq_output.en
pyTuft 1.0.0
A Truffle-like tool for Python smart contracts
Requires Python: >=3.6

# pyTuft

A Truffle-like tool for managing Python smart contracts on Omne.

## Installation

### Prerequisites

Make sure you have the following installed:
- Python 3.6+

## Installing pyTuft

```sh
pip install pyTuft
```

## Configuration

Create a `pyTuft_user_config.py` file in your project directory with the following content:

```python
BLOCKCHAIN_URL = 'http://localhost:5000'
DEPLOYER_ADDRESS = '0xYourAddress'
```

## Usage

### Compile a Contract

```sh
pyTuft compile <contract>
```

## Deploy a Contract

```sh
pyTuft deploy <contract>
```
## Execute a Contract

```sh
pyTuft execute --contract_id <contract_id> --function_name <function_name> --args <arg1> <arg2>
```

## Byte-compiled / optimized / DLL files

## Running Tests

```sh
pyTuft test
```

## License

This project is licensed under the MIT License.
crimson-faiss-indexer 0.1.0
Your package description.
Requires Python: >=3.9

**Template README.md**\
This file is from the [template repository](https://github.com/crimson206/template/blob/main/README.md).
Rewrite it for your own package.

## Python Package Setup

### Setup Base

To install required pip modules for `generate_toml.py`, run
``` bash
source scripts/setup_base.sh
```

### User Setup

- go to `generate_toml.py` file, and complete the setup in the `User Setup` session.

```python
options = Options(
    # Will you use the discussion session in your repo?
    discussion=False
)

# Define the general information of your package
kwargs = Kwargs(
    name_space="None",
    module_name="None",
    description="None",
)
```

If you wrote all the information, run
```
python generate_toml.py
```

#### Template

If you want to understand the generation process, check the `template` variable in `generate_toml.py`.

### Setup Env

#### Prerequisite

Finish [User Setup](#user-setup) first.
Of course, conda command must be available.

#### Setup Env

Run
``` bash
source scripts/setup_env.sh
```

steps
- create an conda environment named as your $MODULE_NAME
- activate the environment.
- install requirements.txt

#### Generate Private Env
Generate a private repository in this repo.
I recommend you to write all the unstructured codes in this repo.

``` bash
source scripts/generate_dev_repo.sh
```

It will ask you the name of your repo, and then, generate a repo named f'{your_repo_name}-dev'.

**Usage Tip**

If you wrote your codes in a wrong branch,
- backup the files to the dev repo
- remove changes in your main(not main branch) repo
- move to your correct branch
- place back the backup codes


## Workflows

I currently setup test and release workflows.

**Test**

If you make a PR with the patterns [ main, develop, 'release/*', 'feature/*' ],

It will perform your unittest in ["3.9", "3.10", "3.11"]

**Release**

required secret : PYPI_API_TOKEN

I usually make PRs only when I start release branches.
release workflow is not conducted automatically. If you think your branch is ready to be published, 

- go to https://github.com/{github_id}/{repo_name}/actions/workflows/release.yaml
- find the button, 'Run workflow'
- select the branch to publish. In my case, release/x.x.x
noplaintext 0.4.1
An application for generating and managing encryption keys and encrypting/decrypting messages.
Requires Python: >=3.8

# noplaintext

## Overview

noplaintext is a module that is intended to eliminate hard-coded credentials in scripts by encrypting them using a external key file. This means that only the encrypted credentials are visible and can only be decrypted with a key file that can be stored in a directory not accessible from a github repository, network drive, or wherever else the source code made be. There is a graphical application to generate a key file and encrypt credentials.

## Project Structure
```
/project-root
   /src
      /crypto_utils
         __init__.py
         crypto_utils.py
         README.md
            /gui_app
            __init__.py
            gui_app.py
            README.md
   
   README.md
   pyproject.toml
   requirements.txt
```

- `/src/crypto_utils`: Contains the cryptographic utility functions for key generation, loading, encryption, and decryption.
- `/src/gui_app`: Contains the GUI application that interacts with the user to perform cryptographic operations.
- `/tests`: Contains tests for the cryptographic utilities.

## Installation

1. **Clone the repository:**

    ```bash
    git clone https://github.com/Sluke950/noplaintext.git
    ```

2. **Navigate to the project directory:**

    ```bash
    cd noplaintext
    ```

3. **Install dependencies:**

    ```bash
    pip install -r requirements.txt
    ```

4. **Run the GUI application:**

    ```bash
    python src/noplaintext/gui_app/gui_app.py
    ```

## Dependencies

- `tkinter` (included with Python)
- `cryptography`
- `logging`

## Usage

1. **Generate Key:** Click the "Generate Key" button to create a new encryption key and save it to a file.
2. **Load Key:** Click the "Load Key" button to load an existing key from a file.
3. **Encrypt Message:** Enter a message and click "Encrypt" to encrypt it using the loaded key.
4. **Decrypt Message:** Enter an encrypted message and click "Decrypt" to decrypt it using the loaded key.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing

If you want to contribute to this project, please fork the repository, make your changes, and submit a pull request. All contributions are welcome!
be-datahive 0.1.3
A Python wrapper for the BEDATAHIVE API

# be-datahive

[![image](https://img.shields.io/pypi/v/be_datahive.svg)](https://pypi.python.org/pypi/be_datahive)
 
Python library for the [BE-dataHIVE
API](https://be-datahive.com/documentation.html).

# Installation

`be_datahive` is available on
[PYPI](https://pypi.python.org/pypi/be_datahive/). Install with `pip`:

``` bash
pip install be_datahive
```

# Get Started

Create an `api` object for interacting with the API:

``` python
from be_datahive import be_datahive
api = be_datahive()
```

Obtain efficiency & bystander data:

``` python
efficiency_data = api.get_efficiency()
bystander_data = api.get_bystander()
```

Convert efficiency & bystander data into machine-ready arrays:

``` python
ef_features, ef_target, variable_info = api.get_efficiency_ml_arrays(efficiency_data, target_col = "efficiency_full_grna_reported", encoding='hilbert-curve', clean=True, flatten=True)
by_features, by_target, variable_info = api.get_bystander_ml_arrays(bystander_data, encoding='one-hot', bystander_type = 'edited', clean=True, flatten=True)
```
# API Documentation

The Python wrapper uses the BE-dataHive API which is accessible at the endpoint (https://be-server.herokuapp.com). 
The detailed API documentation, describing all endpoints, query parameters, and response schema, can be viewed [here](https://be-datahive.com/documentation.html).


# Troubleshooting

If you encounter any issues while using the `be_datahive` library, please refer to the common issues listed below:

1. **Installation issues**: Make sure you have the latest version of `pip` and Python installed. Use `pip install --upgrade pip` to upgrade pip if necessary.
2. **API Connection Errors**: Check your internet connection and ensure that the API endpoint (https://be-server.herokuapp.com) is reachable.
3. **Data Retrieval Issues**: Ensure that you are using the correct function names and parameters as outlined in the documentation.

If your issue is not listed here or you need further assistance, please open an issue on GitHub or reach out directly.

# Reporting Issues

If you have any problems, you can open an issue on GitHub in the following format:

**Title**: [Brief description of the issue]

**Description**:
1. **Summary**: A detailed description of the issue.
2. **Steps to Reproduce**: Step-by-step instructions to reproduce the issue.
3. **Expected Result**: What you expected to happen.
4. **Actual Result**: What actually happened.
5. **Software**: Operating system and Python version.
6. **Additional Information**: Any other information that may help us resolve the issue.

Alternatively, you can reach out directly to Lucas Schneider at [lucas.schneider@cs.ox.ac.uk](mailto:lucas.schneider@cs.ox.ac.uk).


# Citation
When using the [BE-dataHIVE
API](https://be-datahive.com/documentation.html), please cite our paper as outlined below. 

```bibtex
@article{Schneider.2023,
    title = "BE-dataHIVE: a Base Editing Database",
    author = "Lucas Schneider, Peter Minary",
    year = "2024",
}
```
rhotermpredict 3.4
RhoTermPredict (Barrick Lab Fork)

# RhoTermPredict

RhoTermPredict algorithm in python language

RhoTermPredict is an algorithm for the prediction of Rho-dependent transcription terminators in bacterial genomes. It searchs for a putative RUT site followed by a putative pause site for RNA polymerase (hairpin structure and/or pause-consensus element).

INPUT: genome sequences file in fasta format

OUTPUT: a csv file containing the coordinates of predicted Rho-dependent terminators and a txt file cointaining some informations about predictions
pejmanai-summarizer 1.1.1
A simple text summarizer package using transformers and BART.
Requires Python: >=3.6

# PejmanAI Summarizer

* `pejmanai-summarizer` is a Python package that provides text summarization functionality using the * * `facebook/bart-large-cnn` model from the Hugging Face `transformers` library.

## Installation

- `pip install pejmanai-summarizer`

## Usage

- `from pejmanai_summarizer import summarize_text`

- `text = "Your long text goes here..."`
- `summary = summarize_text(text, max_length=150, min_length=30, do_sample=False)`
- `print(summary)`

* Note: You can change summaize_text function parameters (max_length: int = 150, min_length: int = 30)
sucrose-ollama 0.1.1
Add your description here
Requires Python: >=3.8

# Sucrose

Inspired by `fructose` https://github.com/bananaml/fructose, but uses the ollama python client. Supports `pydantic` models.

```
pip install sucrose_ollama
```

```python
from sucrose import Sucrose
ai = Sucrose()

@ai
def describe(animals: list[str]) -> str:
  """
  Given a list of animals, use one word that'd describe them all.
  """
  ...

description = describe(["dog", "cat", "parrot", "goldfish"])
print(description) # -> "pets" type: str
```
noplaintext-Sluke950 0.3.0
An application for generating and managing encryption keys and encrypting/decrypting messages.
Requires Python: >=3.8

# noplaintext

## Description

noplaintext is a Python application for generating and managing encryption keys, as well as encrypting and decrypting messages. This tool uses the `cryptography` library to ensure secure encryption and decryption operations.

## Features

- **Generate Key**: Create and save a new encryption key.
- **Load Key**: Load an existing encryption key from a file.
- **Encrypt Message**: Encrypt messages using a provided key file.
- **Decrypt Message**: Decrypt messages using a provided key file.

## Installation

To set up the project, follow these steps:

1. **Clone the Repository:**

   ```bash
   git clone https://github.com/Sluke950/noplaintext.git
   cd noplaintext