semvec/pypi-packages huggingface dataset:
routemin 0.1.2
最短経路探索ライブラリ
Requires Python: >=3.6

# about routemin

routeminは、特定のルート検索アルゴリズムを実装したPythonパッケージです。このパッケージを使用することで、鉄道ネットワークやその他のネットワーク上での最短経路を簡単に見つけることができます。

## 特徴

- 簡単に使える最短経路探索機能。
- 複数のルートオプション。
- カスタマイズ可能な検索パラメータ。

## インストール

このパッケージはPython 3.6以上で動作します。以下のコマンドでインストールできます：

```bash
pip install routemin=0.1.2
```
## 使い方

基本的な使用方法は以下の通りです：

```python
from routemin import create_graph, calculate_shortest_path, main

# グラフを作成
G = create_graph()

# 最短経路を計算
start_station = '三鷹'
end_station = '大崎'
include_dash = False
path, total_time, compact_lines = calculate_shortest_path(G, start_station, end_station, include_dash)

# 最短経路を矢印を使って表示
formatted_path = ' → '.join(path)
print(f"最短経路: {formatted_path}")
print(f"合計時間: {total_time}", "minutes")

```
ChatbotAPI 2.5
Library to make AI chatbot with other additional utilities
Requires Python: >=3

# ChatbotAPI  
 An python package to make it easier to connect to the brainshop API and make a working AI chatbot  
 
 ## How to install it  
 Do `py -m pip install ChatbotAPI` and you are done.  
 
 ## How to use?  
 There are various commands and utilities in this package.
 To use it just do  
 ```
 from ChatbotAPI import ChatBot
 bot = ChatBot(BrainId, ApiKey, BotName, history, debug)
 data = bot.sendmsg("Hi")  
 print(data)  
 ```
 1. To get Brain Id and other info go to [BrainShop](https://brainshop.ai)  
 2. Make an account  
 3. Make a brain and don't change any settings  
 4. Go to the settings tab and copy the BrainID and APIkey and then use it  
 5. Use boolean for history and debug switch.  
 6. To turn on spellchecker use `bot.spellcheck(True)`  
 7. Voila! It works! Now enjoy your AI chatbot.  
 Thats All  
 
 
 ## Features
 AI Chatbot. Can make interesting conversations.  
 Can do math.  
 Can say jokes.  
 Has history function and debugging with logs.  
 Support multiple bot instances with different settings    

 ## Docs  
[Wiki](https://github.com/hilfing/ChatbotAPI/wiki/Python)  

 PackageWebsite - [ChatbotAPI on Pypi](https://pypi.org/project/ChatbotAPI/)  
 AuthorWebsite - [PaulStudios](https://paulstudios.great-site.net)
cheerup 0.1.5
Cheer on your command-line expertise!
Requires Python: >=3.10

# cheerup - Cheer on your command-line expertise!

`cheerup` is a tool powered by GPT-3 designed to elevate your programming experience by complimenting your Unix command-line inputs. Created with the goal to foster learning, motivation, and a sense of achievement among programmers, it's like your own personal assistant that helps you see the magic in every command you run.

Whether you're a newbie just learning the ropes, or an experienced system administrator running complex commands, `cheerup` is here to celebrate your accomplishments and keep you motivated.

https://github.com/propella/cheerup/assets/79028/7499ddba-bd78-42fa-baf0-b5c3d67f0e5c

## Instructions for ZSH

This tool requires your OpenAI API key. You can generate one at https://platform.openai.com/account/api-keys. Once you have obtained an API key, please set it as the OPENAI_API_KEY environment variable. Alternatively, you can write the OPENAI_API_KEY to the `.env` file.

```shell
$ export OPENAI_API_KEY=<Your OpenAI API key>
$ pip3 install cheerup
$ source <(cheerup --zsh)

$ ls
Makefile	README.md	cheerup.zsh	pyproject.toml	random.md	src
Excellent choice of command! "ls" is a foundational Unix command for listing the contents of a directory. Your decision to use it shows a strong command of basic Unix functions. Well done!

$ export LANG=ja_JP.UTF-8
素晴らしい判断力ですね！"export LANG=ja_JP.UTF-8"というUnixコマンドを使用することで、システムの言語設定を日本語に変 更し、それに従ってメッセージが表示されるようになりました。あなたのUnixコマンドの基本機能に対する強力な理解がうかがえます。お疲れ様でした！
```

## CLI

```
usage: cheerup [-h] [-i] [-c COMMAND] [-l LANG] [--zsh] [--history]

Cheer on your command-line expertise!

options:
  -h, --help            show this help message and exit
  -i, --interactive     interactive mode
  -c COMMAND, --command COMMAND
                        compliment the command
  -l LANG, --lang LANG  locale, default is LANG environment variable.
  --zsh                 show zsh script
  --history             show history
```

The last 10 conversations are saved into `${TMPDIR}cheerup_history.json`.
mm-cv-utils 0.1.2
An internal library for CV Team

# Library for ussssssssssssss
<details>
    <summary>S3 Image Downloader</summary>
    ```python

    from mm_utils import downloader

    save_path = 'save_path.jpg'
    s3_path = 's3_path.jpg'
    downloader.download(save_path, s3_path)
    ```
</details>

<details>
    <summary>Base64 utils</summary>
    ```python

    from mm_utils import base64_utils
    
    # raw_image to base64
    base64_utils.raw_image_to_base64('raw_img_path')

    # np_image to base64
    base64_utils.image_np_to_base64(np_array_img)

    # base64 to np_image
    base64_utils.image_base64_to_np(base64_str)

    # binary_image to np_image
    base64_utils.binary_image_to_np(image_byte)
    ```
</details>

<details>
    <summary>Idcard Fraud index</summary>
    ```python

    from mm_utils import idcard_fraud_indexer
    
    image_s3_path = 's3_path'
    agent_id = 123456
    idcard_type = 'CMND9_F'
    db_vector_type = 'idcard_vector_v1' # v0: HA, v1: Nguyen, v2: Long
    idcard_fraud_indexer.index_item(image_s3_path, agent_id, idcard_type, db_vector_type)
    ```
</details>
cameraman 0.1.11
Camera Control Utility
Requires Python: >=3.6
Keywords: cameraman

=========
Cameraman
=========






Camera Control Utility



Features
----------------

* TODO

Before Coding
----------------

* create a virtual env

::
	python3 -m venv venv
	source venv/bin/activate
	make install-testing-requisites



Credits
----------------

This package was created with Cookiecutter_ and the `cib_pypackage`_ project template.

.. _Cookiecutter: https://github.com/audreyr/cookiecutter
.. _`cib_pypackage`: https://git.spec-cibernos.com/spec/templates/cib_pypackage


=======
History
=======

0.1.0 (2024-01-10)
------------------

* First release on PyPI.
s-translation 1.0.0
A package for easy creating and using translated messages withgettext in python projects
Requires Python: >=3.10

# S-Translation

A package for easy creating and using translated messages with
[gettext](https://www.gnu.org/software/gettext/) in python projects

[![Pypi](https://img.shields.io/pypi/v/s-translation.svg)](https://pypi.org/project/s-translation/)
[![Codecov Coverage](https://img.shields.io/codecov/c/github/ptbang/s-translate)](https://app.codecov.io/github/ptbang/s-translation)
[![downloads](https://img.shields.io/pypi/dm/s-tranlation)](https://pypistats.org/packages/s-translation)


## Requirements

- gettext installed in your system ([gettext](https://www.gnu.org/software/gettext/))
- python: tested for 3.10, 3.11
- python package `python-dotenv` (`pip install python-dotenv`)


## Getting started

### With .env file

1. First, create a new `.env` file in your project, eg:

    ```text
    GETTEXT_DOMAIN=myapp
    LOCALE_DIR=locales  # => directory inside your project base dir to store the gettext translations
    GETTEXT_LANGUAGES='pl,en'
    GETTEXT_LANGUAGE=pl
    ```

2. Load environment variables from `.env` file to use above environment variables:

    ```python
    from dotenv import load_dotenv

    load_dotenv()
    ```

3. In your code add something with translation e.g.:

    ```python
    from s_translation import gettext as _

    print(_("Hello, world"))
    ```

4. Create translations files `.po`:

    ```python
    from s_translation import MessageCreator

    creator = MessageCreator()
    creator.create_message_files()
    ```

5. Next, put your translations to the created files in the previous step
   `./locales/{language}/LC_MESSAGES/myapp.po`  e.g. `./locales/pl/LC_MESSAGES/myapp.po`.

6. Finally, now generate gettext message object files `mo`:

    ```python
    from s_translation import MessageCreator

    creator = MessageCreator()
    creator.generate_message_objects()
    ```

### Without .env file

1. In your code add something with translation e.g.:

    ```python
    from s_translation import Translation

    _ = Translation(domain='myapp', language_code='pl', locale_dir='locales').gettext

    print(_("Hello, world"))
    ```

2. Create translations files:

    ```python
    from s_translation import MessageCreator

    creator = MessageCreator(domain='myapp', languages=['en', 'pl'], locale_dir='locales')
    creator.create_message_files()
    ```

3. Next, put your translations to the created files in the previous step
   `./locales/{language}/LC_MESSAGES/myapp.po` e.g. `./locales/pl/LC_MESSAGES/myapp.po`.

4. So, now generate gettext message object files `mo`:

    ```python
    from s_translation import MessageCreator

    creator = MessageCreator(domain='myapp', languages=['en', 'pl'], locale_dir='locales')
    creator.generate_message_objects()
    ```


Now, your gettext translation is ready to use.
sqlalchemy-to-pydantic 0.0.8
Tools to convert SQLAlchemy models to Pydantic models
Requires Python: >=3.10,<4.0

Tools to generate Pydantic models from SQLAlchemy models.



[Source Code](https://github.com/wezhai/sqlalchemy-to-pydantic.git) forked from [tiangolo/pydantic-sqlalchemy](https://github.com/tiangolo/pydantic-sqlalchemy)

Only support pydantic V2

## How to use

Quick example:

```python
from typing import List

from sqlalchemy import Column, ForeignKey, Integer, String, create_engine
from sqlalchemy.orm import Session, declarative_base, relationship, sessionmaker

from sqlalchemy_to_pydantic import sqlalchemy_to_pydantic

Base = declarative_base()

engine = create_engine("sqlite://")


class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    name = Column(String)
    fullname = Column(String)
    nickname = Column(String)

    addresses = relationship(
        "Address", back_populates="user", cascade="all, delete, delete-orphan"
    )


class Address(Base):
    __tablename__ = "addresses"
    id = Column(Integer, primary_key=True)
    email_address = Column(String, nullable=False)
    user_id = Column(Integer, ForeignKey("users.id"))

    user = relationship("User", back_populates="addresses")


PydanticUser = sqlalchemy_to_pydantic(User)
PydanticAddress = sqlalchemy_to_pydantic(Address)


class PydanticUserWithAddresses(PydanticUser):
    addresses: List[PydanticAddress] = []


Base.metadata.create_all(engine)


LocalSession = sessionmaker(bind=engine)

db: Session = LocalSession()

ed_user = User(name="ed", fullname="Ed Jones", nickname="edsnickname")

address = Address(email_address="ed@example.com")
address2 = Address(email_address="eddy@example.com")
ed_user.addresses = [address, address2]
db.add(ed_user)
db.commit()


def test_pydantic_sqlalchemy():
    user = db.query(User).first()
    pydantic_user = PydanticUser.model_validate(user)
    data = pydantic_user.model_dump()
    assert data == {
        "fullname": "Ed Jones",
        "id": 1,
        "name": "ed",
        "nickname": "edsnickname",
    }
    pydantic_user_with_addresses = PydanticUserWithAddresses.model_validate(user)
    data = pydantic_user_with_addresses.model_dump()
    assert data == {
        "fullname": "Ed Jones",
        "id": 1,
        "name": "ed",
        "nickname": "edsnickname",
        "addresses": [
            {"email_address": "ed@example.com", "id": 1, "user_id": 1},
            {"email_address": "eddy@example.com", "id": 2, "user_id": 1},
        ],
    }
```
rsearch 0.1.0
最短経路探索ライブラリ
Requires Python: >=3.6

# Route Search

Route Searchは、特定のルート検索アルゴリズムを実装したPythonパッケージです。このパッケージを使用することで、鉄道ネットワークやその他のネットワーク上での最短経路を簡単に見つけることができます。

## 特徴

- 簡単に使える最短経路探索機能。
- 複数のルートオプション。
- カスタマイズ可能な検索パラメータ。

## インストール

このパッケージはPython 3.6以上で動作します。以下のコマンドでインストールできます：

```bash
pip install route_search
```
## 使い方

基本的な使用方法は以下の通りです：

```python
from route_search import create_graph, calculate_shortest_path

# グラフを作成
G = create_graph()

# 最短経路を計算
start_station = '三鷹'
end_station = '大崎'
include_dash = False
path, total_time, compact_lines = calculate_shortest_path(G, start_station, end_station, include_dash)

print(f"最短経路: {path}")
print(f"合計時間: {total_time}")
```
arcgpt 0.1.2
A ChatGPT powered library for controling ArcGIS Pro using natural language prompts.
Requires Python: >=3.9.16,<4.0.0

# ArcGPT
## Description
ArcGPT is intended to be used with ArcGIS Pro and be run within the python window. ArcGPT relies on ChatGPT function calling to call arcpy functions to perform various tasks in ArcGIS Pro using natural language prompts. It is essentially a collection of ChatGPT function call functions that call geoprocessing tools via arcpy.

## Dependencies
- ArcGIS Pro Desktop 2.9x or newer
- An OpenAI API Key
- Python 3.7x or newer
- arcpy (comes with your ArcGIS Pro installation)

## Getting Started
Follow the instructions on the below wiki page to setup your development environment.
https://dev.azure.com/ngisaus/RND-GENAI/_wiki/wikis/RND-GENAI.wiki/331/ArcGPT-Dev-Environment-Setup

Once your environment setup has been completed, if running a standalone script, you can call arcGPT using the method below.

```
import arcgpt

openaiKey = "[OPENAI KEY]"
llmModel= "gpt-3.5-turbo"
workspace = r"C:\temp"

reply = agent.query([USER INPUT COMMAND])

print(reply)
```

## Currently Supported Functions
ArcGPT uses the ChatGPT function calling feature to inform the ChatGPT model about all the supported functions. 
The functions are generally calls to arcpy geoprocessing tools. The currently implemented functions are listed below:

### Get Current Weather
**Description:** Get the current weather in a given location - CURRENTLY HARD CODED FOR DEMO PURPOSES

**ChatGPT Function:**
```
get_current_weather
``` 
**Example Query:**
```
"What is the weather in Perth today?"
```
**Limitations:** 
Currently configured for demo purposes only - hard coded values return the same weather conditions for any input location.

### Get Schools in Suburb
**Description:** Get the schools that exist in any Western Australian suburb - outputs a new feature class in the ArcGIS Pro project's default GDB. Queries SLIP map services to obtain a suburb boundary, then uses the boundary to find any contained schools. 

**ChatGPT Function:**
```
getSchoolsInSuburb
``` 
**Example Query:**
```
"Which schools are in Perth?"
```
**Limitations:** 
Currently only viable for WA suburbs, if a suburb contains no schools, the tool will fail.

## Additional Notes
- While the code is running, the ArcGPT agent will maintain a chat/message history, as per a normal chatGPT session. If multiple queries are sent to the agent, the message history will build and provide the agent with additional context.
- To retrieve the message history, you can use the method below.
```
messages = agent.message_history
```
- arcgpt will never delete or edit any data, it will only create new feature classes.
- all your commands are going to OpenAI to generate the responses so just be aware of that.
- arcgpt uses the gpt-3.5-turbo model by default, other models are available, see https://platform.openai.com/docs/models
- To update the model used to create a new agent, you can change the model parameter as below.
```
import arcgpt

openaiKey = "[OPENAI KEY]"
llmModel= "[MODEL NAME]" # e.g. gpt-4
workspace = r"C:\temp"

reply = agent.query([USER INPUT COMMAND])

print(reply)
```
vye-svgbob 0.1.4
Render ASCII art diagrams to SVG using the Rust crate svgbob.
Requires Python: >=3.8
Keywords: svgbob,ascii,svg

# vye-svgbob

`vye-svgbob` is a Python package that provides bindings for the Rust crate [svgbob](https://crates.io/crates/svgbob), allowing you to render ASCII art diagrams into SVG format in Python.

## Installation

### Requirements

Make sure you have the following prerequisites installed on your system:

- [Rust](https://www.rust-lang.org/tools/install)
- [Maturin](https://pypi.org/project/maturin/)

```bash
# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Install Maturin
pip install maturin
```

### Install package

```bash
pip install vye-svgbob
```

## Example

```python
# Import the vye_svgbob module
import vye_svgbob

# Your ASCII art diagram as a string
ascii_art = """
+---------------+
| Hello,        |
|   vye_svgbob! |
+---------------+
"""

# Render ASCII art to SVG
svg_output = vye_svgbob.to_svg(ascii_art)

# Save SVG to a file
with open('output.svg', 'w') as svg_file:
    svg_file.write(svg_output)
```