semvec/pypi-packages huggingface dataset:
plom 0.20.1
Plom is Paperless Open Marking
Requires Python: >=3.10

# Paperless Open Marking - [Plom](https://plomgrading.org)

  * Plom is a system for large-scale marking by humans of handwritten work.
  * Designed for giving consistent, meaningful feedback to students.
  * [Free/Open Source Software](https://www.gnu.org/licenses/agpl-3.0.en.html)
    written in Python using [Qt](https://pypi.org/project/PyQt6) and other
    components.

<img src="https://plomgrading.org/images/plomclient.png" width="800px" alt="The plom annotation client in action">


## Plom's benefits

  * Respects privacy of student data -- all data stays on your server,
    and markers do not see student name or ID when working.
  * Easy multi-versioned tests -- designed to handle crowded classrooms
    and multi-section courses over multiple days.
  * Simplify logistics and minimizes paper-handling.
  * Free -- Plom is [Libre](https://en.wikipedia.org/wiki/Gratis_versus_libre#Libre)
    and [Gratis](https://en.wikipedia.org/wiki/Gratis_versus_libre#Gratis).
    No software to buy, and no subscriptions to pay.


## Want to know more?

Take a look at the [plomgrading.org](https://plomgrading.org).


## Translations

If you'd like to help translate Plom into another language,
please help at https://gitlab.com/plom/plom/-/issues/1725


## Getting in touch

  * Our dev channel is [gitter.im/plomgrading/dev](https://gitter.im/plomgrading/dev).
  * Our [main development repo is on Gitlab.com](https://gitlab.com/plom/plom)
    and [mirrored on GitHub](https://github.com/plomgrading/plom).
bfiocpp 0.4.0
Tensorstore Based Backend for BFIO
Requires Python: >=3.8

This is the new backend for `bfio`, using `Tensorstore` and other high-throughput IO library

## Build Requirements

`bfiocpp` uses `Tensorstore` for reading and writing OME Tiff and OME Zarr files. So `Tensorstore` build requirements are needed to be satisfied for `bfiocpp` also. 
For Linux, these are the requirements:
- `GCC` 10 or later
- `Clang` 8 or later
- `Python` 3.8 or later
- `CMake` 3.24 or later
- `Perl`, for building *libaom* from source (default). Must be in `PATH`. Not required if `-DTENSORSTORE_USE_SYSTEM_LIBAOM=ON` is specified.
- `NASM`, for building *libjpeg-turbo*, *libaom*, and *dav1d* from source (default). Must be in `PATH`.Not required if `-DTENSORSTORE_USE_SYSTEM_{JPEG,LIBAOM,DAV1D}=ON` is specified.
- `GNU Patch` or equivalent. Must be in `PATH`.


Since `Tensorstore` requires `MACOSX_DEPLOYMENT_TARGET` to be `10.14` or higher (to support sized/aligned operator `new`/`delete`.), `bfiocpp` needs the same.


## Building and Installing

Here is an example of building and installing `bfiocpp` in a Python virtual environment.
```
python -m venv build_venv
source build_venv/bin/activate
git clone https://github.com/PolusAI/bfiocpp.git 
cd bfiocpp
mkdir build_deps
cd build_deps
../ci-utils/install_prereq_linux.sh
cd ..
export BFIOCPP_DEP_DIR=./build_deps/local_install
python setup.py install -vv
```
pyclassparser 0.7
Parse Python classes and attributes from a string of Python code.
Requires Python: >=3.12
Keywords: pydantic, parser, tool, schemas

# PyClassParser

`PyClassParser` is a Python library designed to parse Python class definitions and extract class attributes. It uses the `attrs` library for defining class attributes and ensures type safety with `attrs-strict`.

Currently it only supports Pydantic class format.

## Features

- Parses Python class definitions to extract class names and their attributes.
- Uses `attrs` for attribute definition and `attrs-strict` for type validation.
- Handles optional attributes and attributes with default values.

## Installation

To install `PyClassParser`, you need to have Python 3.x installed. You can install the required dependencies using `pip`:

```bash
pip install attrs attrs-strict
```

## Usage

Here's how you can use `PyClassParser` to parse Python class definitions:

### Example Code

Create a Python script, for example `example.py`:

```python
from pyclassparser import ClassParser

code = """
class MyClass:
    attr1: int
    attr2: str = "default"

class AnotherClass:
    attr3: float
"""
parser = ClassParser(code=code)
print(parser.output)
print(parser.class_data_dict)
```

### Example Output

Running the above script should give you the parsed output of class definitions:

```
class MyClass:
    attr1: int
    attr2: str = "default"

class AnotherClass:
    attr3: float

{'MyClass': [ClassATTR(attr_value='attr1', attr_type='int'), ClassATTR(attr_value='attr2', attr_type='str')], 
 'AnotherClass': [ClassATTR(attr_value='attr3', attr_type='float')]}
```

## Contributing

Contributions are welcome! Please submit a pull request or open an issue to discuss your ideas.

## License

This project is licensed under the MIT License.

## Acknowledgements

This library utilizes `attrs` and `attrs-strict` for attribute definition and type validation. Special thanks to the authors and contributors of these libraries.