semvec/pypi-packages huggingface dataset:
uikitpy 0.2.0
A set of libraries for UI development.

About
=====

This is just a utility project to help quickly bring in dependencies that I usually use in my personal projects.
It also contains a little bit of OpenGL code to compile shaders, open nicer looking fonts in ImGui, store user settings in a sensible place, and get rid of entry point boiler plate.
This library comes in two flavors: the C++ interface (for desktop and web browser platforms) and Python.
The two flavors are a bit different in some ways, but for the most part they are just a packaged interface to GLFW, OpenGL ES 2, ImGui and ImPlot.
There is little to no abstraction layers in place. If you already know the GLFW, OpenGL and ImGui APIs, learning to use this library is easy.

## C++ Interface

In order to use this project with C++, you'll need to compile it and link to it.
In order to compile it, you'll need to have CMake installed and an active `vcpkg` repository.
You'll need to set the environment variable `VCPKG_ROOT` to where the initialized `vcpkg` repository is.
Finally, you'll need to ensure you have the dependencies installed:

```
./vcpkg install glfw openal-soft pybind11
```

*Note: The OpenAL dependency may get dropped in a future release.*

Add this project as a sub directory in CMake either by installing it with `FetchContent` or by adding it as a git submodule and calling `add_subdirectory(uikit)`.
Link to `uikit::uikit` and `uikit::main` (contains the entry point code) and start your application like this:

```cxx
#include <uikit/main.hpp>

#include <imgui.h>

// optionally
#include <GLES2/gl2.h>

namespace {

class app_impl final : public app
{
public:
  void setup(uikit::platform& plt) override { plt.set_app_name("My Demo App"); }

  void teardown(uikit::platform& plt) { }

  void loop(uikit::platform& plt) {

    // In setup() you can disable auto-close with uikit::platform::set_auto_close_enabled and allow the application to
    // decide when to exit.
    //
    // if (plt.exit_requested()) {
    //   plt.queue_exit();
    // }

    ImGui::Begin("Test");

    ImGui::End();
  }
};

} // namespace

namespace uikit {

auto create_app() -> std::unique_ptr<app> { return std::unique_ptr<uikit::app>(new app_impl()); }

} // namespace uikit

```

## The Python Interface

You can also use this project in Python on both Linux and Windows.

Clone the repository and run:

```
pip install path/to/uikit
```

Where `uikit` is the path to the repository.
It works just fine in virtual environments as well.

In a Python file, you can import `uikitpy` which contains submodules for OpenGL ES 2, GLFW, ImGui, ImPlot and portable-file-dialogs.

```python
import uikit.gl as gl
import uikit.glfw as glfw
import uikit.imgui as imgui
import uikit.implot as implot
import uikit.pfd as pfd

def main():
  glfw.init()
  window = glfw.create_window()
  while not window.should_close():
    glfw.poll_events()
    window.begin_frame()
    if imgui.begin('Main Window'):
      if imgui.button('Click me!'):
        print('Button was clicked!')
    imgui.end()
    window.end_frame()
  window.close()
  glfw.terminate()
main()
```
authexchange 0.7.6
A server to handle the OAuth token exchange with FusionAuth.
Requires Python: >=3.10

![GitHub License](https://img.shields.io/github/license/r0b4dams/authexchange?)
[![CI](https://github.com/r0b4dams/authexchange/actions/workflows/ci.yaml/badge.svg)](https://github.com/r0b4dams/authexchange/actions/workflows/ci.yaml)
[![Tests](https://github.com/r0b4dams/authexchange/actions/workflows/unit_tests.yaml/badge.svg)](https://github.com/r0b4dams/authexchange/actions/workflows/unit_tests.yaml)

[![GitHub Release](https://img.shields.io/github/v/release/r0b4dams/authexchange?logo=github&label=GitHub&color=%23fefefe)](https://github.com/r0b4dams/authexchange/releases)
[![PyPI - Version](https://img.shields.io/pypi/v/authexchange?&logo=pypi&label=PyPI&labelColor=%23ffffff&color=%235a9fd4)](https://pypi.org/project/authexchange/)
[![Docker Image Version](https://img.shields.io/docker/v/r0b4dams/authexchange?&logo=docker&logoColor=%231D63ED&label=Docker&labelColor=%23E5F2FC&color=%231D63ED)](https://hub.docker.com/repository/docker/r0b4dams/authexchange)

# authexchange

A server to perform the OAuth token exchange with FusionAuth.
historicaldates 1.0.1
Python library for handling BCE and CE dates.
Requires Python: >=3.6

# python-historical-dates

Python library for handling historical dates, including support for BCE dates. This library simplifies working with ancient and historical calendars without the complexities of modern datetime modules.

## Features

- Support for both BCE and CE dates.
- Simple and intuitive API for creating and manipulating historical dates.
- Functionality for comparing dates and calculating differences across eras.

## Installation

Install `python-historical-dates` via pip:

```bash
pip install historicaldates
```

## Quick Start

Here's how you can use python-historical-dates to create and manipulate historical dates:

```python
from historicaldates import HistoricalDate

# Create a historical date for January 1, 500 BCE
date_bce = HistoricalDate(-500, 1, 1)

# Create a historical date for December 31, 500 CE
date_ce = HistoricalDate(500, 12, 31)

# Calculate the number of days between two dates
days_between = date_ce - date_bce
print(f"Days between: {days_between}")
```

## How to Contribute

I welcome contributions from the community! Here are some ways you can contribute:
- Submit bugs and feature requests.
- Review the source code and improve documentation.
- Submit pull requests with bug fixes or new features.
Before contributing, please read the CONTRIBUTING.md file for details on our code of conduct, and the process for submitting pull requests to us.

## License

This project is licensed under the MIT License - see the LICENSE.md file for details.
haulsrv 0.0.0
A log sequencer with bottomless storage
Requires Python: >=3.11

# haulsrv
![pypi](https://img.shields.io/pypi/v/haulsrv.svg)
![versions](https://img.shields.io/pypi/pyversions/haulsrv.svg)

Hauler server. A log sequencer with bottomless storage adapters.

## Usage

Run the docker container

```console
> docker run rupurt/haulsrv:latest \
    -p 8080:8080 \
    -p 8081:8081
```

## Development

This repository manages the dev environment as a Nix flake and requires [Nix to be installed](https://github.com/DeterminateSystems/nix-installer)

```console
> nix develop -c $SHELL
```

```shell
> make setup
```

```shell
> make test
```

## Publish Package to PyPi

```shell
> make pypi
```

## License

`haulsrv` is released under the [MIT license](./LICENSE)
unleashed-chat-cli 0.1.0
A simple CLI wrapper for Unleashed.chat's chatbot service.
Requires Python: >=3.6

# Unleashed.chat CLI Chat Wrapper

A simple CLI wrapper for [Unleashed.chat](https://unleashed.chat)'s chatbot service.

## Usage:

1. Clone this repository.
   `git clone https://github.com/reecehunter/openai-cli-chat-wrapper`

2. Navigate to the repository.
   `cd unleashed-chat-cli-wrapper`

3. Open the pipenv shell.
   `pipenv shell`

4. Install dependencies.
   `pipenv install`

5. Clone `.env.example` into `.env`
   `cp .env.example .env`

6. Add your OpenAI API Key to `.env`.
   `nano .env`

7. Start the program.
   `python3 main.py`
custjson 0.1.1
A package that manages JN formatted files (CustJSON specific JSON varient)
Requires Python: >=3.9

# CustJSON
A python package that makes its own little custom variant of JSON. Still easy to read, just no nested values (yet)

## WARNING
By using this package, the code writer does not take responsibility if you use this package and data gets leaked or stolen due to the CustJSON format being <u>*plain text*</u>.

<br/><br/><br/>

# Usage
## Opening, Closing, Deleting and Creating files

To start using the package, make an initialization object using this code:

    i = custjson.Init()

This line of code initializes the package's features, which by proxy means you have to run CustJSON's functions via *i.function(foo,bar)*

To create a file directly and load it into the package's memory, type:
    
    i.create_file("filename-without-extension")
    
Replace "filename-without-extension" with the filename of your choice WITHOUT THE EXTENSION. It automatically assigns the file a <u>*.jn*</u> extension.

To load a file that already exists to the package's memory, type:

    i.open_file("path/to/file/filename.jn")
    
Again, replace "path/to/file/filename.jn" with the path to your file (including your file AND the .jn extension.)

To delete a file, make sure it's loaded in memory, and then type:

    i.delete_file()
    
To close a file, it's the same process, but with a different command.
Type:

    i.close_file()
    
## Reading and Writing to files

To read and write to .JN files, you first have to load them into CustJSON's memory as shown before, then you can simply use the commands
    
    i.read_value_from_name("valueNameHere")
    i.read_line(lineNumber)
    
Replace each placeholder with its respective value, for example if you wanted to get the value of the key "space", you'd do:

    i.read_value_from_name("space")
    
and replace *lineNumber* with... the line number you want to read from the current file...

##  &rlm;&lrm;

You have now learned how to use CustJSON. Yaaay!

# Changelog

v. 0.1.1:
    Fixed a bug with the value reader not being coded properly. Woops!