semvec/pypi-packages huggingface dataset:
Yamada 0.2.2
Calculate the Yamada polynomial of spatial topologies.
Requires Python: >=3.9

# Yamada: The Python Library for Calculating the Yamada Polynomial of Spatial Graphs

[![ASME IDETC Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41592--019--0686--2-blue)](
https://doi.org/10.1115/DETC2021-66900)

[![Python package](https://github.com/Chad-Peterson/Yamada/actions/workflows/tests.yml/badge.svg)](https://github.com/Chad-Peterson/Yamada/actions/workflows/tests.yml)

[![Windows](https://svgshare.com/i/ZhY.svg)](https://svgshare.com/i/ZhY.svg)
[![macOS](https://svgshare.com/i/ZjP.svg)](https://svgshare.com/i/ZjP.svg)
[![Linux](https://svgshare.com/i/Zhy.svg)](https://svgshare.com/i/Zhy.svg)


[![GitHub license](https://img.shields.io/github/license/Naereen/StrapDown.js.svg)](https://github.com/Naereen/StrapDown.js/blob/master/LICENSE)


![Yamada Logo](./images/yamada_logo.png)

## Spatial Topologies and Yamada Polynomials

Systems such as automotive cooling layouts, hybrid-electric power trains, and aero-engines are made up of interconnected
components that are spatially arranged to meet system requirements. Holistically optimizing these types of systems is an
extremely challenging problem due to the combinatorial nature of the design space. The research community is exploring
different design representations and algorithms to address this problem.

This library provides a Python implementation of the spatial graphs, spatial graph diagrams, and Yamada polynomial.
These spatial-topological constructs are powerful tools for representing and analyzing complex engineering systems.
By representing engineering systems as spatial topologies we abstract away complex geometry while
retaining some low-fidelity, directionally correct information. Yamada polynomials are a calculated quantity that
is essentially a fingerprint of a spatial topology. This fingerprint can be used to identify unique spatial topologies.

We are currently collecting and analyzing empirical data to determine the effectiveness of spatial topologies and
Yamada polynomials as a design representation for different classes of problems.

## Important Notice

Since this library is still early in development features are often added and removed.
Please feel free to reach out to Chad <cp44@illinois.edu> with any questions or concerns.

## Installation
Yamada requires Python 3.9+ and is supported on Windows, Mac, and Linux. 
It can be installed from PyPI with the following command in your terminal:

>pip install yamada

## Cite Us

@software{Yamada2023github,
  author = {Chad Peterson, Nathan Dunfield},
  title = {Yamada: The Python Library for Calculating the Yamada Polynomial of Spatial Graphs},
  url = {https://github.com/Chad-Peterson/Yamada},
  version = {0.2.1},
  year = {2023},
}
python-ogs 0.1.0
An API Wrapper for online-go.com, an online Go / Baduk server
Requires Python: >=3.7

# OGS Python Library

## Summary

An API wrapper written in python for the Online-Go Server's (OGS) REST API and Realtime (SocketIO) API

**THIS IS STILL HEAVILY IN DEVELOPMENT. VERY MUCH NOT READY FOR USE**

## Install

Installing the specific versions in `requirements.txt` is **REQUIRED**, the OGS API does not support newer versions, and these versions of socketio and engineio are tested to be compatible with each other.

```bash
pip3 install -r requirements.txt
```

If you install the wrong version by accident, you *must* uninstall and re-install.

```bash
pip3 uninstall python-engineio python-socketio
pip3 install -r requirements.txt
```
## Usage

```python
from ogs_client import OGSClient, OGSSocket

ogs = OGSClient('your_client_id', 'your_client_secret', 'your_username', 'your_password')
```
This will authenticate you to OGS using your API credentials, and connect you to the Realtime API Socket. You can now call the usable functions.

## Implemented API Functions
*NOTE* All usernames are case sensitive
### User Functions

- Get User vitals: `ogs.user_vitals()`
- Get User Settings: `ogs.user_settings()`
- Get User Games: `ogs.user_games()`
- Get User Friends (Optionally search for user): `ogs.user_friends(username)`
- Send friend request: `ogs.send_friend_request(username)`

### Player Functions

- Get Player Info: `ogs.get_player(username)`
- Get Received Challenges: `ogs.received_challenges`
- Get Sent Challenges: `ogs.sent_challenges()`
- Get Challenge Details: `ogs.challenge_details(challenge_id)`
- Get Game Details: `ogs.game_details(game_id)`

## Implemented Realtime API Functions

- Get Host Info: `ogs.sock.host_info()`
- Ping: `ogs.sock.ping()`
- Connect To Notification Stream: `ogs.sock.notification_connect()`
- Connect to Chat: `ogs.sock.chat_connect()`
- Connect to a Game: `ogs.sock.game_connect(gameid: int)`
  - This creates an object in the `ogs.sock.games` list with the key `game_id`
- Disconnect from a Game: `ogs.sock.game_disconnect(game_id)`

### Implemented Game Functions

- Make a move: `ogs.sock.games[game_id].move('jj')`


## To Implement
TODO: Update this list

- Pretty much everything
flatlify 0.1.1
Helper functions for flattening nested data structures
Requires Python: >=3.8,<4.0

<p align="center">
    <a href="https://github.com/nickatnight/flatlify/actions">
        <img alt="GitHub Actions status" src="https://github.com/nickatnight/flatlify/actions/workflows/main.yml/badge.svg">
    </a>
    <a href="https://codecov.io/gh/nickatnight/flatlify">
        <img alt="Coverage" src="https://codecov.io/gh/nickatnight/flatlify/branch/main/graph/badge.svg?token=E03I4QK6D9"/>
    </a>
    <a href="https://github.com/nickatnight/flatlify/releases"><img alt="Release Status" src="https://img.shields.io/github/v/release/nickatnight/flatlify"></a>
    <a href="https://github.com/psf/black"><img alt="Style Badge" src="https://img.shields.io/badge/code%20style-black-000000"></a>
    <a href="https://mypy.readthedocs.io/en/stable/"><img alt="MyPy Badge" src="https://img.shields.io/badge/mypy-1.1.1-FFDD23">
    <a href="https://github.com/nickatnight/flatlify/blob/main/LICENSE">
        <img alt="License Shield" src="https://img.shields.io/github/license/nickatnight/flatlify">
    </a>
</p>


# flatlify
A suite of helper functions for flattening nested data structures

## Usage
Install with pip
```shell
$ pip install flatlify
```

```python
from flatlify.flatten import flatten_packet

packet = {"a": 1, "b": 2, "c": {"d": 3, "e": {"f": 4}, "g": 5}}
print(flatten_packet(packet))
{"a": 1, "b": 2, "c.d": 3, "c.e.f": 4, "c.g": 5}
```

Some constraints:
- Keys are always strings
- Values may be floats, integers, strings, or dictionaries

## Ci/CD
GitHub Actions will run a number of checks and balances on each PR. You can view more [here](.github/workflows/main.yml)

## Development
Requires [Poetry](https://python-poetry.org/docs/#osx--linux--bashonwindows-install-instructions) to manage dev environment.  Once installed:
1. install packages with `poetry install`

### pre-commit hooks
Download [pre-commit](https://pre-commit.com/) system package and install. Once done, install the git hooks with
```console
$ pre-commit install
pre-commit installed at .git/hooks/pre-commit
```

### Helpful commands
Black
```shell
$ poetry run black .
```

Ruff
```shell
$ poetry run ruff check .
```

MyPy
```shell
$ poetry run mypy .
```

iSort
```shell
$ poetry run isort .
```

Test
```shell
$ poetry run pytest --cov=. tests/
```

Package dist and create new setup.py
```shell
$ poetry build --format sdist
$ tar -xvf dist/*-`poetry version -s`.tar.gz -O '*/setup.py' > setup.py
```

## TODO
- automate PyPi publishing

Made with :heart: from Cali