semvec/pypi-packages huggingface dataset:
compose-companion 0.2.2
A companion for Docker Compose
Requires Python: >=3.10,<4.0

# Compose Companion

This is a little CLI tool created for my home server.

It aims to make it easy to configure and document scripts that should run before and/or after the server containers on docker compose go up or down.

## Scrips File

The app will read the scripts from a yaml file in the following format:

```yaml
# compose-companion.yaml

x-before-up:
  sonarr:
    - echo this will run before sonarr startup
    - echo this too will run before sonarr startup, after the previous one
  radarr:
    - echo this will run before radarr startup
    - echo this too will run before radarr startup, after the previous one

x-after-up:
  sonarr:
    - echo this will run after sonarr startup
    - echo this too will run after sonarr startup, after the previous one
  radarr:
    - echo this will run after radarr startup
    - echo this too will run after radarr startup, after the previous one

x-before-down:
  sonarr:
    - echo this will run before sonarr shutdown
    - echo this too will run before sonarr shutdown, after the previous one
  radarr:
    - echo this will run before radarr shutdown
    - echo this too will run before radarr shutdown, after the previous one

x-after-down:
  sonarr:
    - echo this will run after sonarr shutdown
    - echo this too will run after sonarr shutdown, after the previous one
  radarr:
    - echo this will run after radarr shutdown
    - echo this too will run after radarr shutdown, after the previous one
```

The container keys should match the ones from `docker-compose.yaml` file.  
The app will look for a file named `compose-companion.yaml` on the folder it's first run, if that's not there it'll ask you to inform the file path manually.  
As the top-level keys start with `x-`, you can use the `docker-compose.yaml` file itself, if you wish, and these settings will be properly ignored by docker compose.  

## Commands

For a list of command, run `compose --help` or simply `compose`.  
For details on each command, run `compose [command] --help`.
AutoDiffpyyy 1.0.0
Package for automatic differentiation by Harvard AC207 students
Requires Python: >=3.5

# AC207 Final Project - `AutoDiffpy`

![coverage.yml](https://code.harvard.edu/CS107/team03/actions/workflows/coverage.yml/badge.svg)

![test.yml](https://code.harvard.edu/CS107/team03/actions/workflows/test.yml/badge.svg)

## Team03 Members
|    Member   |         Email             | 
|-------------|---------------------------|
| Jinglun Gao | jgao1@g.harvard.edu       |
| Chuqin Zhao | chuqingzhao@g.harvard.edu | 
| Chao Wang   | chaowang@g.harvard.edu    | 
| Jiaping Lin | jiapinglin@g.harvard.edu  |  


## Introduction
The `AutoDiffpy` Python package is the project topic of the Harvard AC207 Final Project in Fall 2022, which we writed a python automatic differentiation library. AD is a very broad area spanning computer science and mathematics with applications in fields across science and engineering. Thus, we have build this package to support getting derivatives of large scalar functions and vector functions. Particularly, `AutoDiffpy` could perform forward automatic differentiation that takes dual numbers to compute derivatives sequentially, and could also perform reverse automatic differentiation that computes accurate derivatives to solve problems.

## Simple Install
To install the `AutoDiffpy`, user could run the following command in the terminal.
```
!pip install AutoDiffpy
```
## Documentation
The documentation for the `AutoDiffpy` package can be found [here](https://code.harvard.edu/CS107/team03/blob/jil3612/docs/documentation.md).
bodkin 0.1.1
Library to create and execute computation graphs
Requires Python: >=3.7

Bodkin is a Python library to create, evaluate, and visualize computation graphs.

# Usage / terminology

`bodkin.Node` - an abstract base class for for a black box that updates its outputs based on its inputs

`bodkin.Atom` - a Node that is a fundamental building block. An Atom provides a function to update its outputs from its inputs. An Atom is what we would conventionally refer to as a node in a graph.

`bodkin.DAG` - a directed acyclic graph that encapsulates a set of Nodes and evaluates them in order of dependency. A DAG consists of Node objects, so it may contain Atoms and/or other embedded DAGs.

Any Node's inputs and outputs may be accessed through its properties `i` and `o`, resepectively. These properties behave like dictionaries but can be linked together so that setting a output on one Node also sets an input on some other Node.

To learn more see the `examples/basic.py` script for a basic usage example or pass an object into `help()`. Feel free to open an issue for further questions.

# Installation

## Dependencies

Basic functionality only relies on the standard library, but visualizing objects via their `show` method requires the `dot` command from [`graphviz`](https://graphviz.org/download/).

## From [PyPI](https://pypi.org/project/bodkin/)

Install using pip

```sh
python3 -m pip install bodkin
```