semvec/pypi-packages huggingface dataset:
create-app-fastapi 0.1.6
Library for initializing FastAPI project structure - create-app-fastapi
Requires Python: >=3.9
Keywords: create-app-fastapi, create, fastapi, fastapi project, project structure, api structure, python fastapi project structure

# **create-app-fastapi**  

A simple CLI tool for generating FastAPI projects with a predefined structure, including APIs, database setup, models, schemas, and configuration files, enabling a quick start to development.

### **Installation**
To install this package, use the following command:  
```bash
pip install create-app-fastapi
```

### **Usage**
After installation, create a new FastAPI project by running:  
```bash
create-app-fastapi project-name
```
Navigate to the project directory
```bash
cd project-name
```
Start the development server
```bash
fastapi dev main.py
```
Your FastAPI is now up and running on port 8000! 🚀

### **Output**
The generated project will have the following structure:

```
root-folder/
|- APIs/
|  |- __init__.py
|  |- api.py
|- models/
|  |- __init__.py
|  |- model.py
|- schemas/
|  |- __init__.py
|  |- schema.py
|- settings/
|  |- __init__.py
|  |- auth.py
|  |- config.py
|  |- db.py
|- testcase/
|  |- __init__.py
|  |- test_main.py
|- venv/
|-.gitignore
|- main.py
|- requirements.txt
```


### Features

* Predefined project structure for FastAPI applications.
* Includes APIs, models, schemas, and settings files.
* Ready-to-use database connection file (db.py).
* Simplifies setting up new FastAPI projects.


    ------- Happy Coding! 🎉  --------
pymahjong 1.0.4
A Japanese Mahjong environment for decision AI research.
Requires Python: >=3.6


# Japanese Riichi Mahjong

[![PyPI version](https://badge.fury.io/py/pymahjong.svg)](https://badge.fury.io/py/pymahjong)

|Branch| Build |
|:----:|:----:|
|master|[![Build-and-test](https://github.com/Agony5757/mahjong/actions/workflows/build-and-test.yml/badge.svg?branch=master)](https://github.com/Agony5757/mahjong/actions/workflows/build-and-test.yml)|
|develop|[![Build-and-test](https://github.com/Agony5757/mahjong/actions/workflows/build-and-test.yml/badge.svg?branch=develop)](https://github.com/Agony5757/mahjong/actions/workflows/build-and-test.yml)|

Simulator of Japanese Riichi Mahjong (https://en.wikipedia.org/wiki/Japanese_Mahjong) written in C++. [关于C++部分的说明（中文版）](https://github.com/Agony5757/mahjong/blob/master/%E8%AF%BB%E6%88%91.md)


# See [here](https://github.com/Agony5757/mahjong/tree/master/pymahjong) for the Python APIs for e.g., decision AI research.


## Citation
```
@inproceedings{
han2022variational,
title={Variational oracle guiding for reinforcement learning},
author={Dongqi Han and Tadashi Kozuno and Xufang Luo and Zhao-Yun Chen and Kenji Doya and Yuqing Yang and Dongsheng Li},
booktitle={International Conference on Learning Representations},
year={2022},
url={https://openreview.net/forum?id=pjqqxepwoMy}
}
```

## Contact us

Email:    hdqhdq58@outlook.com
QQ group: 608064044
PyShaping 2.3.2
Math functions for 2D and 3D shapes
Requires Python: >=3.0

# PyShaping Library  
A python module for math lovers or just people who needs it.  
  
## Introduction  
The module can calculate the **Areas** and **Perimeters** of 2D shapes.  
The module can calculate the **Volumes** and **Surface Areas** of 3D shapes.  
The module is lightweight, and only requires the python built-in `math` library.  
  
Every function is stored in a shape class.  
  
## Cool Features  
There are functions for 5-point stars' **area** calculation!  
There are functions for ellipsoids and spheroids' **surface area** calculation!  
There are functions for ellipse's **perimeter** calculation!  
  
## 2D Shapes  
There are various shapes!  
Including:  
 - Square
 - Rectangle
 - Triangle
 - Rhombus
 - Parallelogram
 - Kite
 - Circle
 - Trapezoid
 - Ellipse
 - Pentagon (5 side) ~ Dodecagon (12 side)
 - Starfish (5-point star shape)

Usage:  
```
from pyshaping import Pentagon

shape = Pentagon(side=10)
print(f"Area of pentagon with side length 10 is {shape.area()}")
print(f"Perimeter of pentagon with side length 10 is {shape.perimeter()}")

```  
  
## 3D Shapes
There are again, various objects you can use!  
Including:  
 - Cube
 - Prisms (Triangular ~ Dodecagonal)
 - Sphere
 - Hemisphere
 - Sphere Cap
 - Spheroid (Oblate & Prolate)
 - Ellipsoid
 - Torus (Donut shape)
 - Sausage (Wiener Sausage shape)
  
Usage:  
```
from pyshaping import Oblate

shape = Oblate(radius=15, halfheight=5)
print(f"Volume of the oblate spheroid is {shape.volume()}")
print(f"Surface area of the oblate spheroid is {shape.surface()}")

```
DARTassembler 1.0.4
Simple to use package for building 3D structures of novel transition metal complexes from a large database of ligands extracted from the Cambridge Structural Database.
Requires Python: >=3.9


# DART - Directed Assembly of Random Transition metal complexes
Welcome to the DART platform, a cutting-edge suite of tools for the generation and exploration of mono-metallic transition metal complexes! Developed by the CCEM group at Trinity College Dublin, DART is engineered to facilitate the design and analysis of molecular complexes for chemistry research.

DART integrates a collection of modules, each serving a unique function in the assembly process:

- **MetaLig** :
    Explore the comprehensive MetaLig database with 41,018 ligands extracted from the Cambridge Structural Database, complete with high-quality formal charge assignments.

- **Assembler** :
    Assemble novel transition metal complexes in a matter of seconds, guided by a simple configuration file for precise control over the resulting structures.

- **Ligand Filters** :
    Tailor assembled ligands to your research needs with a wide range of chemical and data-driven filters.

Using DART is simple. After download, just run the DART assembler and start generating complexes by executing the following command in your terminal:

    DARTassembler assembler --path assembly_input.yml

## Documentation
The documentation of DART under [https://dartassembler.readthedocs.io](https://dartassembler.readthedocs.io) will show you how to install and use DART.

## How to cite DART
Please cite [our paper](https://chemrxiv.org/engage/chemrxiv/article-details/6717eb4e83f22e4214d2b98b).

## Reproducing the DART paper
The documentation contains a section about the Pd/Ni cross coupling example that was used in the paper. It will show you how to reproduce the results of the paper.

## License
DART is subject to the GPL-3.0-or-later license. See `LICENSE` for more information.

## Origin of data
We are grateful to the providers of the [Cambridge Structural Database](https://www.ccdc.cam.ac.uk/structures/), which is the source of all ligands in the ligand database.
text-format-converter 0.23
text format converter
Requires Python: >=3.8

# TextFormatConverter

**TextFormatConverter** is a Python package for converting text from one format to another—such as converting JSON to Markdown or CSV to XML. It provides both a command-line interface and a Python API so you can integrate it easily into your workflow or other Python projects.

## Table of Contents

- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)
  - [CLI Usage](#cli-usage)
  - [Python API Usage](#python-api-usage)
- [Examples](#examples)
- [Contributing](#contributing)
- [License](#license)

---

## Features

- **Multiple Format Support**: Convert between JSON, Markdown, CSV, XML, and more.
- **Easy to Use**:
  - Command-line tool for quick conversions.
  - Python API for seamless integration into your code.
- **Extensible**: Add or modify converters for new or custom file formats.
- **Lightweight**: Minimal dependencies for fast installation and usage.

---

## Installation

You can install **TextFormatConverter** using pip:

```bash
pip install textformatconverter
poetic-errors 0.1.3
Transform Python errors into delightful poems
Requires Python: >=3.6

# Poetic Error Handler 🌹
Transform your Python error messages into delightful poems! This lightweight error handler converts standard Python errors into poetic form while preserving the original error information.

## Installation
You can install the package using pip:
```bash
pip install poetic-errors
```

## Quick Start
Simply import the module at the start of your Python script:
```python
import poetic_errors
```

That's it! Your error messages will now be displayed as poems.

## Features
- Converts common Python errors into randomly selected poems
- Maintains original error messages for debugging
- Works across all operating systems (Windows, macOS, Linux)
- Handles different error types with specific poem templates:
  - NameError
  - SyntaxError
  - TypeError
  - And a default template for other errors

## Example
If you run code with an undefined variable:
```python
x = y + 1  # y is not defined
```

You'll see output like:
```
.-----------------.
| Poetic Error    |
'-----------------'
Roses are red,
Variables are rare,
On line 1, I looked everywhere,
But y just wasn't there.

Original error: name 'y' is not defined
```

## Development
To contribute or modify the package:

1. Clone the repository:
```bash
git clone https://github.com/JugalKothari/poetic-errors.git
```

2. Install in development mode:
```bash
pip install -e .
```

## Customization
You can add your own poem templates by modifying the `templates` dictionary in the `PoeticErrorHandler` class. Each error type can have multiple poem templates that will be randomly selected.

## Requirements
- Python 3.6 or higher
- No additional dependencies required

## Contributing
Feel free to contribute by:
- Adding new poem templates
- Supporting additional error types
- Improving error detection and formatting
- Suggesting new features

## License
MIT License - Feel free to use and modify!