semvec/pypi-packages huggingface dataset:
pygamal 1.0.8
This module is for csc281 encryption project
Keywords: python,c,primitive root,encryption,algamal,prime


This module have been made for the project of discret math CSC281 at ksu university.
The project supervisor is Aqil Alazimi. LinkedIn: https://www.linkedin.com/in/aqil-azmi-20903960/
The project repo is: https://github.com/Wouze/csc281-project
ElGamal-c 2.0.2
This module is for csc281 encryption project
Keywords: python,c,primitive root,encryption,algamal,prime


This module have been made for the project of discret math CSC281 at ksu university.
The project supervisor is Aqil Alazimi. LinkedIn: https://www.linkedin.com/in/aqil-azmi-20903960/
The project repo is: https://github.com/Wouze/csc281-project
pycentraldispatch 1.0.12
A simple Grand Central Dispatch (GCD) inspired API for python.
Requires Python: >=3.6

# PyCentralDispatch
A Grand Central Dispatch (GCD) inspired API for python. Not optimal, mostly just for convenience.

Inspired by Mike Ash's [article](https://www.mikeash.com/pyblog/friday-qa-2015-09-04-lets-build-dispatch_queue.html).

## Install

Install the package using `pip`.

```
python3 -m pip install pycentraldispatch
```

## API

The general behavior of this API is inspired by Apple's [Grand Central Dispatch (GCD)](https://en.wikipedia.org/wiki/Grand_Central_Dispatch). The API allows for dispatching
tasks (functions) `synchronously` or `asynchronously`. There are two flavors of queues: `serial` and `concurrent`.

`serial` - Tasks will be executed one-at-a-time in the order they are queued.

`concurrent` - Tasks may be executed in parallel, but they will be started in the order they are queued. 

Additionally, the API provides access to a `global` queue, which is a default singleton concurrent queue that
can be shared across the application.

The primary APIs are `dispatch_sync` and `dispatch_async`, which dispatch the task onto a queue, either
synchronously or asynchronously. The primary difference is that synchronous tasks do not return until the
task is completed. Asynchronous tasks will be run in the background and return from the dispatch call
immediately.

### Global queue

A shared concurrent queue singleton for access across the application.

```
from pycentraldispatch import PyCentralDispatch

# This same singleton queue can be used anywhere in the application.
global_queue = PyCentralDispatch.global_queue()

def some_function():
  print 'hello'

global_queue.dispatch_sync(some_function)  # Prints "hello"
```

### Serial queues

Serial queues do not provide any parallelization. They execute tasks one-at-a-time in the order they were received.

```
from pycentraldispatch import PyCentralDispatch

local_serial_queue = PyCentralDispatch.create_queue(is_serial_queue=True)

def some_function_with_parameters(a, b):
  print a + b
  
local_serial_queue.dispatch_async(some_function_with_parameters, args=(3, 5))  # Prints `8`
```

### Concurrent queues

Concurrent queues allow for tasks to execute in parallel. However the tasks are started in the order they were queued.

```
from pycentraldispatch import PyCentralDispatch

local_concurrent_queue = PyCentralDispatch.create_queue()  # Defaults to concurrent queue.

def some_function_with_parameters(a, b=5):
  print a + b

local_concurrent_queue.dispatch_async(some_function_with_parameters, args=(3,), kwargs={'b' : 3})  # Prints `6`
```
bifurc2midi 0.0.1
This application generates midi bifurcation diagrams generated from generated logistic map data.

# bifurc2midi

This application generates midi bifurcation diagrams generated from generated logistic map data.

See [instructions for installation on macOS](docs/MACOS.md) for more detailed guide on getting started.

## Installation

- Prerequisites:
    - Python 3
    - pip

Make sure pip is up to date:
```bash
python3 -m pip install --upgrade pip
```

- Install package from source code:
```bash
pip install .
```

- Now you can run the application from the command line e.g.
```bash
bifurc2midi --version
```
## Usage

- For help:
```bash
bifurc2midi --help
```

- Run with default settings:
```bash
bifurc2midi
```
This will generate a midi file in the current working directory.

- Sending midi output to a specific device:

```
bifurc2midi --midi-out-device device_name
```

Where `device_name` is the name of the midi device you want to send the output to. Use a `device name` of 'default' to use the first available device e.g.

```bash
bifurc2midi --midi-out-device 'device_name'
```

- Enabling midi loopback driver on macOS (e.g. for use with DAWS):
    1. Open 'Audio MIDI Setup.app'
    2. Click 'Window' -> 'Show MIDI Studio'
    3. Double click 'IAC Driver' device
    4. Check 'Device is online' checkbox
    5. Click 'Apply'
    6. Make sure 'IAC Driver' enabled as a midi input device in your DAW

## Development

- Pre-requisites:
    - Python 3
    - pip
    - virtualenv

- Use the Makefile for local development:

1. Activate a virtual environment:
```bash
make virtualenv
```

2. Activate the virtual environment (not strictly necessary, if using the Makefile only):
```bash
source venv/bin/activate
```

3. Install dependencies:
```bash
make install
```

Then you can:

- Run the application:
```bash
make run
```
Extra arguments can be passed by providing EXTRA_ARGS variable e.g.
```bash
make run EXTRA_ARGS="--help"
```

- Run tests:
```bash
make test
```

- Run linter:
```bash
make lint
```
`make fmt` can be used to automatically fix some linting errors.

- Other useful make targets are provided too, see the Makefile for details. Or run `make`/`make help`

## TODO

- Investigate improving blending of note transitions/overlaps
- Add tests, replace the placeholder test
- Run tests in github actions
- Release as a package
- Review what is settings/parameters are configurable
- Installation shell script
- Add support to specify the starting note
- GUI
- Realtime parameter tweaking as it sends midi to output