semvec/pypi-packages huggingface dataset:
pydantic-openai 0.1.0
Pydantic models for OpenAI's API
Requires Python: >=3.7

# pydantic-openai

Pydantic models for OpenAI's API. These make it easier to construct requests and parse responses, as well as set up API-compatible servers.

Making requests is explicitly out of scope.

This is mostly translated from [sashabaranov/go-openai](https://github.com/sashabaranov/go-openai/tree/master), by ChatGPT. I welcome translating the rest over, I just don't really use the other API's.

# Usage

See the package on [PyPI](https://pypi.org/project/pydantic-openai/). 

```bash
pip install pydantic-openai
```

```python
from pydantic_openai import ChatCompletionRequest
```
fleet-sdk 0.5.5.1
Fleet SDK for building and managing chatGPT plugins
Requires Python: >=3.6,<4.0

## Set Up Fleet

# Install the SDK 

pip install fleet-sdk

# Import the SDK at the top of your plugin's files

from fleet_sdk.fastapi import Tracker 

from fleet_sdk.flask import Tracker 

from fleet_sdk.quart import Tracker 

# Initialize the SDK with your Plugins Analytics's ID.

tracker = Tracker("fleet-49b1bee7-b471-492a-a814-1bfbc2c2afa8", app=app)

# Add this decorator to the endpoints you want to track.

@tracker.log_event
coffeefetch 1.3.0
A lightweight system information grabber written in Python
Requires Python: >=3.7

# CoffeeFetch
![image](https://github.com/TeaPixl/CoffeeFetch/assets/106362493/71e27b7e-3d09-4b5b-8b6e-384b3f781b1b)
## A lightweight system info grabber written in Python

## Introduction
CoffeeFetch is a system information grabber for Unix systems that fetches your system information and displays it to the screen. This is a lightweight package and is built to be run on systems without the use of a Window Manager or Desktop Enviornment and is displayed directly in in TTY. It will attempt to grab you CPU model, CPU frequency, current RAM consumption, current disk usage, Operating System, CPU architecture, IP Address, hostname, and OS version.

## Installation
It is required to use Python 3.7 or greater for this package. 
> psutil >= 5.9.5 is required for this package.

Firstly, clone this repository:
```
git clone https://github.com/TeaPixl/CoffeeFetch/
cd CoffeeFetch
```
Then, install the required Python modules
```
pip install -r requirements.txt
```
Build and install the .whl file
> Change the X.X.X to the version you have
```
python3 -m build
cd dist/
pip install coffeefetch-X.X.X-py3-none-any.whl
```
OR

```
pip install coffeefetch
```

## Usage
To use CoffeeFetch, type into your terminal:
```
python3 -m coffeefetch
```

## NOTE
This project is currently in the works and I have not finished it yet.
This is a NEW repository so feel free to post any issues you may find.

Currently working on:
+ Providing more detailed exceptions
+ testing
sphinx-xournal 0.1.2
Sphinx extension to generate images from xournal files.
Requires Python: >=3.10
Keywords: sphinx,xournal,notes

==============
Sphinx Xournal
==============

.. image:: https://img.shields.io/pypi/v/sphinx-xournal.svg
   :target: https://pypi.python.org/pypi/sphinx-xournal

Sphinx extension to render images of Xournal files.

Usage
-----

You will need to start by installing the extension.

.. code-block:: bash

   pip install sphinx-xournal

Your sphinx conf.py file will need a few changes.
To enable this extension it needs to be added to the extensions list.

.. code-block:: python

   extensions = [
       "sphinx_xournal",
   ]

If xournalpp is not installed in the default location you need to specify one:

.. code-block:: python

   xournal_binary_path = "/a/different/place/xournalpp"


You are now ready to include your .xopp files in your marvelous documentation.

We provide you with 3 options:

Option 1:
~~~~~~~~~

You can generate a restructured image from any Xournal files.
This block inherits all the restructured image tags, like :align:.

.. code-block:: rst

   .. xournal-image:: ./example.xopp
      :format: svg
      :align: center

      Sketch of an example.

Option 2:
~~~~~~~~~

Same applies for the figure block.

.. code-block:: rst

   .. xournal-figure:: ./example.xopp
      :format: svg
      :align: center

      Sketch of an example.

Option 3 (Experimental):
~~~~~~~~~~~~~~~~~~~~~~~~

The last option allows you to embed the raw svg.

.. code-block:: rst

   .. xournal-raw:: ./example.xopp
      :format: svg
      :align: center

      Sketch of an example.
BLEST-Py 0.0.2
The Python reference implementation of BLEST (Batch-able, Lightweight, Encrypted State Transfer)
Requires Python: >=3.6

# BLEST-Py

The Python reference implementation of BLEST (Batch-able, Lightweight, Encrypted State Transfer), an improved communication protocol for web APIs which leverages JSON, supports request batching and selective returns, and provides a modern alternative to REST. It includes examples for Django and Flask.

To learn more about BLEST, please refer to the white paper: https://jhunt.dev/BLEST%20White%20Paper.pdf

## Features

- JSON Payloads - Reduce parsing time and overhead
- Request Batching - Save bandwidth and reduce load times
- Compact Payloads - Save more bandwidth
- Selective Returns - Save even more bandwidth
- Single Endpoint - Reduce complexity and improve data privacy
- Fully Encrypted - Improve data privacy

## Installation

Install BLEST-Py from PyPI.

```bash
pip install blest_py
```

## Usage

### Server-side

Use the `create_request_handler` function to create a request handler suitable for use in a Python application. The following example uses Flask, but you can find examples with other frameworks [here](/examples).

```python
from flask import Flask, make_response, request
from blest_py import create_request_handler

async def greet(params, context):
  return {
    'geeting': 'Hi, ' + params.get('name') + '!'
  }

router = create_request_handler({
  'greet': greet
})

app = Flask(__name__)

@app.post('/')
async def index():
  result, error = await router(request.json)
  if error:
    resp = make_response(error, 500)
    resp.headers['Content-Type'] = 'application/json'
  else:
    resp = make_response(result, 200)
    resp.headers['Content-Type'] = 'application/json'
    return resp
```

### Client-side

Client-side libraries assist in batching and processing requests and commands. Currently available for React with other frameworks coming soon.

#### React

```javascript
import React from 'react';
import { useBlestRequest, useBlestCommand } from 'blest-react';

// Use the useBlestRequest hook for fetching data
const MyComponent = () => {
  const { data, loading, error } = useBlestRequest('listItems', { limit: 24 });

  // Render your component
  // ...
};

// Use the useBlestCommand hook for sending data
const MyForm = () => {
  const [submitMyForm, { data, loading, error }] = useBlestCommand('submitForm');

  // Render your form
  // ...
};
```

## Contributing

We actively welcome pull requests. Learn how to [contribute](CONTRIBUTING.md) for more information.

## License

This project is licensed under the [MIT License](LICENSE).
slackybot 1.2.0
A Python package that helps to interact with the Slack App
Requires Python: >=3.10

# Slackybot
This Python package helps you with sending messages to Slack. It offers an object-oriented approach - every message or reply in a thread is an object, so they can be easily managed.

## Getting started
### Installation
```commandline
python -m pip install slackybot
```
Add following token scopes to your Slack bot:  
`channels:join` `channels:read` `chat:write` `chat:write.customize` `chat:write.public`

### Simple usage
Import and initialize the slack object
```python
from slackybot import Slack

slack = Slack(token='XXX')
```
As a best practice, it is better to pass the token using an environment variable (e.g. `.env` file)

To send a message you have to use the Slack object method. It takes two arguments: `channel` and `text` they are both strings. 
```python
slack.send_message(channel='channel-name', text='Sample text')
```
The above method returns the `Message` object.

To update a message you may use the Message method `.update()`. It takes one argument: `text` as a string.
```python
message = slack.send_message(channel='', text='')
message.update(text='New text')
```

To send a reply in the message thread simply use `.send_reply()` method. It takes one argument: `text` as a string.
```python
message = slack.send_message(channel='', text='')
message.send_reply(text='Reply message in the thread')
```
The above method returns the `Reply` object.

Both objects `Message` and `Reply` can be deleted by using `.delete()` method on them. Those objects can be listed using:
* `.get_messages()` on the Slack object
* `.get_replies()` on the Message object
classic-isotherms 0.0.1
A package to calculate the classic and empirical isotherms

# ClassicIsotherms

ClassicIsotherms is a Python module that provides implementations of various classic adsorption isotherm equations. It allows you to calculate the loading and deviations for different isotherm models based on pressure, temperature, and parameters.

## Installation

You can install ClassicIsotherms using pip:

```shell
    pip install classic-isotherms
```

## Usage

```python
    import ClassicIsotherms

    # Create an instance of ClassicIsotherm
    isotherm = ClassicIsotherms("freundlich")

    # Calculate loading for a given pressure, temperature, and parameters
    pressure = 1.5
    temperature = 298.15
    parameters = [2.0, 1.5]
    loading = isotherm.get_loading(pressure, temperature, parameters)
    print("Loading:", loading)

    # Calculate loadings for multiple pressures
    pressures = [1.0, 2.0, 3.0]
    loadings = isotherm.get_loadings(pressures, temperature, parameters)
    print("Loadings:", loadings)

    # Calculate deviation using a specific deviation function
    experimental_loadings = [0.5, 1.0, 1.5]
    deviation_equation = "SSE"
    deviation = isotherm.get_deviation(pressures, experimental_loadings, temperature, parameters, deviation_equation)
    print("Deviation:", deviation)
```

# Supported Isotherm Models

The following classic adsorption isotherm models are currently supported:

- Freundlich (`'freundlich'`)
- Langmuir (`'langmuir'`)
- Redlich-Peterson (`'redlich-perterson'`)
- Sips (`'sips'`)
- Toth (`'toth'`)
- Unilan (`'unilan'`)
- Keller-Staudt-Toth (`'keller-staudt-toth'`)

# Supported Deviation Methods

The following deviation methods are currently supported:

- Sum of Squared Errors (`'SSE'`)
- Average Relative Error (`'ARE'`)
- Absolute Error (`'EABS'`)
- Hybrid Deviation (`'HYBRID'`)
- Mean Percentage Standard Deviation (`'MPSD'`)
- Sum of Relative Errors (`'SRE'`)
- Chi-square Deviation ('`CHI_2'`)
- Residual Sum of Squares Deviation (`'R_S'`)

# Contributing

Contributions are welcome! If you have suggestions, bug reports, or feature requests, please open an issue on the [GitHub repository](https://github.com/mv-per/ClassicIsotherms).

# License

ClassicIsotherms is licensed under the MIT License. See the [LICENSE](https://github.com/mv-per/ClassicIsotherms/blob/main/LICENSE) file for more information.