semvec/pypi-packages huggingface dataset:
MorePie 1.0.1
Does Python not have enough tools? MorePie is here to help!
Requires Python: >=3.10

# MorePie
## FAQ
### What is MorePie?
MorePie is a library made to introduce more features to Python, such as a two-dimensional table of contents and a hand-made HashMap class
## Documentation
### ColumnTypes
ColumnTypes is an Enum class, meaning that the following are its usages:
```py
ColumnTypes.automatic_id # Will return an error if used in a Matrix
ColumnTypes.string
ColumnTypes.integer
ColumnTypes.Real
```
### Column
`Column(name: str, kind: ColumnTypes)` -- Creates a new Columnn
#### Properties
- `Column.name`
- `Column.kind` (equivilant to `Column.type`)
### Matrix
!!  The `Matrix` class is still under work and is not recommended for production. You should use the built-in dictionaries instead! <br>
`Matrix(*columns: Column)` -- Creates a new Matrix <br>
`add_column(*columns: Column)` -- Adds a new column <br>
`add_row(**data)` -- Adds a new row. You need to parse as arguments values for each column you defined in the table <br>
### HashMap
The `HashMap` class should just be initialized with a dictionary or two lists, and behaves similarly to a normal dictionary. We would recommend using the built-in `dict` instead, as the `HashMap` class still has bugs.
### ErrorSuppressor
The `ErrorSuppressor` class is made to be used as a context manager. <br>
Syntax: `ErrorSuppressor(errors: tuple[Exception] = ())` <br>
### sum_of_array(array: np.ndarray)
Returns the sum of all items in an array
### sum_of_arange(arange: np.arange)
Self-Explanatory
### sum_of_range(Range: range)
Self-Explanatory
### execute(command: str)
Execute a console command. (Command behavior may differ based on the operating system) <br>
Is equivalent to doing `os.sys()` <br>
Can also be used as `execute(*commands: str)` to run multiple consecutive commands <br>
## Creator Notes
- `MorePie` is still in-work. We recommend testing it with your code before implementing it into any programs!
- For the best experience, we recommend downloading the [Latest Version](https://pypi.org/project/MorePie/)
st-span-annotation 0.0.8
Streamlit component to annotate text span
Requires Python: >=3.7

# st-span-annotation

Streamlit component to annotate text span

## Usage instructions

```python
from typing import TypedDict

import streamlit as st
from st_span_annotation import st_span_annotation

class Span(TypedDict):
    start: int
    end: int
    label: str
    text: str


text = """Alice and Bob are planning to visit New York next week.
They will be attending a conference on AI."""
labels = ["PERSON", "LOCATION", "DATE", "EVENT"]
initial_spans: list[Span] = [
    {"start": 0, "end": 5, "label": "PERSON", "text": "Alice"},
    {"start": 36, "end": 44, "label": "LOCATION", "text": "New York"},
    {"start": 45, "end": 54, "label": "DATE", "text": "next week"},
    {"start": 81, "end": 97, "label": "EVENT", "text": "conference on AI"},
]
color_palette: dict[str, str] = {
    "PERSON": "lightblue",
    "LOCATION": "lightgreen",
    "DATE": "lightyellow",
    "EVENT": "lightcoral",
}

result: list[Span] = st_span_annotation(
    text=text,
    labels=labels,
    spans=initial_spans,  # optional
    color_palette=color_palette,  # optional
    is_editable=True,  #optional
)

st.write(result)
```
llm-astar 0.1.4
LLM-A*: Large Language Model Enhanced Incremental Heuristic Search on Path Planning.
Keywords: LLMs, route planning, deep learning, neural networks, research, LLMs agent

Abstract
------
Path planning is a fundamental scientific problem in robotics and autonomous navigation, requiring the derivation of efficient routes from starting to destination points while avoiding obstacles. Traditional algorithms like A* and its variants are capable of ensuring path validity but suffer from significant computational and memory inefficiencies as the state space grows. Conversely, large language models (LLMs) excel in broader environmental analysis through contextual understanding, providing global insights into environments. However, they fall short in detailed spatial and temporal reasoning, often leading to invalid or inefficient routes. In this work, we propose **LLM-A***, an new LLM based route planning method that synergistically combines the precise pathfinding capabilities of A* with the global reasoning capability of LLMs. This hybrid approach aims to enhance pathfinding efficiency in terms of time and space complexity while maintaining the integrity of path validity, especially in large-scale scenarios. By integrating the strengths of both methodologies, **LLM-A*** addresses the computational and memory limitations of conventional algorithms without compromising on the validity required for effective pathfinding.

Directory Structure
------
    .
    └── dataset
    └── env
        └── search
    └── model
        ├── chatgpt
        └── llama3
    └── pather
        ├── astar
        └── llm_astar
    └── utils

## ⏬ Installation
```bash
pip install llm-astar
```

## 🚀 Quick Start
```python
import openai
openai.api_key = "YOUR API KEY"

from llmastar.pather import AStar, LLMAStar
query = {"start": [5, 5], "goal": [27, 15], "size": [51, 31],
        "horizontal_barriers": [[10, 0, 25], [15, 30, 50]],
        "vertical_barriers": [[25, 10, 22]],
        "range_x": [0, 51], "range_y": [0, 31]}
astar = AStar().searching(query=query, filepath='astar.png')
llm = LLMAStar(llm='gpt', prompt='standard').searching(query=query, filepath='llm.png')
```

## 📝 Citation
If you found this work helpful, please consider citing it using the following:
```
LLM-A*: Large Language Model Enhanced Incremental Heuristic Search on Path Planning
Silin Meng, Yiwei Wang, Cheng-Fu Yang, Nanyun Peng, Kai-Wei Chang
```

## 💫 Showcase
<br/>
<p align="center"> <img width="1000" src="https://github.com/SilinMeng0510/llm-astar/assets/89226819/36ff049f-4e4e-453b-9454-2d6441ad79c0">

## 🪪 License
MIT. Check `LICENSE`.

[![Downloads](https://static.pepy.tech/badge/llm-astar)](https://pepy.tech/project/llm-astar) ![PyPI - Version](https://img.shields.io/pypi/v/llm-astar)
heatflow 0.0.1
HeatFlow is a python framework to work with neural networks, tensor, etc.
Requires Python: >=3.10

<p align="center">
  <img src="https://github.com/introlix/HeatFlow/blob/main/images/flame_repo.jpeg" width="300"/>
  <h1 align="center">HeatFlow</h1>
</p>

--------------------------------------------------------------------------------

HeatFlow is a python framework to work with neural networks, tensor, etc. It also provides some useful functions for machine learning and deep learning. HeatFlow gives you full control on your code. It is written on top of numpy which makes it blazing fast compared to other. It uses jit to make the code run as fast as possible.

## Get Started

```bash
pip install heatflow
```