semvec/pypi-packages huggingface dataset:
pyhpp 0.1.5
Algorithms for Three Dimensional Path Planning
Requires Python: >=3.6

pyhpp
======
#### Python Package for Path Planning Algorithms ####

[![GitHub license](https://img.shields.io/github/license/Kun-Neng/hpp)](https://github.com/Kun-Neng/hpp/blob/main/LICENSE)

Steps
------
* Step 1: import A* algorithm
```python
from pyhpp.a_star import AStar
```

* Step 2: prepare a JSON type scenario, e.g.,
```python
scenario = {
    "dimension": {"x": 10, "y": 10, "z": 10},
    "waypoint": {
        "start": {"x": 5, "y": 9, "z": 2},
        "stop": {"x": 5, "y": 0, "z": 4},
        "allowDiagonal": False
    },
    "data": {
        "size": 16,
        "x": [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7],
        "y": [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6],
        "z": [2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5]
    },
    "boundary": {
        "zCeil": 6,
        "zFloor": 1
    }
}
```
> `dimension`: [required] whole dimension of the scenario. Two dimensional scenario can be set up when `"z": 0`<br>
> `waypoint`: [required] start and stop positions (default `allowDiagonal` is `False`)<br>
> `data`: obstacle data (set as empty if none)<br>
> `boundary`: the z-axis boundary of path for calculation<br>

* Step 3: create an A* instance
```python
a_star = AStar(scenario)
```

* Step 4: calculate and get the results
```python
result = a_star.calculate_path()

visited_Q = result["visited_Q"]
final_Q = result["final_Q"]
path = result["path"]
```
This returned `result` contains the following main properties
> `visited_Q`: all the visited positions<br>
> `final_Q`: all the positions in the A* path<br>
> `path`: the A* path array from start to stop<br>
> `refined_path`: the A* path with minimum number of points<br>

and some useful information
> `message`: the information about path planning<br>
> `elapsed_ms`: the running milliseconds of path planning
phx-events 0.4.1
AsyncIO Phoenix Channels client for fast asynchronous message handling
Requires Python: >=3.9,<4
Keywords: asyncio,channels,phoenix,websockets

# PHX Events

![PyPI](https://img.shields.io/pypi/v/phx_events)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/phx_events)
![GitHub](https://img.shields.io/github/license/AceFire6/phx_events)

[![Test PHX Events](https://github.com/AceFire6/phx_events/actions/workflows/run_tests.yml/badge.svg)](https://github.com/AceFire6/phx_events/actions/workflows/run_tests.yml)
[![Lint Python](https://github.com/AceFire6/phx_events/actions/workflows/lint_python.yml/badge.svg)](https://github.com/AceFire6/phx_events/actions/workflows/lint_python.yml)
[![Lint Github Workflows](https://github.com/AceFire6/phx_events/actions/workflows/lint_workflows.yml/badge.svg)](https://github.com/AceFire6/phx_events/actions/workflows/lint_workflows.yml)

PHX Events is an AsyncIO library to set up a websocket connection with 
[Phoenix Channels](https://phoenixframework.readme.io/docs/channels) in Python 3.9+.

Check out the [`phx_event` documentation](https://acefire6.github.io/phx_events/stable/)

## Installing PHX Events

### From Pip
```shell
pip install phx-events
```

### From Source
Clone the Git repo and then install the dependencies
```shell
pip install -r requirements/core.txt
```

## Use the client in your code:

```python
import asyncio
from concurrent.futures import ThreadPoolExecutor

from phx_events.client import PHXChannelsClient
from phx_events.phx_messages import ChannelMessage, Event, Topic


def print_handler(message: ChannelMessage, client: PHXChannelsClient) -> None:
    client.logger.info(f'DEFAULT: {message=}')


async def async_print_handler(message: ChannelMessage, client: PHXChannelsClient) -> None:
    client.logger.info(f'ASYNC: {message=}')


async def main() -> None:
    token = 'auth_token'
    client: PHXChannelsClient

    with ThreadPoolExecutor() as pool:
        async with PHXChannelsClient(token) as client:
            client.register_event_handler(
                event=Event('event_name'),
                handlers=[
                    print_handler,
                    async_print_handler,
                ],
            )
            client.register_topic_subscription(Topic('topic:subtopic'))

            await client.start_processing(pool)


if __name__ == '__main__':
    asyncio.run(main(), debug=True)
```

## Developing

This project uses [`pip-tools`](https://github.com/jazzband/pip-tools/) to manage dependencies.

Before contributing ensure you agree to the [DCO](https://developercertificate.org/).
Commits contributed to this project need to be signed in `git`.

This can be done as follows (**Note** `-s` is a shortcut for `--signoff`) :

```shell
git commit --signoff
```

### 1. Create a virtualenv

Note: Creating the virtualenv can be done however you want. We will assume you've done created a new
virtualenv and activated it from this point.

### 2. Install `pip-tools`:

```shell
pip install pip-tools
```

### 3. Install Dependencies

```shell
pip-sync requirements/core.txt requirements/dev.txt 
```
scalabis 1.1
A Python3 module for fast & easy sequence comparison.
Keywords: sequence,mismatch,comparison

# Welcome to scalabis
A Python3 module for fast & easy sequence comparison

scalabis is built on numba and numpy, taking advantage of JIT compiled functions for speedy mismatched sequence comparisons.

# Instructions

Install scalabis using pip:

`pip install scalabis`

Import it as any other python module:

`import scalabis as sc`


Usage examples. See help(function) after import for more use details:

`sequence1 = "pihton"`

`sequence2 = "Hello there, this is a test for a fast & easy mismatch matching python module. Allegedly, it is efficient"`

count by how many mismatches 2 same lenght sequences diverge:

`sc.mismatch_counter(sequence1,sequence2)`

find one sequence in another, with mismatches. return_template=True returns 

`sc.find(sequence1,sequence2,mismatch=1)`

without return in a class

`sc.find(sequence1,sequence2,mismatch=2,dict_return=False)`

compare two sequences, searching from the search sequence from a specified starting point (default=0), 
returning the full aligned matrix whrere mismatches are 1, and matches are 0. 
Mismatches are the total mismatches in the compared matrix

`sc.comparefromfound(sequence1,sequence2,mismatch=0,start=0,dict_return=True)`

compare two sequences, returning all the locations in which they differ

`sc.compareandlocate(start=0,search=sequence1,template=sequence2)`

compare two sequences, returning the full aligned matrix. starting point can be specified

`sc.compare(search=sequence1,template=sequence2,start=0,dict_return=False)`