semvec/pypi-packages huggingface dataset:
fast-marching-square 0.1.1
Fast Marching Square (FM2) is a path planning algorithm based on the Fast Marching Method that solves the Eikonal equation.
Requires Python: >=3.10

# Fast Marching Square

The [Fast Marching Square (FM2) method](https://www.researchgate.net/profile/Santiago-Garrido/publication/305377309_FM2_A_real_Fast_Marching_sensor-based_Motion_Planner/links/59649679aca2728c1129ec03/FM2-A-real-Fast-Marching-sensor-based-Motion-Planner.pdf) is a path planning algorithm which is a variation of the [original Fast Marching Method](https://epubs.siam.org/doi/abs/10.1137/S0036144598347059), which it is based on the idea of guiding the desired path by following light propagation. The path that light follows is always the fastest feasible one, so the proposed planning method ensures the calculation of the path of least possible time. Since the method is based on wave propagation, if there is a feasible solution, it is always found, so it is complete.

This implementation of the Fast Marching Squared method is based on the [Mirebeau implementation](https://github.com/Mirebeau/HamiltonFastMarching), so feel free to visit the repository.

## Installation

Follow the next steps for installing the simulation on your device.

**Requirements:**
- Python 3.10.0 or higher


### Install miniconda (highly-recommended)
It is highly recommended to install all the dependencies on a new virtual environment. For more information check the conda documentation for [installation](https://conda.io/projects/conda/en/latest/user-guide/install/index.html) and [environment management](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html). For creating the environment use the following commands on the terminal.

```bash
conda create -n fm2 python==3.10.9
conda activate fm2
```
### Install from pip

The ADAM simulator is available as a pip package. For installing it just use:
```
pip install fast-marching-square
```

### Install from source
Firstly, clone the repository in your system.
```bash
git clone https://github.com/vistormu/fast_marching_square.git
```

Then, enter the directory and install the required dependencies
```bash
cd fast_marching_square
pip install -r requirements.txt
```

## Documentation
The official documentation of the package is available on [Read the Docs](https://fast-marching-square.readthedocs.io/en/latest/). Here you will find the [installation instructions](https://fast-marching-square.readthedocs.io/en/latest/src/installation.html), the [API reference](https://fast-marching-square.readthedocs.io/en/latest/src/api_reference.html) and some [minimal working examples](https://fast-marching-square.readthedocs.io/en/latest/src/examples.html).
jqlite 0.4.3
An implementation of jq for learning purposes.
Requires Python: >=3.7.0,<4.0.0
Keywords: jq,json,jqlite

# jqlite

![PyPI](https://img.shields.io/pypi/v/jqlite)
![GitHub](https://img.shields.io/github/license/christianzzz/jqlite)
[![codecov](https://codecov.io/gh/christianzzz/jqlite/branch/develop/graph/badge.svg?token=9UE406IALD)](https://codecov.io/gh/christianzzz/jqlite)
[![Tests](https://github.com/christianzzz/jqlite/actions/workflows/tests.yml/badge.svg)](https://github.com/christianzzz/jqlite/actions/workflows/tests.yml)

An implementation of [jq](https://stedolan.github.io/jq/), the commandline JSON processor, for learning and fun.

## Installation

```shell
> pip install jqlite
```

## Examples:
```sh
> echo '{"foo": 0}' | jqlite
{
  "foo": 0
}

> echo '{"foo": [1, 2, 3, 4]}' | jqlite '[.foo | .[] | select(. % 2 == 0) | . * 2]'
[
  4.0,
  8.0
]
```
ckit 0.3.0
Organize and run frequently used commands
Requires Python: >=3.8,<3.12

<p align="center">
  <img alt="ckit logo" width="460" height="300" src="https://raw.githubusercontent.com/fpgmaas/ckit/main/docs/static/ckit-logo.svg">
</p>

---

[![Release](https://img.shields.io/github/v/release/fpgmaas/ckit)](https://img.shields.io/github/v/release/fpgmaas/ckit)
[![Build status](https://img.shields.io/github/actions/workflow/status/fpgmaas/ckit/main.yml?branch=main)](https://github.com/fpgmaas/ckit/actions/workflows/main.yml?query=branch%3Amain)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/ckit)](https://pypi.org/project/ckit/)
[![codecov](https://codecov.io/gh/fpgmaas/ckit/branch/main/graph/badge.svg)](https://codecov.io/gh/fpgmaas/ckit)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/ckit)](https://pypistats.org/packages/ckit)
[![License](https://img.shields.io/github/license/fpgmaas/ckit)](https://img.shields.io/github/license/fpgmaas/ckit)

_ckit_ is a command line utility to help you organise and quickly run frequently used commands.

<p align="center">
<img src="docs/static/ckit.gif"/>
</p>

---
<p align="center">
  <a href="https://fpgmaas.github.io/ckit">Documentation</a> - <a href="https://github.com/fpgmaas/ckit-files/">Example configuration files</a>
</p>

---

## Quickstart

### Installation

_ckit_ can be installed by running

```shell
pip install ckit
```

To get started, run

```bash
ckit init
```

which will prompt to add a `ckit/ckit.yaml` file in the user's home directory for global commands, and/or a `ckit.yaml` file in the current directory for commands specific to the current project.  Alternatively, run

```bash
ckit init --download-global-defaults
```

to get started with a richer set of examples in the global configuration directory, see [ckit-files](https://github.com/fpgmaas/ckit-files/).

To use _ckit_ to run any of the pre-configured commands, simply run

```
ckit
```

## Configuration

_ckit_ can look for configuration in the following two locations:

- In a `ckit.yaml` file in the current directory
- In any `.yaml` file in the the global configuration directory, which is defaulted to `~/ckit`, but which can be overridden with the environment variable `CKIT_HOME`.

An example `.yaml` file could look as follows:

```yaml
test:
  my-command:
    cmd: "echo Hello! My name is: $name. My favourite fruit is: $fruit"
    echo: false
    args:
      - name
      - fruit: apple
```

Which adds the command group `test` wth a single command called `my-command`. When `my-command` is selected to be run, _ckit_ prompts the user for `name` and `fruit` before running the command specified in `cmd`, where `fruit` is defaulted to `apple` if the user does not give any input.

For more details, see the [configuration](https://fpgmaas.github.io/ckit/configuration) section of the documentation.

---

Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
patatas 0.1.1
A powerful package for K-NN regression, data preprocessing, and analysis for Data Science
Keywords: data preprocessing knn regression analysis data science scikit-learn pandas

# Patatas 

[https://pypi.org/project/patatas/](https://pypi.org/project/patatas/)


Patatas is a Python package that provides tools for preprocessing and modeling data using machine learning algorithms.

## Installation

You can install Patatas using pip:

pip install patatas


## Installation

### Usage
Encoding categorical columns
To encode all categorical (object) columns of a pandas DataFrame using Label Encoding, you can use the fritas() function:
```bash

from patatas import fritas
import pandas as pd

# Create a sample DataFrame with categorical columns
df = pd.DataFrame({'Color': ['Red', 'Green', 'Blue'], 'Size': ['Small', 'Medium', 'Large']})

# Encode categorical columns using Label Encoding
df_encoded = fritas(df)

# Show the encoded DataFrame
print(df_encoded)
```


Finding the best value of k for K-NN regression
To find the best value of k (number of neighbors) for K-NN regression based on the mean squared error, you can use the bravas() function:


```bash
from patatas import bravas
import pandas as pd

# Load a sample dataset
df = pd.read_csv('my_dataset.csv')

# Find the best value of k for K-NN regression
best_k = bravas(df, 'target_column')
print(f'The best value of k is {best_k}')
Contributing
Contributions to Patata Poderosa are welcome! To contribute, please follow these steps:
```

Fork the repository and create a new branch for your feature or bug fix.
Write tests for your changes.
Implement your feature or bug fix.
Run the tests and ensure they pass.
Submit a pull request.
License
Patatas is released under the MIT License. See the LICENSE file for more details.
lnschema_wetlab 0.15rc2
Base classes for a wetlab schema (`vvhc`).

[![pypi](https://img.shields.io/pypi/v/lnschema_wetlab?color=%2334D058&label=pypi%20package)](https://pypi.org/project/lnschema_wetlab)

# lnschema-wetlab: Generic bio wetlab (`vvhc`)

Read the [docs](https://lamin.ai/docs/lnschema-wetlab).
V2Ray 1.1
A project that can create a VPN server(Vmess , Vless) using this script from X-UI panels
Requires Python: >=3.10

<!DOCTYPE html>
    <h1>V2Ray Python API</h1>
    <p>This is a Python API for V2Ray that allows users to create and delete V2Ray accounts programmatically. It provides an easy-to-use interface that allows developers to automate the process of creating and deleting accounts.</p>
    <p>[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)</p>
    <h2>Requirements</h2>
    <ul>
        <li>Python 3.x</li>
        <li><code>requests</code> module</li>
    </ul>
    <h2>Usage</h2>
    <h3>Creating an account</h3>
    <p>To create a new V2Ray account, instantiate the <code>V2Ray</code> class and call the <code>create_account</code> method with the following parameters:</p>
    <ul>
        <li><code>protocol</code>: string, must be either <code>'vmess'</code> or <code>'vless'</code></li>
        <li><code>remark</code>: string, the name of the account</li>
        <li><code>total</code>: integer, the total amount of data that the account is allowed to use (in GB)</li>
        <li><code>expire</code>: integer, the number of days until the account expires</li>
        <li><code>port</code>: integer (optional), the port number to use for incoming connections (default is a random port between 11111 and 55555)</li>
        <li><code>alert_id</code>: integer (optional), the alert ID to use for the account (default is 1)</li>
    </ul>
    <pre><code>from v2ray import V2Ray
v2ray = V2Ray('localhost', '8080', 'session_token')

result = v2ray.create_account('vmess', 'My V2Ray Account', 10, 30)
if result:
    print(result)
else:
    print('Failed to create account')</code></pre>
<h3>Deleting an account</h3>
<p>To delete a V2Ray account, call the <code>delete_account</code> method with one of the following parameters:</p>
<ul>
<li><code>by</code>: string, the name of the account to delete</li>
</ul>
<pre><code>from v2ray import V2Ray

v2ray = V2Ray('localhost', '8080', 'session_token')

result = v2ray.delete_account('My V2Ray Account')
if result:
    print(result)
else:
    print('Failed to delete account')</code></pre>
<h2>License</h2>
<p>This code is licensed under the <a href="https://opensource.org/licenses/MIT">MIT License</a>. Feel free to use it in your own projects or modify it to suit your needs.</p>

<h2>Wrote By</h2>
<p>Wrote by @Santrich</p>