semvec/pypi-packages huggingface dataset:
pyreda 0.1.5
A Python Library for Building the Genetic Algorithm.
Requires Python: >=3.6

# pyreda

`pyreda` is a Python library for implementing and running Genetic Algorithms (GAs). It provides an easy-to-use interface to configure and execute GAs with customizable parameters for selection, crossover, and mutation.

## Features

- Customizable fitness functions
- Support for tournament selection
- One-point crossover
- Bit-flip mutation
- Configurable mutation rates and number of generations

## Installation
You can install `pyreda` via pip:

	pip install pyreda

## Usage

Here’s a basic example of how to use pyreda to run a genetic algorithm:

import SimpleGA from `pyreda`

	from pyreda import SimpleGA
	import numpy as np


Define a custom fitness function

	# Example: Sum of all genes
	def custom_fitness(individual):
		return np.sum(individual)

Create an instance of the SimpleGA class

	ga = SimpleGA.SimpleGA(
		population_size=10,       # Size of the population
		gene_length=5,             # Length of each individual
		fitness_function=custom_fitness,  # Fitness function to evaluate individuals
		mutation_rate=0.01,        # Mutation rate
		generations=20            # Number of generations to evolve
	)

Parameters:

	population_size: Number of individuals in the population.
	gene_length: Length of the individual’s gene sequence.
	fitness_function: Function to evaluate the fitness of an individual.
	mutation_rate: Probability of mutation for each gene.
	generations: Number of generations for the algorithm to run.

## Run the genetic algorithm

	ga.run()


## Contributing
If you’d like to contribute to the development of pyreda, please fork the repository and submit a pull request. We welcome improvements and bug fixes.


## License
pyreda is licensed under the MIT License. See the LICENSE file for details.

## Contact
For questions or support, please contact Reda Ghanem at reda.ghanem66@gmail.com.
streamlit-js-callback 1.0.2
Eval js code with callbaack
Requires Python: >=3.7

# streamlit-js-callback

Eval js code with callbaack.

## Installation instructions

```sh
pip install streamlit-js-callback
```

## Usage instructions

```python
import random
import streamlit as st
from streamlit_js_callback import streamlit_js_callback


print("Start render..")

st.subheader("JS Callback Component")


def use_return():
    result1 = streamlit_js_callback("""
    console.log("eval 1 + 1")
    return 1 + 1
    """)
    if result1:
        st.text("Received by use_return: " + str(result1))


def use_send_message():
    result2 = streamlit_js_callback("""
    console.log("hello")
    sendMessage("hello")
    """)
    if result2:
        st.text("Received by use_send_message: " + str(result2))


def exec_async():
    res = streamlit_js_callback("""
    return await fetch("https://reqres.in/api/products/3").then(function(response) {
        return response.json();
    })
    """)
    if res:
        st.text("Received by exec_async: " + str(res))


def exec_event_listen():
    if st.button("btn1"):
        print("btn1 click")
    result3 = streamlit_js_callback("""
        console.log("init 3..")
        let clickCount = 0
        window.parent.document.querySelectorAll('button[kind="secondary"]').forEach((item) => {
            item.addEventListener("click", function(e) {
                clickCount += 1
                console.log(clickCount)
                sendMessage(clickCount)
            });
        })
    """)
    if result3:
        st.text(f"Received event: {result3}")
        print(f"Received event: {result3}")


use_return()
use_send_message()
exec_async()
exec_event_listen()


# my_key = "my_key"
#
#
# @st.fragment
# def exec_in_context_2():
#     global my_key
#     print("my_key", my_key)
#     result4 = streamlit_js_callback("""
#         const res = String(new Date())
#         console.log(res)
#         return res
#         """, key=my_key)
#     if result4:
#         st.text("Received by exec_in_context: " + str(result4))
#         print(f"Received by exec_in_context: {result4}")
#         my_key = str(random.randint(0, 99999))
#         print("my_key", my_key)
#
#
# @st.fragment
# def exec_in_context():
#     if st.button("btn2"):
#         print("btn2 click")
#         exec_in_context_2()
#         print('exec_in_context finish.')
#
#
# exec_in_context()


print("Finish render")

```
rlai 1.4.0
Reinforcement Learning:  An Introduction
Requires Python: <3.13,>=3.10

Welcome to RLAI. To launch a live graphical interface to the RLAI package, click below:

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/MatthewGerber/rlai/HEAD?urlpath=lab/tree/jupyter/trainer.ipynb)

Please see the [project website](https://matthewgerber.github.io/rlai/) for more information.

Status:
* [![PyPI version](https://badge.fury.io/py/rlai.svg)](https://badge.fury.io/py/rlai)
* [![Run Python Tests](https://github.com/MatthewGerber/rlai/actions/workflows/run-tests-on-push.yml/badge.svg)](https://github.com/MatthewGerber/rlai/actions/workflows/run-tests-on-push.yml)
* [![Coverage Status](https://coveralls.io/repos/github/MatthewGerber/rlai/badge.svg?branch=master)](https://coveralls.io/github/MatthewGerber/rlai?branch=master)
status-checker-api 0.5
Un paquete para verificar el estado de una API.
Requires Python: >=3.12

# API Status Checker

![Example](/img/paste-5.png)

Un paquete para verificar el estado de una API.

## Instalación

```bash
pip install api_status_checker
```

# Uso


```bash
api-status-checker
```

# Ejemplo

```bash
api-status-checker --url https://api.github.com
```
quclo 0.0.5
A CLI tool designed to simplify the execution and management of quantum circuits across multiple backend providers.
Requires Python: <4.0,>=3.12

# QuClo CLI

QuClo CLI is a command-line interface tool designed to simplify the execution and management of quantum circuits across multiple backend providers. This tool leverages the QuClo platform to offer a seamless experience for researchers, educators, and hobbyists in quantum computing.

## Features

- **Execute Quantum Circuits:** Run your quantum circuits on various backend providers.
- **Intelligent Backend Selection:** Choose the best backend based on criteria like cost, speed, fidelity, and queue time.
- **Result Visualization:** Generate comprehensive and easy-to-understand visualizations of your quantum circuit results.
- **Open-Source SDK Integration:** Easily integrate and submit circuits created with other SDKs.

## Installation

To install the QuClo CLI, ensure you have Python installed, then use pip:

```bash
pip install quclo
```

## Usage

CLI:

```bash
quclo --help
```

UI:

```bash
pip install pdoc
pdoc quclo --logo https://quclo.com/assets/quclo-Cg4oDc2h.svg
```

1. Create a new user account:

   ```bash
   quclo create user --email <email> --password <password>
   ```

2. Authenticate with your user account:

   ```bash
   quclo create token --email <email> --password <password>
   ```

3. List available backends:

   ```bash
   quclo get backends
   ```

4. Display details of a specific backend:

   ```bash
   quclo get backend ibm.condor
   ```

5. Execute a quantum circuit:

   **Using priority:**

   ```bash
   quclo create circuit --file <file> --priority <priority>
   ```

6. Get the status or results of a quantum circuit:

   ```bash
   quclo get circuit <circuit_id>
   ```

## Contributing

Contributions are welcome! Please submit a pull request or open an issue to discuss any changes.

## Contact

For any questions or feedback, please contact us at [support@quclo.com](mailto:support@quclo.com).
breseq-ext-cnv 0.0.4
An extension of breseq to determine copy number variations from coverage data
Requires Python: >=3.9

# breseq-ext-cnv
*breseq* copy number variation extension accepts .tab coverage output from [*breseq*](https://github.com/barricklab/breseq.git) BAM2COV and predicts copy number variations across the genome after correcting the biases in read counts introduced by variations in sequencing methods.

**Installation:**

Create python environment. 
```
conda create -n <env-name> python>=3.8
conda activate <env-name>
```
Install breseq-ext-cnv
```
pip install git+https://github.com/barricklab/breseq-ext-cnv.git
```
**Run:**

Run BAM2COV on *breseq* output to get the coverage table: 
```
breseq bam2cov -t[--table] --resolution 0 (0=single base resolution) --region <reference:START-END> --output <filename>
```
With the coverage table as the input determine regions of copy number variation using: 

```
breseq-ext-cnv -i <input file> [-o <output folder location>] [-w <window>] [-s <step size>]
```
```
usage: get_CNV.py [-h] -i I [-o O] [-w W] [-s S] [-ori ORI] [-ter TER] [-f F]

The breseq-ext-cnv is python package extension to breseq that analyzes the sequencing coverage across the genome to determine specific regions that have undergone copy number variation (CNV)

options:
  -h, --help            show this help message and exit
  -i I, --input I       input .tab file address from breseq bam2cov.
  -o O, --output O      output file location preference. Defaults to the current folder.
  -w W, --window W      Define window length to parse through the genome and calculate coverage and GC statistics.
  -s S, --step-size S   Define step size (<= window size) for each progression of the window across the genome sequence. Set = window size if non-overlapping windows.
  -ori ORI, --origin ORI
                        Genomic coordinate for origin of replication.
  -ter TER, --terminus TER
                        Genomic coordinate for terminus of replication.
  -f F, --frag_size F   Average fragment size of the sequencing reads.

Input .tab file from breseq bam2cov. To get the coverage file run the command below in your breseq directory which contains the 'data' and 'output' folders.
'```
breseq bam2cov -t[--table] --resolution 0 (0=single base resolution) --region <reference:START-END> --output <filename>
```'
```
selo-linku 0.0.1
Python library for interacting with sona Linku (the lipu Linku API)
Requires Python: >=3.12

# seloLinkuPason
Python API wrapper for sona Linku

selo Linku Pason is an unoficial API wrapper for [lipu Linku](https://github.com/lipu-linku). lipu Linku is an open-source, collabarative [toki pona](https://tokipona.org/) dictionary. Please note that this code is awful and very much uncommented. This was made in an afternoon and is not intended to be used for anything serious, it’s just for fun. I am not affiliated with the Linku team, full credit goes to them for making such an awesome tool, and making it free for anyone to use.

## Instalation
To install, run:

```
pip install selo-linku
```

## Usage
Import:
```
import selo_linku as selo
linku = selo.apiv1()
```

You can use .reload() to reload cache data:
```
linku.reload()
```
You can use .getwordfromtp() to get a word object from it's toki pona spelling:
```
toki = linku.getwordfromtp(word="toki", sandbox=True)
print(toki.name)
> toki
print(toki.definitions['en'])
> communicate, say, think; conversation, story; language
```

You can find more info at [the docs](docs/README.md)