semvec/pypi-packages huggingface dataset:
arcframework 2.7.1
A Python micro web framework for creating dynamic websites.
Requires Python: >=3.8

# Arc 2.5.3
### Python ASGI web framework for creating fast and dynamic web applications.

Arc is a python ASGI web framework for creating dynamic web pages. Arc is still under heavy devlopment, and all help is appreciated. Arc is built using `Starlette`, and runs on the lighting fast `uvicorn` web server.

## Installation
Arc is relatively easy to get set up with. Arc is cross platform, and can be installed on any operating system. You can install it using pip.
```
# Windows
pip install arcframework

# Linux
pip3 install arcframework
```

## Quickstart
Arc is a very easy to use libary, and is similar to other micro frameworks such as Flask or Bottle, so learning it won't be too hard. The below is an example of an Arc application.
```py
from arc import App, TextResponse

app = App()

@app.route("/home")
def home(request):
    return TextResponse("Hello, World")

if __name__ == "__main__":
    app.run()
```
Copy and paste the above and run your file, you'll get an output like the following in your console.
```
INFO: Running on http://127.0.0.1:5000

INFO: Press CTRL + C to stop
```
Now go to http://127.0.0.1:5000/home, and you should see `Hello World` being displayed on the screen.

## Issues/Bugs
Arc is still under heavy development abd has loads of bugs and errors that I'm constantly working on resolving. You can check out the documentation at https://aboominister25.github.io/arc/. Feel free to open an issue or email me at aboominister@gmail.com, all help would be appreciated.
fastcpu 1.5.0
A queue service for quickly running scripts sequentially to use all your CPUs efficiently
Requires Python: >=3.0

Inspired with code from https://github.com/fastai/fastgpu 

# fastcpu

> A queue service for quickly developing scripts that use all your CPUs efficiently

> PULL REQUESTS WELCOME! 

fastcpu provides a single command, fastcpu_poll, which polls a directory to check for scripts to run, and then runs them
on the first available CPU. If no CPUs are available, it waits until one is. If more than one CPU is available,
multiple scripts are run in parallel, one per CPU.
(Note currently the CPU load checking is not implemented, the scripts are run sequentially at polling interval)

## Installation

`pip install fastcpu`

## How to use

--help provides command help:

```
$ fastgpu_poll --help

optional arguments:

  -h, --help                         show this help message and exit
  --path PATH                        Path containing `to_run` directory (default: .)
  --exit_when_empty EXIT_WHEN_EMPTY  Exit when `to_run` is empty (default: 1)
  --poll_interval POLL_INTERVAL      The duration between polls (default: 0.1)
  --terminate_timout                 The timeout at which point we kill the running script in seconds, -1 to never terminate
```

If installed via pip there is a handy command line method available

`fastcpu_poll --path /path/to/scripts --exit_when_empty 0 --poll_interval 60`

If running as a module 

`python -m fastcpu.cli --path /path/to/scripts --exit_when_empty 0 --poll_interval 60` 

The above examples will run scrips located in the to_run subdirectory of the directory being monitored
The program will not exit when there are no scripts left to run, it will keep polling since we set that to 0
the polling interval is 60 seconds, it can be set as fractions of a second e.g 0.1

once the program starts it creates the following directory structure. you can then  your scripts in the to_run folder,
and the scrips are run sequentially

```
.
├── complete
├── fail
├── out
├── running
└── to_run
    ├── script_example1.sh
    └── script_example2.sh
```


`fastcpu_poll` will run each script in `to_run` in sorted order. 
Each script will be assigned to one CPU (*future*)

Once a script is selected to be run, it is moved into a directory called `running`. Once it's finished,
it's moved into complete or fail as appropriate. stdout and stderr are captured to files with the same name as the script,
plus stdout or stderr appended.

If exit_when_empty is 1 (which is the default), then once all scripts are run, `fastcpu_poll` will exit.
If it is 0 then `fastcpu_poll` will continue running until it is killed; it will keep polling for any new scripts that are added to `to_run`.


# Development

### local testing

`python -m fastcpu.cli --path test_scripts --exit_when_empty 1 --poll_interval 5 --terminate_timeout 12`

## Troubleshooting

If you get permission denied error in stderr logs check that your scripts are executable
pazgui 0.0.1
Python terminal GUI toolkit
Requires Python: >=3.8

# Terminal GUI toolkit in Python

It is based on [blessed](https://github.com/jquast/blessed) and
provides core GUI functionality;

* Event system
  * Keyboard events
  * Scheduled events (by [schedule](https://github.com/dbader/schedule))
  * Custom events
* Vertical and horizontal auto alignment
* Input widgets
  * Textarea
  * Button
  * Checkbox
  * Password
* Panels
* Progress bar

Check chat interface example in (examples/chat/main.py) .
gitlab-versioned-pages 0.1.6
Include documentation for multiple project versions in a single GitLab page
Keywords: gitlab_versioned_pages

# gitlab-versioned-pages

[![conda](https://img.shields.io/conda/dn/ostrokach-forge/gitlab-versioned-pages.svg)](https://anaconda.org/ostrokach-forge/gitlab-versioned-pages/)
[![docs](https://img.shields.io/badge/docs-v0.1.6-blue.svg)](https://ostrokach.gitlab.io/gitlab-versioned-pages/v0.1.6/)
[![pipeline status](https://gitlab.com/ostrokach/gitlab-versioned-pages/badges/v0.1.6/pipeline.svg)](https://gitlab.com/ostrokach/gitlab-versioned-pages/commits/v0.1.6/)
[![coverage report](https://gitlab.com/ostrokach/gitlab-versioned-pages/badges/v0.1.6/coverage.svg?job=docs)](https://ostrokach.gitlab.io/gitlab-versioned-pages/v0.1.6/htmlcov/)

Include documentation for multiple project versions in a single GitLab page.

## Overview

This package can be used inside a `pages` job in your `.gitlab-ci.yml` pipeline in order to combine documentation for all tagged versions of the package. See the [`.gitlab-ci.yml`](./.gitlab-ci.yml) of this package for an example.

This package also generates a `versions.json`, which can be used together with e.g. the Sphinx [`msmb_theme`](https://github.com/msmbuilder/msmb_theme) in order to include a version selector on the documentation page for each version

## Usage

Add the following stage in your `.gitlab-ci.yml` file to collect documentations for all tagged versions and include them in a single page. The `GITLAB_TOKEN` is a private token that can be created manually inside the GitLab settings page.

```yaml
pages:
  stage: custom
  before_script:
    - pip install gitlab_versioned_pages
  script:
    - mkdir -p ./public
    - python -m gitlab_versioned_pages
      --project-id ${CI_PROJECT_ID}
      --job-name docs
      --private-token ${GITLAB_TOKEN}
      --output-dir ./public
      --url "https://${CI_PROJECT_NAMESPACE}.gitlab.io/${CI_PROJECT_NAME}"
  artifacts:
    paths:
      - public
  only:
    variables:
      - $UPDATE_PAGES
```

## Implementation details

This file creates a `./public` folder containing documentation created for multiple versions (tags) of this repository.

When the repository is public, our job is easy: we simply download the `artifact.zip` file from a publicly-accessible URL (see: [downloading the latest artifacts]). However, when the repository is private, using the above-mentioned URL does not work (see: [gitlab-org/gitlab-ce#22957]). In that case, we resort to using the GitLab API instead.

If [gitlab-org/gitlab-ce#22957] is ever fixed, we would be able to specify
`--header "Private-Token: XXXXX"` or attach `&private_token=XXXXX` to the query string,
and keep using the original URL:

```bash
curl --header "Private-Token: XXXXX" \
    "https://gitlab.com/user/repo/-/jobs/artifacts/ref/download?job=job_name"
```

Good resource: <https://docs.gitlab.com/ee/api/jobs.html#download-the-artifacts-archive>.

<!-- Links -->

[downloading the latest artifacts]: https://docs.gitlab.com/ee/user/project/pipelines/job_artifacts.html#downloading-the-latest-artifacts
[gitlab-org/gitlab-ce#22957]: https://gitlab.com/gitlab-org/gitlab-ce/issues/22957
PDBeCif 1.5
A lightweight pure python package for reading, writing and manipulating mmCIF files distributed by the wwPDB.
Keywords: STAR CIF mmCIF PDB PDBe parsing parser API

![GitHub](https://img.shields.io/github/license/pdbeurope/pdbecif) ![tests](https://github.com/PDBeurope/pdbecif/workflows/pdbecif%20tests/badge.svg) ![documentation](https://github.com/PDBeurope/pdbecif/workflows/pdbecif%20documentation/badge.svg)
# PDBeCIF

PDBeCIF is a package that is used to work with mmCIF formatted files. The package
contains modules for accessing mmCIF data in different ways depending
on the type of task required.

The first mechanism (while slower) allows users to access ANY mmCIF formatted
file and includes Reader and Writer objects for mmCIF file IO.

This not only includes mmCIF data files but mmCIF dictionaries as well.

The second mechanism is a highly optimised (algorithmic) mmCIF parser that
currently has NO Reader and Writer objects. This module (fastCif) can only be
used for accessing public mmCIF data files.

The fastCif module also contains wrappers that emulate python objects from
python dictionaries and so mmCIF categories and items are accessed using 'dot'
notation. There are also convenience methods for searching rows in categories
where items have a particular value.

The documentation on how to use the toolkit can be found [here](https://pdbeurope.github.io/pdbecif/).