semvec/pypi-packages huggingface dataset:
curricula 2.1.2
A content manager and grading toolkit for evaluating student code
Requires Python: >=3.9

# Curricula

[![Codacy Badge](https://api.codacy.com/project/badge/Grade/e6d63124ef0c4a939f726c1609841978)](https://www.codacy.com/manual/csci104/curricula?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=csci104/curricula&amp;utm_campaign=Badge_Grade)

Curricula is a set of specifications and tools for managing content and grading assignments in a college-level computer science setting.
It is currently being developed by [Noah Kim](https://noahbkim.github.io) for CSCI 104, the most challenging core-track C++ course at USC for CS majors.

## How Does it Work?

Curricula covers the two main aspects of managing assignments for a programming course.

1. **Assignment creation**: Curricula provides a schema for developing assignments per-problem rather than all at once.
   This allows content producers to easily port assignments from previous semesters to the evolving parameters of the current.
   Assignments can then be built up from their components problems, separating each and combining their independent parts into packages for publishing, grading, etc.

2. **Submission grading**: the other function of Curricula is to provide a robust framework for testing all aspects of submitted code.
   This includes checks for things like correctness, time complexity, resources leakage, and even code style, all while facilitating granular configuration.
   These tests are written to a universal output format so that they can be reinterpreted without having to re-run the code. 

## Using Curricula

Curricula can be used by installing the [command line interface](https://github.com/csci104/curricula-shell).
This repository only contains the core functionality.
treeplotter 0.5.0
Python package for tree plotting.
Requires Python: >=3.7

# `treeplotter`
[![Actions Status](https://github.com/Luke-Poeppel/treeplotter/workflows/Build/badge.svg)](https://github.com/Luke-Poeppel/treeplotter/actions)
![img](https://img.shields.io/badge/semver-0.5.0-green)

Tree plotting is really hard in Python. The `treeplotter` package aims to make the process easier. It wraps the TreantJS library to plot trees and saves them to a rendered HTML file. This HTML file is then also exported to a high-res PNG by wrapping R's ``webshot`` package. The package requires some complicated installs, but this is the price to pay to not use any R, Javascript, or CSS ;)

### Usage
This library has `Node` and `Tree` classes in the `treeplotter.tree` module. `Node` objects can store various items. We can then specify the node children and parents. A `Tree` is then defined by a root node. From this, we can create tree visualizations. See [here](https://github.com/Luke-Poeppel/treeplotter/blob/master/Tutorial.md) for a complete demo. 

This package is used in the `decitala` package (see [here](https://github.com/Luke-Poeppel/decitala)) to make `FragmentTree` diagrams, like the following one of the Greek Prosodic Feet:

![](https://github.com/Luke-Poeppel/treeplotter/blob/master/images/Prosodic_Tree.png)

![](https://github.com/Luke-Poeppel/treeplotter/blob/master/images/styled_tree.png)

### Installation
The basic package can be installed with
```
$ pip3 install treeplotter
```
To create the tree diagrams, however, some additional installs are required. See [here](https://github.com/Luke-Poeppel/treeplotter/blob/master/Installation.md) for the complete instructions.
nrn-subprocess 1.3.4
Run isolated NEURON simulations in a single Python session.

# NEURON subprocessing

Run multiple NEURON setups isolated from each other from a single Python script.
This package uses Python's `subprocess` to run multiple NEURON instances that
are completely seperated from eachother, making it easier to executed repeated
and parametrized simulations without having to worry about cleaning up the state
of the previous run.

## Installation

```
pip install nrn-subprocess
```

## Usage

Write your entire NEURON setup that you'd like to isolate inside of a function,
then use the `subprocess` or `isolate` approach to execute it in isolation:

### `subprocess`

```
import nrnsub

def my_sim(param1, opt1=None):
  from neuron import h
  s = h.Section(name="main")
  # ...
  return s.v

for i in range(10):
  nrnsub.subprocess(my_sim, 15, opt1=i)
```

This will run the subprocesses in series, parallel coming Soon (tm).

### `isolate`

There's also the `isolate` decorator that will make sure every call to that function is
ran as an isolated subprocess:

```
import nrnsub

@nrnsub.isolate
def my_sim(param1, opt1=None):
  from neuron import h
  s = h.Section(name="main")
  # ...
  return s.v

for i in range(10):
  my_sim(15, opt1=i)
```

## Worker `PATH`

The worker might have trouble unpacking the serialized objects because it can't
find the module they came from on the main process. This might result in `dill`
raising "module not found" errors. To fix them you can pass the `_worker_path` to
`subprocess` or `worker_path` to the `isolate` decorator:

```
import nrnsub

sys.path.insert(0, "/home/me/my_modules_folder")

@nrnsub.isolate(worker_path=["/home/me/my_modules_folder"])
def f():
  import something_in_my_modules_folder
```