semvec/pypi-packages huggingface dataset:
qforce 0.6.14
Q-Force: Quantum mechanically augmented molecular force fields
Keywords: qm forcefield md

<img src="https://i.imgur.com/jZG5MNO.jpg" height="200">

## **Q**uantum Mechanically augmented molecular **force** fields
[//]: # (Badges)
[![GitHub Actions Build Status](https://github.com/selimsami/qforce/workflows/CI/badge.svg)](https://github.com/selimsami/qforce/actions?query=workflow%3ACI)
[![codecov](https://codecov.io/gh/selimsami/qforce/branch/master/graph/badge.svg)](https://codecov.io/gh/selimsami/qforce/branch/master)
![license](https://img.shields.io/github/license/selimsami/qforce)

Please see the [Documentation](https://qforce.readthedocs.io/).



If you use Q-Force, please cite:


[Sami, S.; Menger, M. F. S. J.; Faraji, S.; Broer, R.; Havenith, R. W. A., Q-Force: Quantum Mechanically Augmented Molecular Force Fields. Journal of Chemical Theory and Computation 2021, 17 (8), 4946-4960.](https://pubs.acs.org/doi/10.1021/acs.jctc.1c00195)
quiltcore 0.6.3
low-level plubming to read/write Quilt packages
Requires Python: >=3.10,<4.0

# QuiltCore

QuiltCore is a library for building and running [Quilt](https://quiltdata.com) data packages.
It is designed to leverage standard open source technology and YAML configuration files
so that it can easily be ported to other languages and platforms.

This initial implementation is in Python.

## Key Technologies

- Apache [Arrow](https://arrow.apache.org/) for reading, writing, and representing manifests
  - [PyArrow](https://arrow.apache.org/docs/python/) for Python bindings to Arrow
- fsspec [filesystems](https://filesystem-spec.readthedocs.io/en/latest/)
  for reading and writing files from various sources
- [PyYAML](https://pyyaml.org/) for reading and writing YAML configuration files

## Example

```bash
poetry install
```

```python
#!/usr/bin/env python
import os
from quiltcore import Domain, UDI
from tempfile import TemporaryDirectory
from upath import UPath

TEST_BKT = "s3://quilt-example"
TEST_PKG = "akarve/amazon-reviews"
TEST_TAG = "1570503102"
TEST_HASH = "ffe323137d0a84a9d1d6f200cecd616f434e121b3f53a8891a5c8d70f82244c2"
TEST_KEY = "camera-reviews"
WRITE_BKT = os.environ.get("WRITE_BUCKET")
SOURCE_URI = f"quilt+{TEST_BKT}#package={TEST_PKG}:{TEST_TAG}"
DEST_URI = f"quilt+{TEST_BKT}#package={TEST_PKG}:{TEST_TAG}"
```

### Get Manifest

<!--pytest-codeblocks:cont-->
```python
remote = UDI.FromUri(SOURCE_URI)
print(f"remote: {remote}")
with TemporaryDirectory() as tmpdir:
    local = UPath(tmpdir)
    domain = Domain.FromLocalPath(local)
    print(f"domain: {domain}")
    folder = domain.pull(remote)
    print(f"folder: {folder}")
    if WRITE_BKT:
        tag = domain.push(folder, remote=UDI.FromUri(DEST_URI))
        print(f"tag: {tag}")
```
overwatch-client 0.1.9
A python based Overwatch Client for interacting with the overwatch server with higher level apis.
Requires Python: >=3.9,<4.0

# Overwatch Client

This is a python client for the Overwatch REST API. This implementation is a work in progress but is still able to communicate with the overwatch server and register/infer models. 


```py 

from overwatch_client import HTTPClient

client = HTTPClient(
  overwatch_server_url = "https://overwatch.distributive.network",
  model_registry_url = "https://models.overwatch.distributive.network"
)

print(f"Can we connect? {client.check_overwatch_server_connection()}")

#### Register a Model

response = client.register_model(
    model_name = "my_model",
    model_path = "./my_model.onnx",
    preprocess_path = "./preprocess.py",
    postprocess_path = "./postprocess.py",
    password = "my_password",
    language = "python",
    packages = ["numpy", "pandas", "opencv-python"]
)

print(response.text) ### Model registered successfully!

#### Infer a Model


response = client.infer(
    inputs = files, # a list of the bytes of each input
    model_name = "my_model",
    slice_batch = 1, # number of inputs per slice
    inference_id = "my_inference_id", # An identifier for the inference
    compute_group_info = "joinKey/joinSecret" # The compute group info for the inference
)


```
neopolitan 0.1.41
Neopolitan: a library for displaying text on LED boards
Requires Python: >=3.7

# neopolitan
A library for displaying "text" on LED boards

## Description

This is a revamp of [stockticker](https://github.com/alyoshenka/stockticker), which queries real-time stock price data, calculates daily fluctuations, and displays it on an LED board. While the end result of that project was cool, this project aims to clarify much of the data display code and make it usable to display any inputted message. See this [sub-readme](https://github.com/alyoshenka/neopolitan/tree/main/src/writing#readme) for an introduction to how data can be used to make the board display "human-readable" text.

Given that access to hardware boards can be constrictive and testing can be difficult, this project aims to support data display on a graphical interface so that anyone can access it. `pygame` is used to display the graphical display, while the `neopixel` (hence the project name) library is used to interface with the hardware board. The switch between these two displays is OS-dependent.

## Installation
`[python3 -m] pip install neopolitan`

## Usage
*Make sure to exit the program by pressing the window close "X", instead of `ctrl+c`*
- To run the program
  ```py
  from neopolitan.neop import main as main_function
  main_function()
  ```
- To demo live-update functionality
  ```py
  import neopolitan.testboardrunner
  ```
- To run the program with arguments
  ```py
  from queue import Queue

  q = Queue() # Initialize the input events queue
  q.put('say This is a demo statement') # Set the message: 'say {message (spaces okay)}'
  q.put('speed fast') # Set the scroll speed: 'speed {slow/medium/fast}'
  q.put('wrap True') # Set whether message wraps when done displaying: 'wrap {True/False};

  from neopolitan.neop import main
  main(events=q) # Run main with the specified events
  ```
  - See [Supported Characters](https://github.com/alyoshenka/neopolitan/blob/main/neopolitan/writing/ReadMe.md#defined-characters) for a list of supported characters

https://github.com/alyoshenka/neopolitan/assets/38815390/1e98261b-8dfb-48e3-943b-34b49878c55f

- To run some demos
  ```py
  from neopolitan.demos import *

  display('This displays a message that cannot be updated')
  # Execution will return here when the display is closed
  display_all() # display all defined symbols
  ```

https://github.com/alyoshenka/neopolitan/assets/38815390/e9cae65b-2c18-4844-886f-61a2a319c42a


- See [this code](https://github.com/alyoshenka/neo/blob/main/neo/neopolitan_handler.py) for an example of how to send live updates in the package

## Command Line Arguments

[*Deprecated*]
**Note: This code only works from source, NOT the package install**

From the top-level `neopolitan/` directory: `python[3] neopolitan/neop.py {args}`
- `--message/-m {message_to_display}`
  - Displays the given message on the board (enclose in quotes if multiple words)
- `--scroll-speed/-s {slow/medium/fast}`
  - Controls how quickly the display scrolls across the screen
- `--wrap/-w {True/False}`
  - Determines whether the display should "wrap around" when it gets to the end, or just show a blank screen