semvec/pypi-packages huggingface dataset:
unigui-carstentb 0.1.3
A cross-hardware GUI framework
Requires Python: >=3.9

# UniGui

![Screenshot](screenshot.png)

### A cross-platform user interface framework based on Adafruit Displayio

This GUI framework can be used to create front-ends on multiple platforms, including Generic Linux and Windows PCs, Single board computers such as Raspberry Pi using a hardware display (for instance: PiTFT), and microcontroller-based projects (i.e. Feather RP2040) using CircuitPython and a display.

There is also a class called `PygameDisplay` that uses pygame to create a `displayio.Display` for use in a non-embedded environment. Much of that code was adopted from https://github.com/FoamyGuy/Blinka_Displayio_PyGameDisplay.

## ToDo list
- [X] PR for Adafruit_Blinka and (possibly) PlatformDetect to allow usage on generic PC environments.
- [ ] Overall improvement and features for widgets
- [ ] Fix border_on function for generic widget so border is always drawn on top of other content (useful for viewing widget dimensions)
- [X] Map names (such as BASE_DARK, BASE_LIGHT, TEXT_DEFAULT, TEXT_HIGHLIGHT, etc) to the palette indices so that I can reference them independently of the color scheme
- [ ] Figure out how to better handle clicks. For example, I might want a single widget to have multiple click regions. I don't think this is easy to do right now. Consider removing UniGui object totally and just making the Widget idea fully recursive.
- [X] Fix font file paths so they work always

## How to use this framework
- Clone this repository to your computer, then navigate into the project directory.
- Create a python virtual environment with `python -m venv .venv`. Note: This project has been tested with Python 3.10.4 on Windows and Linux. You can name your virtual environment directory whatever you like. The current `.gitignore` will ignore all directories starting with `.venv`
- Activate the virtual environment on Linux with `source .venv/bin/activate.sh`, or on Windows PowerShell with `.venv\Scripts\Activate.ps1`.
- Install dependencies with `pip install -r requirements.txt`.
- To run the main example, type `python examples/desktop/code-desktop.py`
reinvent-models 0.0.15rc1
Generative models for Reinvent
Requires Python: >=3.7

# Introduction
This is a package to supply all the models used by REINVENT.

# Develop
## Setup environment
You can use Conda to create an environment with all the necessary packages installed.

```
$ conda env create -f reinvent_models
[...]
$ conda activate reinvent_models
```

## Run tests
The tests use the `unittest` package testing framework. Before you can run the tests make sure that you have created a
`config.json`file in the `reinvent_models/configs` directory. There is an example config in the same directory, which 
you can base your own config off of. The easiest way is to make a copy of the example config file and name it `config.json`.
Make sure that you set `MAIN_TEST_PATH` to a non-existent directory; it is where temporary files will be written during the tests; 
if it is set to an existing directory, that directory will be removed once the tests have finished.

For the unit tests in this repository, make sure the paths below are set:
 `"PRIOR_PATH": "/path/to/reinvents/prior"`
 `"LIBINVENT_PRIOR_PATH": "/path/libinvent/prior"`

Once you have created a config file, you can run the tests, located in the directory, by running

```
$ python main_test.py
```
pol-inv 0.1.2
Package for computing polymorphisms in universal algebra

# pol-inv

The goal of this project is to allow one to use a Jupyter notebook (or a Python program) to investigate various properties of relational structures and algebras.

The package is very basic and probably full of bugs at the moment. There some similar packages are already available:
- Jakub Opršal's [PCSP Tools](https://github.com/jakub-oprsal/pcsptools) from which I took a lot of inspiration
- Peter Jipsen's [Sage package](https://math.chapman.edu/~jipsen/sagepkg/) that uses Prover9 to reason about algebras
- Miklos Maroti's [Critical Relations](https://www.math.u-szeged.hu/~mmaroti/applets/CriticalRels.html) and [Graph Polymorphism](https://www.math.u-szeged.hu/~mmaroti/applets/GraphPoly.html) Java applets
- The [Universal Algebra Calculator](http://uacalc.org) has a GUI and a Python API (but only handles algebras, not relational structures)

Currently pol-inv can compute:
- Whether there exists a polymorphism from a relational structure A to a relational structure B that satisfies a given height 1 identity (see https://doi.org/10.1145/3457606)
trview 0.3.4
A GUI between AUG data and transport codes
Requires Python: >=2.6

What you need: python>=2.7 with numpy, scipy, matplotlib, Tkinter, tkFileDialog, tkMessageBox
Special need: libgsl_congtrib.so installed

Visual tool to collect TRANSP, ASTRA and RABBIT input (u-files, namelists, IMAS). 
Recursive cubic-spline for the input profiles.

Execute: trv_gui.py

More documentation at https://www.aug.ipp.mpg.de/aug/manuals/transp/trview
daacla 0.0.8
Python module to management `dataclass` objects using SQLite


# daacla

Python module to management `dataclass` objects using SQLite


# Usage

```
from dataclasses import dataclass
from datetime import datetime

from daacla import Daacla, table


@dataclass
@table(key='url')  # `key` means primary key
class Post:  # makes `Post` table on the `db` database
    url: str
    created_at: float


db = Daacla()

# Update/Insert a record
db.upsert(Post(url='https://example.com/page/1', created_at=datetime.now().timestamp()))

# Check existence of the record
print( db.exists(Post, key='https://example.com/page/1') )  # → True

# Check existence of the record
print( db.exists(Post, key='https://example.com/page/NOTHING') )  # → False

# Search
url = 'https://example.com/page/1'
for post in db.select(Post, 'url = ?', url):
  print(post.url)  # → https://example.com/page/1
```