semvec/pypi-packages huggingface dataset:
RBFMeshGen 1.0.5
A Python package for generating random meshes based on radial basis functions.
Requires Python: >=3.6

# RBFMeshGen

RBFMeshGen is a Python package designed for the generation and visualization of random mesh points within specified geometric boundaries using Radial Basis Functions (RBF) and other mesh generation techniques. The package provides tools to create, manipulate, and visualize complex mesh structures effectively in Python.

## Features

- **Geometric Boundary Definitions**: Define complex boundaries using parametric functions.
- **Mesh Generation**: Generate meshes based on defined geometric borders, ensuring points adhere to specified orientations and distributions.
- **Visualization Tools**: Visualize meshes and geometric borders, supporting both individual and collective plot displays.
- **Utility Functions**: Includes utility functions to calculate mesh orientations and handle geometric calculations.

## Installation

To install RBFMeshGen, simply clone this repository and use the setup file to install the package:

```bash
pip install RBFMeshGen
```


## Usage

```python
import numpy as np
from RBFMeshGen import RBFMesh, plot_mesh, Border


# Define a parametric function for a circle
def circle_parametric_function(radius, t):
    return radius * np.cos(t), radius * np.sin(t)


# Define the borders of the mesh
outer_radius = 1.0
inner_radius = 0.5

border_outer1 = Border(parametric_function=lambda t: circle_parametric_function(outer_radius, t), label=1, t_start=0,
                       t_end=np.pi)
border_outer2 = Border(parametric_function=lambda t: circle_parametric_function(outer_radius, t), label=1,
                       t_start=np.pi, t_end=2 * np.pi)
border_inner1 = Border(parametric_function=lambda t: circle_parametric_function(inner_radius, t), label=1, t_start=0,
                       t_end=2 * np.pi)

# Generate a random mesh
random_mesh = RBFMesh(border_outer1(100), border_outer2(200), border_inner1(-100))

# Generate points
num_points = 10000
random_mesh.generate_points(num_points)

# Plot the points
plot_mesh(random_mesh)
```

![Output Mesh Visualization](docs/images/Example_1.png)

## Contributing

Contributions to RBFMeshGen are welcome! Please feel free to fork the repository, make changes, and submit pull requests. You can also open issues to discuss potential changes or report bugs.

## License
RBFMeshGen is released under the MIT License. See the LICENSE file in the repository for full details.
szkGraph 0.0.3
An easy graph formatting tool for matplotlib
Requires Python: >=3.9

# szkGraph - simple style formatter for matplotlib
This is a useful Python codes to simply modify the style of matplotlib for your presentation and academic papers.
Any type of suggestions, feedbacks, and upgrades are welcome.

# How to install?
Install using pip.

`python -m pip install -U szkGraph`

Then, import as follows.

`import szkGraph.formatter`

# How to use?
Call `formatter.prepare()` to initialize the figure. Use the returned `fig, ax` for plotting.
After plotting and modifying your figure, export the figure with `formatter.finalize()`. 

## `formatter.prepare(xtitle=None, ytitle=None, w=None, h=None, r=0.7, font="arial", fontsize=20)`
### Paramters
* **xtitle**: _str, optional_
    Title of x-axis.
* **ytitle**: _str, optional_
    Title of y-axis.
* **w**: _float or str, optional_
    Float for specifying the width in inches, str for specifying the width relative to powerpoint slide or academic paper.
    Use `pp1/X` for one-X-th of powerpoint slide (16:9), `ppX` for X times of powerpoint slide (16:9), and `1col` etc. for figures in academic paper.
* **h**: _float, optional_
    Height in inches.
* **r**: _float, optional_
    Ratio of height to width.
* **font**: _str, optional_
    Fontname. It should be either `arial` or `times`.
* **fontsize**: _int, optional_
    Fontsize in pt.

### Returns
* **fig**: _matplotlib.figure_
* **ax**: _matplotlib.axes_


## `formatter.finalize(fig, ax, fn_figout, lims=[None, None, None, None], dpi=300, comp={}, tight=True, pad=0.2, xspace=None, yspace=None)`
### Paramters
* **fig**: _matplotlib.figure_
* **ax**: _matplotlib.axes_
* **fn_figout**: _str_
    Name of the output figure file. It could also be in absolute or relative path.
* **lims**: _list of floats, optional_
    Range of axis in one list as `[xmin, xmax, ymin, ymax]`.
* **dpi**: _int, optional_
    Value of dpi.
* **pil_kwargs**: _dict, optional_
    Dictionary that will be directly passed to `PIL.Image.Image.save`.
* **tight**: _bool, optional_
    Whether to use [`matplotlib.pyplot.tight_layout()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.tight_layout.html).
* **pad**: _float, optional_
    Padding for [`matplotlib.pyplot.tight_layout()`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.tight_layout.html).
* **xspace**: _float or tuple of floats_
    Float for specifying x-tick spacing, tuple of floats for specyfing (x-tick spacing, offset). See [`matplotlib.ticker.MultipleLocator()`](https://matplotlib.org/stable/api/ticker_api.html#matplotlib.ticker.MultipleLocator).
* **yspace**: _float or tuple of floats_
    Float for specifying y-tick spacing, tuple of floats for specyfing (y-tick spacing, offset). See [`matplotlib.ticker.MultipleLocator()`](https://matplotlib.org/stable/api/ticker_api.html#matplotlib.ticker.MultipleLocator).

### Returns
* **fig**: _matplotlib.figure_
* **ax**: _matplotlib.axes_


# License
szkGraph is available under MIT license. See the LICENSE file for more info.
samgob 1.2.0
A simple dice rolling languge embeded in python
Requires Python: >=3.8

# SamGob

## Samon Goblin

### for all of the dice goblins in the world


samgob is a simple script for parsing the pydice programming language!

samgob is a small language designed to be run in a terminal environment and concisely roll dice.
The idea is to use consice syntax in order to describe complex rolls in simple ways.

as a taste a simple query to generate 100 characters by rolling 4 d 6 dropping the lowest value and re rolling
ones and twos can be run with the following instructions

-100S -6 s3T4D{2-6}

at a future date I should upate this page with more help specs for the language, but for now have this simple example :).
python-ndev-blizzardapi 0.2.3
Python module created to integrate your Python project with the Blizzard API

# Python - NDEV Blizzard API
This package is designed to make it easy to use the [Blizzard API](https://develop.battle.net/documentation) in Python. It handles authentication, the details of making requests, and receives the responses. It also provides a simple interface for accessing each of the API's features.

## Documentation

- [Read the Docs](https://python-ndev-blizzardapi.readthedocs.io/)

## Author

- [@natanrmaia](https://github.com/natanrmaia)

## Instalation
```python
  pip install python-ndev-blizzardapi
```

## Blizzard APIs Supported

| API                               | Items                             | Obs                                         |
| :-------------------------------- | :-------------------------------- | :------------------------------------------ |
| **Battle.Net**                    | OAuth API                         | All Regions supported                       |
| **World Of Warcraft (Retail)**    | Game Data API, Profile Data API   | All WoW Retail API Supported (Patch 10.1.5) |
| **World Of Warcraft (Classic)**   | Game Data API, Profile Data API   | All WoW Retail API Supported (Patch 10.1.5) |
| **Diablo 4**                      | Nothing                           | Prioritized once an official API emerges    |
| **Hearthstone**                   | Nothing                           | Planned for the near future                 |
| **Overwatch League**              | Nothing                           | Planned for the near future                 |
| **StarCraft 2**                   | Nothing                           | Planned for the near future                 |
| **Diablo 3**                      | Nothing                           | Not planned for addition                    |

## Report or Request
- [Bug Report](https://github.com/natanrmaia/python-ndev-blizzardapi/issues/new?assignees=&labels=&projects=&template=bug_report.md&title=)
- [Feature request](https://github.com/natanrmaia/python-ndev-blizzardapi/issues/new?assignees=&labels=&projects=&template=feature_request.md&title=)
- [Report a security vulnerability](https://github.com/natanrmaia/python-ndev-blizzardapi/issues/new?assignees=&labels=&projects=&template=feature_request.md&title=)
- [Other questions](https://github.com/natanrmaia/python-ndev-blizzardapi/issues/new/choose)
- [Email - contato@natanael.dev.br](mailto:contato@natanael.dev.br)

## Reference

 - [Battle.Net Developer Portal](https://develop.battle.net/documentation)
samgob-test 1.1.0
A simple dice rolling languge embeded in python
Requires Python: >=3.8

# SamGob

## Samon Goblin

### for all of the dice goblins in the world


samgob is a simple script for parsing the pydice programming language!

samgob is a small language designed to be run in a terminal environment and concisely roll dice.
The idea is to use consice syntax in order to describe complex rolls in simple ways.

as a taste a simple query to generate 100 characters by rolling 4 d 6 dropping the lowest value and re rolling
ones and twos can be run with the following instructions

-100S -6 s3T4D{2-6}

at a future date I should upate this page with more help specs for the language, but for now have this simple example :).
quaero 1.1.5
Simple CLI tool for asking ChatGPT questions in the CLI

# chatgpt-cli-python
Simple CLI tool for asking ChatGPT questions from the terminal

### Getting started
Download by running `pip install quaero`
Run `quaero init` and follow instructions to add your OpenAI key

### Usage
Once your API key is set up, simply run `quaero` and ask your question
Subsequent questions will be part of the same conversation
Exit with control C
The conversation ID printed on exit can be used to resume the conversation by running the script again with `quaero -c <ID>`

### Links
Repo: https://github.com/yeo-yeo/chatgpt-cli-python

Package: https://pypi.org/project/quaero/
manyhttp 2.33.18
Python MultiHTTP for Humans.
Requires Python: >=3.6

# ManyHTTPS

**ManyHTTPS** is a simple, yet elegant, HTTP library for sending multiple asyncronous requests, built on the classic requests library.

```python
>>> import manyhttps
>>> r = manyhttps.get('https://httpbin.org/basic-auth/user/pass', auth=('user', 'pass'), amount=100)
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}
```

ManyHTTPS allows you to send thousands of HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your `PUT` & `POST` data — but nowadays, just use the `json` method!

[![Downloads](https://pepy.tech/badge/requests/month)](https://pepy.tech/project/requests)
[![Supported Versions](https://img.shields.io/pypi/pyversions/requests.svg)](https://pypi.org/project/requests)
[![Contributors](https://img.shields.io/github/contributors/psf/requests.svg)](https://github.com/psf/requests/graphs/contributors)

## Installing MultiHTTP and Supported Versions

MultiHTTP is available on PyPI:

```console
$ python -m pip install multihttp
```

MultiHTTP officially supports Python 3.7+.

## Supported Features & Best–Practices

MultiHTTP is ready for the demands of building robust and reliable HTTP–speaking applications, for the needs of today.

- Keep-Alive & Connection Pooling
- International Domains and URLs
- Sessions with Cookie Persistence
- Browser-style TLS/SSL Verification
- Basic & Digest Authentication
- Familiar `dict`–like Cookies
- Automatic Content Decompression and Decoding
- Multi-part File Uploads
- SOCKS Proxy Support
- Connection Timeouts
- Streaming Downloads
- Automatic honoring of `.netrc`
- Chunked HTTP Requests

## API Reference and User Guide available on [Read the Docs](https://requests.readthedocs.io)

[![Read the Docs](https://raw.githubusercontent.com/psf/requests/main/ext/ss.png)](https://requests.readthedocs.io)

## Cloning the repository

When cloning the Requests repository, you may need to add the `-c
fetch.fsck.badTimezone=ignore` flag to avoid an error about a bad commit (see
[this issue](https://github.com/psf/requests/issues/2690) for more background):

```shell
git clone -c fetch.fsck.badTimezone=ignore https://github.com/psf/requests.git
```

You can also apply this setting to your global Git config:

```shell
git config --global fetch.fsck.badTimezone ignore
```

---

[![Kenneth Reitz](https://raw.githubusercontent.com/psf/requests/main/ext/kr.png)](https://kennethreitz.org) [![Python Software Foundation](https://raw.githubusercontent.com/psf/requests/main/ext/psf.png)](https://www.python.org/psf)