├── .gitignore
├── .gitmodules
├── .travis.yml
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── backend_server
    ├── README.md
    ├── app.yaml
    ├── app_flex.yaml
    ├── appengine_config.py
    ├── configs
    │   ├── gcloud.DEFAULT.yaml
    │   └── local.DEFAULT.yaml
    ├── deploy.sh
    ├── favicon.ico
    ├── main.py
    ├── pybackend
    │   ├── __init__.py
    │   ├── database.py
    │   ├── models.py
    │   ├── oauth.py
    │   ├── storage.py
    │   ├── urilib.py
    │   ├── utils.py
    │   └── version.py
    ├── setup.py
    ├── templates
    │   ├── index.html
    │   └── layout.html
    └── tests
    │   ├── conftest.py
    │   ├── test_main.py
    │   ├── test_pybackend_database.py
    │   ├── test_pybackend_models.py
    │   ├── test_pybackend_oauth.py
    │   ├── test_pybackend_storage.py
    │   ├── test_pybackend_urilib.py
    │   └── test_pybackend_utils.py
├── data
    ├── audio
    │   ├── 267508__mickleness__3nf.ogg
    │   ├── 273427__darshak-bhatti__harmony.ogg
    │   ├── 345515__furbyguy__strings-piano.ogg
    │   ├── 55248__crescendo__asdsdasd.ogg
    │   ├── 58239__crescendo__strings75960.ogg
    │   └── filelist.json
    ├── instrument_taxonomy_v0.json
    └── jamendo
    │   ├── instruments_taxonomy_per_category.json
    │   ├── instruments_taxonomy_per_instrument.json
    │   └── jamendo-instruments-per-track.json
├── docs
    ├── .gitignore
    ├── _config.yml
    ├── _layouts
    │   └── page.html
    ├── annotator.html
    ├── contribute.md
    ├── downloads.md
    ├── img
    │   ├── annotation_state_diagram.png
    │   ├── cas_architecture.png
    │   ├── data-collection.png
    │   ├── roadmap.png
    │   └── system_architecture.png
    ├── index.md
    ├── task1.md
    └── task2.md
└── scripts
    ├── audio_uploader.py
    ├── cli_login_demo.py
    ├── demo.py
    └── filter_successful_uploads.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Byte-compiled / optimized / DLL files
 2 | __pycache__/
 3 | *.py[cod]
 4 | *$py.class
 5 | .DS_Store
 6 | 
 7 | # C extensions
 8 | *.so
 9 | 
10 | # Distribution / packaging
11 | .Python
12 | env/
13 | build/
14 | develop-eggs/
15 | dist/
16 | downloads/
17 | eggs/
18 | .eggs/
19 | lib/
20 | lib64/
21 | parts/
22 | sdist/
23 | tmp/
24 | var/
25 | *.egg-info/
26 | .installed.cfg
27 | *.egg
28 | .config*yaml
29 | 
30 | # PyInstaller
31 | #  Usually these files are written by a python script from a template
32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
33 | *.manifest
34 | *.spec
35 | 
36 | # Installer logs
37 | pip-log.txt
38 | pip-delete-this-directory.txt
39 | 
40 | # Unit test / coverage reports
41 | htmlcov/
42 | .tox/
43 | .coverage
44 | .coverage.*
45 | .cache
46 | nosetests.xml
47 | coverage.xml
48 | *,cover
49 | .hypothesis/
50 | 
51 | # Translations
52 | *.mo
53 | *.pot
54 | 
55 | # Django stuff:
56 | *.log
57 | local_settings.py
58 | 
59 | # Flask stuff:
60 | instance/
61 | .webassets-cache
62 | 
63 | # Scrapy stuff:
64 | .scrapy
65 | 
66 | # Sphinx documentation
67 | docs/_build/
68 | 
69 | # PyBuilder
70 | target/
71 | 
72 | # IPython Notebook
73 | .ipynb_checkpoints
74 | 
75 | # pyenv
76 | .python-version
77 | 
78 | # celery beat schedule file
79 | celerybeat-schedule
80 | 
81 | # dotenv
82 | .env
83 | 
84 | # virtualenv
85 | venv/
86 | ENV/
87 | 
88 | # Spyder project settings
89 | .spyderproject
90 | 
91 | # Rope project settings
92 | .ropeproject
93 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "audio-annotator"]
2 | 	path = audio-annotator
3 | 	url = https://github.com/cosmir/audio-annotator.git
4 |     branch = openmic-dev
5 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | 
 3 | apt:
 4 |   packages:
 5 |   - libgflags-dev
 6 |   - libgtest-dev
 7 | 
 8 | cache:
 9 |   directories:
10 |   - $HOME/env
11 | 
12 | language: python
13 | 
14 | notifications:
15 |   email: false
16 | 
17 | python:
18 |   - "2.7"
19 |   - "3.4"
20 |   - "3.5"
21 | 
22 | install:
23 |   - pip install --upgrade pip
24 |   - pip install --upgrade tox
25 |   - pip install --upgrade protobuf
26 |   - pip install coveralls
27 |   - pip install -e ./backend_server[tests]
28 |   - cp ./backend_server/configs/local.DEFAULT.yaml ./backend_server/.config.yaml
29 | 
30 | script:
31 |   - PYTHONPATH=backend_server:$PYTHONPATH py.test -v --cov=pybackend backend_server/tests
32 | 
33 | after_success:
34 |   - coveralls
35 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Code of Conduct
 2 | 
 3 | As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
 4 | 
 5 | We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
 6 | 
 7 | Examples of unacceptable behavior by participants include:
 8 | 
 9 | * The use of sexualized language or imagery
10 | * Personal attacks
11 | * Trolling or insulting/derogatory comments
12 | * Public or private harassment
13 | * Publishing other's private information, such as physical or electronic addresses, without explicit permission
14 | * Off-topic or unrelated contributions
15 | * Other unethical or unprofessional conduct
16 | 
17 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct,
18 | project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
19 | 
20 | This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community.
21 | 
22 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
23 | 
24 | This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0, available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)
25 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | Contributing
 2 | ============================
 3 | 
 4 | #. Familiarize yourself with the [Code of Conduct](https://github.com/omec/open-mic/blob/master/CODE_OF_CONDUCT.md)
 5 | #. Join the [developers mailing list](https://groups.google.com/forum/#!forum/open-mic-dev)
 6 | #. Feel free to weigh in on issues and discussion
 7 | #. As needed, fork the repo, develop and test your code changes, adding docs.
 8 | #. Make sure that your commit messages clearly describe the changes.
 9 | #. Send a pull request.
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 International Society of Music Information Retrieval
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Open-MIC -- The Open Music Instrument Classification Challenge
 2 | 
 3 | [![Build Status](https://travis-ci.org/cosmir/open-mic.svg?branch=master)](https://travis-ci.org/cosmir/open-mic)
 4 | 
 5 | ## What's going on here?
 6 | 
 7 | This is the source repository for the Open-MIC initiative, a community-driven approach to benchmarking content-based MIR algorithms in a transparent and sustainable way.
 8 | 
 9 | **Relevant Links**
10 | 
11 | - B. McFee, E. J. Humphrey, and J. Urbano. [A Plan for Sustainable MIR Evaluation](https://wp.nyu.edu/ismir2016/wp-content/uploads/sites/2294/2016/07/257_Paper.pdf) ISMIR 2016. [[slides](http://bmcfee.github.io/slides/ismir2016_eval.pdf)]
12 | - [Developer mailing list](https://groups.google.com/forum/#!forum/open-mic-dev)
13 | - [Users mailing list](https://groups.google.com/forum/#!forum/open-mic-users)
14 | 
15 | ## Annotation System Overview
16 | 
17 | This CAS architecture can be described in the following (approximately) sequential manner, where the corresponding functions are numerated in turn:
18 | 
19 | ![Content Annotation System Architecture](https://github.com/cosmir/open-mic/raw/master/docs/img/cas_architecture.png "Content Annotation System Architecture")
20 | 
21 | - Uploader: A collection of audio files, with potentially varying signal parameters, are uploaded into the CAS. In doing so, a number of processes are performed per item:
22 |  - A unique universal resource identifier (URI) is generated.
23 |  - The signal is normalized to a common set of parameters / encoding scheme.
24 |  - Normalized audio data is saved to a binary storage platform with that URI.
25 |  - A record of the audio entity is created and stored under that URI in a database.
26 | - Task Builder: Having creating a normalized, uniquely identified collection, a number of annotation “tasks” are created, whereby the following occurs for each:
27 |  - An audio URI is selected.
28 |  - A N-second “clip” is trimmed from the corresponding audio and imported as a new audio item with appropriate metadata.
29 |  - A new task record is initialized with the clip’s URI and empty state, and stored in a database.
30 | - Annotation: Tasks are served to a web-based annotation tool guided by some backend logic, where users select and submit the music instrument tags recognized.
31 |  - A user registers with the CAS, creating a new user record initialized with a unique URI and empty state, and stored in a database.
32 |  - A user logs into the CAS by providing the appropriate credentials.
33 |  - The annotation front-end requests a task from the server, providing the current user’s information.
34 |  - Audio is rendered in the browser; the user can play the audio any number of times, selecting the music instrument tags deemed relevant.
35 |  - The user attempts to submit their observations; the annotation front-end will accept or reject the response based on the task data received.
36 |  - On occasion, the user is presented with individual and global statistics related to the initiative’s progress.
37 | - Dataset Compiler: Based on the the state of the task collection, a labeled “training” set (audio and instrument tags) and unlabeled “test” (audio only) set are exported from the CAS.
38 |  - The task collection is reviewed, whereby a number of records are deemed “complete.”
39 |  - A randomized subset of complete items are exported as audio clips and labels, under the clip URIs, as the training set.
40 |  - A randomized subset of items from the remaining collection are exported, without labels, as the test set.
41 |  - The URIs for both sets are logged for posterity.
42 | 
43 | ### Roadmap
44 | 
45 | Here is a rough projection of the timeline for progress on the Open-MIC project, as detailed above:
46 | 
47 | ![Open-MIC Roadmap - v1.2](https://github.com/cosmir/open-mic/raw/master/docs/img/roadmap.png "Open-MIC Roadmap - v1.2")
48 | 
49 | 
50 | ## Running the annotation machinery locally
51 | 
52 | The easiest way to get started is to run the demo at the commandline:
53 | 
54 | ```
55 |    $ ./demo.py
56 | ```
57 | 
58 | This will start the backend server (CMS), upload a few audio files, and begin serving the audio annotation tool locally. By default this will appear at [http://localhost:8000/docs/annotator.html](http://localhost:8000/docs/annotator.html).
59 | 
60 | **Notes**:
61 | - It is **strongly** recommended that a private / incognito session is used for demo purposes. Caching behavior in normal browser sessions can cause significant headaches.
62 | - For some reason, loading the audio seems to get "stuck" on occasion. To unblock it, manually proceed to an audio file's URL once the server is running, e.g. [http://localhost:8080/api/v0.1/audio/740c835f-a23d-41ef-b84c-0cd1de4edfa5](http://localhost:8080/api/v0.1/audio/740c835f-a23d-41ef-b84c-0cd1de4edfa5).
63 | 
64 | Alternatively, instructions for running the different parts of the system are listed below.
65 | 
66 | ### Content Management System
67 | 
68 | See the [ReadMe](https://github.com/cosmir/open-mic/blob/master/backend_server/README.md) for details on running the backend web server.
69 | 
70 | ### Audio annotator
71 | 
72 | If this is your first time checking out this repository, you'll need to pull in external
73 | dependencies by saying
74 | 
75 |     git submodule update --init
76 | 
77 | after cloning the repository.
78 | 


--------------------------------------------------------------------------------
/backend_server/README.md:
--------------------------------------------------------------------------------
  1 | # Content Annotation System
  2 | 
  3 | This is the source for the backend Flask server, responsible for the following:
  4 | 
  5 | - Tracking and uniquely identifying users
  6 | - Ingesting source audio
  7 | - Building tasks over the ingested database
  8 | - Serving tasks on request
  9 | - Validating annotation submissions
 10 | - Returning user statistics on request
 11 | 
 12 | 
 13 | ## Annotation State Diagram
 14 | ![Annotation State Diagram](https://github.com/cosmir/open-mic/raw/master/docs/img/annotation_state_diagram.png "Annotation State Diagram")
 15 | 
 16 | 
 17 | ## Dependencies
 18 | 
 19 | First, install the [App Engine Python SDK](https://developers.google.com/appengine/downloads).
 20 | 
 21 | Next, install dependencies in a directory local to this project, e.g. `lib`. App Engine will only be able to import libraries uploaded with the project.
 22 | 
 23 | ```
 24 | $ pip install -r requirements/setup/requirements_dev.txt -t lib
 25 | ```
 26 | 
 27 | ## Testing
 28 | 
 29 | Having taken care of dependencies, you should be able to run the test suite:
 30 | 
 31 | ```
 32 | $ py.test -v .
 33 | ```
 34 | 
 35 | All tests should pass; halt everything if this is not the case. In all likelihood, failure is the result of a broken / missing dependency, but please create a new issue (with a console log and steps to reproduce) if you believe otherwise.
 36 | 
 37 | **Note**: The underlying `google-cloud` library doesn't have the best testing interfaces at the moment; this library is under active development, and hopefully we'll be able to stub out this testing soon. In the meantime, testing is achieved by pinging a live GCP project. To do this, pass a test project flag at the command line:
 38 | 
 39 | ```
 40 | $ TEST_GCP_PROJECT=<YOUR_PROJECT_ID> py.test -v --cov=pybackend tests
 41 | ```
 42 | 
 43 | All affected tests are skipped in the absence of this environment variable.
 44 | 
 45 | ## Using the CAS machinery
 46 | 
 47 | ### Running Locally
 48 | 
 49 | First, follow the directions to install the [App Engine SDK](https://cloud.google.com/appengine/downloads#Google_App_Engine_SDK_for_Python)
 50 | 
 51 | Then, once that's all set, you should be able to do the following from
 52 | repository root:
 53 | 
 54 | ```
 55 | $ dev_appserver.py .
 56 | ```
 57 | 
 58 | At this point, the endpoints should be live via localhost (default deployment is to port 8080):
 59 | 
 60 | ```
 61 | $ curl -X GET localhost:8080/annotation/taxonomy
 62 | $ curl -F "audio=@some_file.mp3" localhost:8080/audio
 63 | ```
 64 | 
 65 | ### Deploying to App Engine
 66 | 
 67 | For the time being, you will need to create your own App Engine project. To do
 68 | so, [follow the directions here](https://console.cloud.google.com/freetrial?redirectPath=/start/appengine).
 69 | 
 70 | Once this is configured, make note of your `PROJECT_ID`, because you're going
 71 | to need to pass it through to the deployment script.
 72 | 
 73 | ```
 74 | $ ./deploy.sh <PROJECT_ID>
 75 | ```
 76 | 
 77 | From here, the app should be deployed to the following URL:
 78 | 
 79 | ```
 80 |   http://<PROJECT_ID>.appspot.com
 81 | ```
 82 | 
 83 | You can then poke the endpoints as one would expect:
 84 | 
 85 | ```
 86 |   $ curl -X GET http://<PROJECT_ID>.appspot.com/api/v0.1/annotation/taxonomy
 87 |   $ curl -F "audio=@some_file.mp3" http://<PROJECT_ID>/api/v0.1/audio
 88 | ```
 89 | 
 90 | 
 91 | ## Shutting Down App Engine
 92 | 
 93 | After deploying the application, you may wish to shut it down so as to not ring up unnecessary charges / usage. Proceed to the following URL and click all the things that say "Shutdown" for maximum certainty:
 94 | 
 95 | ```
 96 |   https://console.cloud.google.com/appengine/instances?project=<PROJECT_ID>
 97 | ```
 98 | 
 99 | Be sure to replace `<PROJECT_ID>` with the appropriate one matching the account you've configured.
100 | 
101 | 
102 | ## OAuth
103 | 
104 | ### Spotify
105 | 
106 | To configure Spotify to verify OAuth credentials, follow the following steps (assuming you already have a Spotify user account):
107 | 
108 | - Go to the [developer portal](https://developer.spotify.com/web-api/) and proceed to "My Applications".
109 | 
110 | - Select "Create an App"; provide it with a human-readable name and description. Note that these will be displayed to a user when authenticating.
111 | 
112 | - Make note of the "Client ID" and "Client Secret", and store them in a YAML file in this repository. You can use either of the template files in `configs/` as a starter, and you'll want to copy it to the backend root with a leading `.`, e.g. `backend_server/.config.cloud.yaml`).
113 | 
114 | - For now, set the "Redirect URI" to the following:
115 |   - [http://localhost:8080/login/authorized/spotify](http://localhost:8080/login/authorized/spotify)
116 |   - [http://localhost:8080/login/authorized/spotify?show_dialog=True](http://localhost:8080/login/authorized/spotify?show_dialog=True)
117 | 
118 | - Make sure you save your changes!
119 | 
120 | ### Google
121 | 
122 | To configure Google to verify OAuth credentials, follow the following steps (assuming you already have a Google Cloud Platform developer account):
123 | 
124 | - Go to the GCP console, at https://console.cloud.google.com/, and select "API" from the menu (the infamous "hamburger" button). From the vertical menu tray on the left-hand side, select "Credentials". You can shortcut this by replacing <YOUR_PROJECT> in the following URL:
125 | 
126 | ```
127 | https://console.cloud.google.com/apis/credentials?project=<YOUR_PROJECT>
128 | ```
129 | 
130 | - Select "Create Credentials", and pick "OAuth client ID" from the pop-up menu.
131 | 
132 | - Select "Web Application" and provide an appropriate name.
133 | 
134 | - Copy the Client ID and Client Secret to the `google` section of the the OAuth config file. Copy this to the backend root directory, and prefix with a leading `.`, e.g. `backend_server/.config.cloud.yaml`.
135 | 
136 | - For now, set the redirect URL to [http://localhost:8080/login/authorized/google](http://localhost:8080/login/authorized/google).
137 | 


--------------------------------------------------------------------------------
/backend_server/app.yaml:
--------------------------------------------------------------------------------
 1 | # Necessary for AppEngine deployment.
 2 | # First, install deps into the lib directory
 3 | #   $ pip install .[appengine] -t lib
 4 | 
 5 | # Python3 (flex) environment only supported in US datacenters :o/
 6 | runtime: python27
 7 | api_version: 1
 8 | threadsafe: true
 9 | 
10 | handlers:
11 | - url: /.*
12 |   script: main.app
13 |   secure: always
14 | 
15 | libraries:
16 | - name: ssl
17 |   version: latest
18 | 
19 | skip_files:
20 | - ^.*\.pyc$
21 | 


--------------------------------------------------------------------------------
/backend_server/app_flex.yaml:
--------------------------------------------------------------------------------
 1 | # Necessary for AppEngine deployment.
 2 | # First, install deps into the lib directory
 3 | #   $ pip install .[appengine] -t lib
 4 | 
 5 | runtime: python
 6 | env: flex
 7 | runtime_config:
 8 |   python_version: 3
 9 | 
10 | entrypoint: gunicorn -b :$PORT appengine_dev:app
11 | 
12 | handlers:
13 | - url: /.*
14 |   script: appengine_dev.app
15 | 
16 | skip_files:
17 | - ^.*\.pyc$
18 | 


--------------------------------------------------------------------------------
/backend_server/appengine_config.py:
--------------------------------------------------------------------------------
1 | from google.appengine.ext import vendor
2 | 
3 | vendor.add('lib')
4 | 


--------------------------------------------------------------------------------
/backend_server/configs/gcloud.DEFAULT.yaml:
--------------------------------------------------------------------------------
 1 | cloud:
 2 |     project: "<YOUR_PROJECT_ID>"
 3 |     storage:
 4 |         name: "open-mic-data"
 5 |         backend: gcloud
 6 |     database:
 7 |         backend: gcloud
 8 |     annotator:
 9 |         scheme: "https"
10 |         netloc: "<YOUR_PROJECT_ID>.appspot.com"
11 | oauth:
12 |     google:
13 |         client_id: "abc"
14 |         client_secret: "xyz"
15 |     spotify:
16 |         client_id: "abc"
17 |         client_secret: "xyz"
18 | annotator:
19 |     static_folder: "./static"


--------------------------------------------------------------------------------
/backend_server/configs/local.DEFAULT.yaml:
--------------------------------------------------------------------------------
 1 | cloud:
 2 |     project: "<YOUR_PROJECT_ID>"
 3 |     storage:
 4 |         name: "audio-data"
 5 |         backend: "local"
 6 |         local_dir: "tmp"
 7 |     database:
 8 |         backend: "local"
 9 |         filepath: "tmp/database-file.json"
10 |         mode: "a"
11 | oauth:
12 |     google:
13 |         client_id: "abc"
14 |         client_secret: "xyz"
15 |     spotify:
16 |         client_id: "abc"
17 |         client_secret: "xyz"
18 | annotator:
19 |     static_folder: "../audio-annotator/static"


--------------------------------------------------------------------------------
/backend_server/deploy.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | if [ -z "$1" ]; then
 5 |     echo "Please provide a project for deployment."
 6 |     exit 1;
 7 | fi
 8 | 
 9 | # Update the gcloud config template and point to it as the default.
10 | sed "s/<YOUR_PROJECT_ID>/$1/" configs/gcloud.DEFAULT.yaml > .config.yaml
11 | 
12 | # Run the test suite, tank deployment on failure.
13 | py.test tests
14 | echo "All tests pass -- deploying"
15 | 
16 | # Install dependencies
17 | LIBDIR=lib
18 | rm -rf $LIBDIR
19 | pip install . -t $LIBDIR
20 | 
21 | # Copy static content
22 | cp -rf ../audio-annotator/static ./
23 | 
24 | gcloud app deploy
25 | 


--------------------------------------------------------------------------------
/backend_server/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/backend_server/favicon.ico


--------------------------------------------------------------------------------
/backend_server/main.py:
--------------------------------------------------------------------------------
  1 | """Flask Backend Server for managing audio content.
  2 | 
  3 | Please see README.md for instructions.
  4 | 
  5 | Starting Locally
  6 | ----------------
  7 | You have two options:
  8 | 
  9 |   $ python main.py --port 8080 --local --debug
 10 | 
 11 | Or, to use GCP backend by default:
 12 | 
 13 |   $ dev_appserver.py .
 14 | 
 15 | 
 16 | Endpoints
 17 | ---------
 18 |   - /audio : POST
 19 |   - /audio/<uri> : GET
 20 |   - /annotation/submit : POST
 21 |   - /annotation/taxonomy : GET
 22 | """
 23 | import argparse
 24 | import datetime
 25 | import io
 26 | import json
 27 | import logging
 28 | import mimetypes
 29 | import os
 30 | import random
 31 | import requests
 32 | import yaml
 33 | 
 34 | from flask import Flask, Response, request, send_file
 35 | from flask import session, redirect, url_for, jsonify, render_template
 36 | 
 37 | from functools import wraps
 38 | 
 39 | import pybackend
 40 | 
 41 | # Python 2.7 doesn't ship with `.json`?
 42 | mimetypes.add_type(mimetypes.guess_type("x.json")[0], '.json')
 43 | logging.basicConfig(level=logging.DEBUG)
 44 | 
 45 | app = Flask(__name__)
 46 | app.secret_key = 'development'
 47 | 
 48 | SOURCE = "https://cosmir.github.io/open-mic/"
 49 | AUDIO_EXTENSIONS = set(['wav', 'ogg', 'mp3', 'au', 'aiff'])
 50 | OAUTH = None
 51 | 
 52 | 
 53 | def configure(cfg):
 54 |     """Configure the (singleton) application object.
 55 | 
 56 |     TODO: Should yell if `cfg` is malformed.
 57 | 
 58 |     Parameters
 59 |     ----------
 60 |     cfg : dict
 61 |         Object containing configuration info.
 62 |     """
 63 |     app.static_folder = cfg['annotator']['static_folder']
 64 |     app.config.update(cloud=cfg['cloud'], oauth=cfg['oauth'])
 65 |     global OAUTH
 66 |     OAUTH = pybackend.oauth.OAuth(app, session)
 67 | 
 68 | 
 69 | # Default configuration
 70 | CONFIG = os.path.join(os.path.dirname(__file__), '.config.yaml')
 71 | with open(CONFIG) as fp:
 72 |     cfg = yaml.load(fp)
 73 |     configure(cfg)
 74 | 
 75 | 
 76 | def authenticate(f):
 77 |     """Decorate a route as requiring authentication."""
 78 |     @wraps(f)
 79 |     def decorated(*args, **kwargs):
 80 |         app.logger.info(session)
 81 |         if any([app.config.get('noauth', False),
 82 |                 session.get(pybackend.oauth.TOKEN, None)]):
 83 |             return f(*args, **kwargs)
 84 |         else:
 85 |             return redirect(url_for('login', _external=True))
 86 | 
 87 |     return decorated
 88 | 
 89 | 
 90 | @app.route('/login')
 91 | @app.route('/login/<app_name>')
 92 | def login(app_name='spotify'):
 93 |     """Start the OAuth login process.
 94 | 
 95 |     Query Parameters
 96 |     ----------------
 97 |     complete : {yes, no}, default=yes
 98 |         Direct the OAuth login process to complete; must be 'no' in order to
 99 |         allow commandline interfaces to successfully authenticate.
100 |     """
101 |     app_name = app_name.lower()
102 |     callback = url_for('authorized', app_name=app_name, _external=True)
103 |     query = ""
104 |     if request.args.get('complete', 'yes') == 'no':
105 |         query += "?complete=no"
106 |     return OAUTH.get(app_name).client.authorize(callback + query)
107 | 
108 | 
109 | @app.route('/login/authorized/<app_name>')
110 | def authorized(app_name='spotify'):
111 |     """Finish the OAuth login process.
112 | 
113 |     This is the callback endpoint registered with different OAuth handlers. For
114 |     commandline interfaces, which require manual intervention, the complete=no
115 |     parameter must be passed through the login redirect route.
116 | 
117 |     TODO: Update this to a more appropriate response once the annotator is
118 |     updated.
119 | 
120 |     Query Parameters
121 |     ----------------
122 |     complete : {yes, no}, default=yes
123 |         Direct the OAuth login process to complete; must be 'no' in order to
124 |         allow commandline interfaces to successfully authenticate.
125 |     """
126 |     app.logger.info("{}".format(request))
127 |     app_name = app_name.lower()
128 |     if request.args.get('complete', 'yes') == 'yes':
129 |         oauthor = OAUTH.get(app_name)
130 |         resp = oauthor.client.authorized_response()
131 |         app.logger.info(resp)
132 |         if resp is None:
133 |             return ('Access denied: reason={error_reason} '
134 |                     'error={error_description}'.format(**request.args))
135 | 
136 |         session[pybackend.oauth.TOKEN] = (resp['access_token'], app_name)
137 |         return redirect(url_for('index'))
138 |     else:
139 |         return ("To complete log-in, proceed to this URL: {}"
140 |                 .format(request.url))
141 | 
142 | 
143 | @app.route('/logout')
144 | def logout():
145 |     """Log the user out of the current session.
146 | 
147 |     TODO: Update this to a more appropriate response once the annotator is
148 |     updated.
149 |     """
150 |     token = session.pop(pybackend.oauth.TOKEN, None)
151 |     return "Success!" if token else "Not currently logged in."
152 | 
153 | 
154 | @app.route("/")
155 | @authenticate
156 | def index():
157 |     """Main entry point for the annotation application."""
158 |     return render_template("index.html")
159 | 
160 | 
161 | @app.route("/me")
162 | @authenticate
163 | def me():
164 |     """Demonstrate that the user has been successfully logged in."""
165 |     token = session.get(pybackend.oauth.TOKEN)
166 |     app.logger.debug(str(token))
167 |     if not token:
168 |         return "No user logged in."
169 | 
170 |     oauthor = OAUTH.get(token[1])
171 |     return jsonify(oauthor.user)
172 | 
173 | 
174 | @app.route('/api/v0.1/audio', methods=['POST'])
175 | @authenticate
176 | def audio_upload():
177 |     """
178 |     To POST files to this endpoint:
179 | 
180 |     $ curl -F "audio=@some_file.mp3" localhost:8080/api/v0.1/audio
181 | 
182 |     TODOs:
183 |       - Store user data (who uploaded this? IP address?)
184 |       - File metadata
185 |     """
186 |     app.logger.info("Upload request from {}".format(request.remote_addr))
187 | 
188 |     audio_data = request.files['audio']
189 |     file_ext = os.path.splitext(audio_data.filename)[-1][1:]
190 |     if file_ext not in AUDIO_EXTENSIONS:
191 |         app.logger.exception('Attempted upload of unsupported filetype.')
192 |         return 'Filetype not supported.', 400
193 | 
194 |     bytestring = audio_data.stream.read()
195 |     app.logger.info("Uploaded data: type={}, len={}"
196 |                     .format(type(bytestring), len(bytestring)))
197 | 
198 |     # Copy to cloud storage
199 |     store = pybackend.storage.Storage(
200 |         project=app.config['cloud']['project'],
201 |         **app.config['cloud']['storage'])
202 | 
203 |     gid = str(pybackend.utils.uuid(bytestring))
204 |     store.put(gid, bytestring)
205 | 
206 |     # Index in the database
207 |     dbase = pybackend.database.Database(
208 |         project=app.config['cloud']['project'],
209 |         **app.config['cloud']['database'])
210 | 
211 |     uri = pybackend.urilib.join('audio', gid)
212 |     record = dict(file_ext=file_ext,
213 |                   created=str(datetime.datetime.now()),
214 |                   remote_addr=request.remote_addr,
215 |                   num_bytes=len(bytestring),
216 |                   **request.form)
217 |     dbase.put(uri, record)
218 |     response_data = dict(
219 |         uri=uri,
220 |         message="Received {} bytes of data.".format(len(bytestring)))
221 | 
222 |     resp = Response(json.dumps(response_data), status=200,
223 |                     mimetype=mimetypes.types_map[".json"])
224 |     resp.headers['Link'] = SOURCE
225 |     return resp
226 | 
227 | 
228 | @app.route('/api/v0.1/audio/<gid>', methods=['GET'])
229 | @authenticate
230 | def audio_download(gid):
231 |     """
232 |     To GET responses from this endpoint:
233 | 
234 |     $ curl -XGET localhost:8080/api/v0.1/audio/\
235 |         bbdde322-c604-4753-b828-9fe8addf17b9
236 |     """
237 |     dbase = pybackend.database.Database(
238 |         project=app.config['cloud']['project'],
239 |         **app.config['cloud']['database'])
240 | 
241 |     uri = pybackend.urilib.join('audio', gid)
242 | 
243 |     entity = dbase.get(uri)
244 |     if entity is None:
245 |         msg = "Resource not found: {}".format(uri)
246 |         app.logger.info(msg)
247 |         resp = Response(
248 |             json.dumps(dict(message=msg)),
249 |             status=404)
250 | 
251 |     else:
252 |         store = pybackend.storage.Storage(
253 |             project=app.config['cloud']['project'],
254 |             **app.config['cloud']['storage'])
255 | 
256 |         data = store.get(gid)
257 |         app.logger.debug("Returning {} bytes".format(len(data)))
258 | 
259 |         filename = os.path.extsep.join([gid, entity['file_ext']])
260 |         resp = send_file(
261 |             io.BytesIO(data),
262 |             attachment_filename=filename,
263 |             mimetype=pybackend.utils.mimetype_for_file(filename))
264 | 
265 |     resp.headers['Link'] = SOURCE
266 |     return resp
267 | 
268 | 
269 | @app.route('/api/v0.1/annotation/submit', methods=['POST'])
270 | @authenticate
271 | def annotation_submit():
272 |     """
273 |     To POST data to this endpoint:
274 | 
275 |     $ curl -H "Content-type: application/json" \
276 |         -X POST localhost:8080/api/v0.1/annotation/submit \
277 |         -d '{"message":"Hello Data"}'
278 |     """
279 |     if request.headers['Content-Type'] == 'application/json':
280 |         app.logger.info("Received Annotation:\n{}"
281 |                         .format(json.dumps(request.json, indent=2)))
282 |         # Do a thing with the annotation
283 |         # Return some progress stats?
284 |         data = json.dumps(dict(message='Success!'))
285 |         status = 200
286 | 
287 |         db = pybackend.database.Database(
288 |             project=app.config['cloud']['project'],
289 |             **app.config['cloud']['database'])
290 |         gid = str(pybackend.utils.uuid(json.dumps(request.json)))
291 |         uri = pybackend.urilib.join('annotation', gid)
292 |         record = pybackend.models.AnnotationResponse(
293 |             created=str(datetime.datetime.now()),
294 |             response=request.json,
295 |             user_id='anonymous')
296 |         db.put(uri, record.flatten())
297 |     else:
298 |         status = 400
299 |         data = json.dumps(dict(message='Invalid Content-Type; '
300 |                                        'only accepts application/json'))
301 | 
302 |     resp = Response(
303 |         data, status=status, mimetype=mimetypes.types_map[".json"])
304 |     resp.headers['Link'] = SOURCE
305 |     return resp
306 | 
307 | 
308 | def get_taxonomy():
309 |     tax_url = ("https://raw.githubusercontent.com/cosmir/open-mic/"
310 |                "master/data/instrument_taxonomy_v0.json")
311 |     res = requests.get(tax_url)
312 |     values = []
313 |     try:
314 |         schema = res.json()
315 |         values = schema['tag_open_mic_instruments']['value']['enum']
316 |     except BaseException as derp:
317 |         app.logger.error("Failed loading taxonomy: {}".format(derp))
318 | 
319 |     return values
320 | 
321 | 
322 | @app.route('/api/v0.1/annotation/taxonomy', methods=['GET'])
323 | def annotation_taxonomy():
324 |     """
325 |     To fetch data at this endpoint:
326 | 
327 |     $ curl -X GET localhost:8080/api/v0.1/annotation/taxonomy
328 |     """
329 |     instruments = get_taxonomy()
330 |     status = 200 if instruments else 400
331 | 
332 |     resp = Response(json.dumps(instruments), status=status)
333 |     resp.headers['Link'] = SOURCE
334 |     return resp
335 | 
336 | 
337 | @app.route('/api/v0.1/task', methods=['GET'])
338 | @authenticate
339 | def next_task():
340 |     """
341 |     To fetch data at this endpoint:
342 | 
343 |     $ curl -X GET localhost:8080/api/v0.1/task
344 |     """
345 |     db = pybackend.database.Database(
346 |         project=app.config['cloud']['project'],
347 |         **app.config['cloud']['database'])
348 | 
349 |     random_uri = random.choice(list(db.uris(kind='audio')))
350 |     audio_url = "api/v0.1/audio/{gid}".format(
351 |         gid=pybackend.urilib.split(random_uri)[1])
352 | 
353 |     task = dict(feedback="none",
354 |                 visualization=random.choice(['waveform', 'spectrogram']),
355 |                 proximityTag=[],
356 |                 annotationTag=get_taxonomy(),
357 |                 url=audio_url,
358 |                 numRecordings='?',
359 |                 recordingIndex=random_uri,
360 |                 tutorialVideoURL="https://www.youtube.com/embed/Bg8-83heFRM",
361 |                 alwaysShowTags=True)
362 |     data = json.dumps(dict(task=task))
363 |     app.logger.debug("Returning:\n{}".format(data))
364 |     resp = Response(data)
365 |     resp.headers['Link'] = SOURCE
366 |     return resp
367 | 
368 | 
369 | @app.errorhandler(500)
370 | def server_error(e):
371 |     logging.exception('An error occurred during a request.')
372 |     return 'An internal error occurred.', 500
373 | 
374 | 
375 | if __name__ == '__main__':
376 |     parser = argparse.ArgumentParser(
377 |         description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
378 |     parser.add_argument(
379 |         '--host', type=str, default='localhost',
380 |         help='Host address for deployment -- 0.0.0.0 for live')
381 |     parser.add_argument(
382 |         "--port", type=int, default=8080,
383 |         help="Port on which to serve.")
384 |     parser.add_argument(
385 |         "--config", type=str,
386 |         help="Absolute path to a config YAML file.")
387 |     parser.add_argument(
388 |         "--noauth",
389 |         action='store_true', help="Disable authentication, for testing.")
390 |     parser.add_argument(
391 |         "--debug",
392 |         action='store_true',
393 |         help="Run the Flask application in debug mode.")
394 | 
395 |     args = parser.parse_args()
396 |     app.config['noauth'] = args.noauth
397 |     if args.config:
398 |         cfg_file = os.path.join(args.config)
399 |         with open(cfg_file) as fp:
400 |             cfg = yaml.load(fp)
401 |             configure(cfg)
402 | 
403 |     app.run(debug=args.debug, host=args.host, port=args.port)
404 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/__init__.py:
--------------------------------------------------------------------------------
 1 | 
 2 | GCLOUD = 'gcloud'
 3 | LOCAL = 'local'
 4 | 
 5 | from . import database
 6 | from . import models
 7 | from . import oauth
 8 | from . import storage
 9 | from . import urilib
10 | from . import utils
11 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/database.py:
--------------------------------------------------------------------------------
  1 | """Client interfaces for local and backend (NoSQL) databases.
  2 | 
  3 | Example
  4 | -------
  5 | >>> import pybackend.database as D
  6 | >>> dbase = D.Database(project='my-fun-project',
  7 |                        backend=S.LOCAL, filepath='my-db.json',
  8 |                        mode=D.APPEND, atomic=True)
  9 | >>> key = "my_song"
 10 | >>> record = dict(a=15, b=['heya', 'hihi'])
 11 | >>> dbase.put(key, record)
 12 | >>> print(dbase.get(key))
 13 | {'a': 15, 'b': ['heya', 'hihi']}
 14 | """
 15 | 
 16 | import json
 17 | from google.cloud import datastore
 18 | import os
 19 | 
 20 | from . import GCLOUD, LOCAL
 21 | from . import urilib
 22 | 
 23 | # Start clean
 24 | WRITE = 'w'
 25 | # Load any existing data
 26 | APPEND = 'a'
 27 | # Immutable / write-safe
 28 | READ = 'r'
 29 | 
 30 | 
 31 | class LocalClient():
 32 |     """A "local" JSON backed database object.
 33 | 
 34 |     TODO: Can / could use a slightly smarter backend to easily mimic the
 35 |     functionality we'll need (multiple indexing), e.g. pandas, mongo, etc.
 36 |     """
 37 | 
 38 |     def __init__(self, project, filepath='', mode=APPEND, atomic=True):
 39 |         """Create a local database client.
 40 | 
 41 |         Parameters
 42 |         ----------
 43 |         project : str
 44 |             Unique identifier for the owner of this storage object.
 45 | 
 46 |         filepath : str
 47 |             Path on disk for writing the persistent database JSON.
 48 | 
 49 |         mode : str, default='a'
 50 |             File mode for accessing the "database", one of
 51 |              * 'r': read only
 52 |              * 'w': write; overwrites the existing file
 53 |              * 'a': append; will attempt to add to the current database.
 54 | 
 55 |         atomic : bool, default=True
 56 |             If True, will flush the database to disk on every `put` operation.
 57 |             Trades performance / speed for guarantees that all data is written.
 58 |         """
 59 |         self._collection = dict()
 60 |         self._filepath = filepath
 61 |         self.mode = mode
 62 |         self.atomic = atomic
 63 |         append_conds = [self.mode in [APPEND, READ],
 64 |                         os.path.exists(self._filepath)]
 65 |         if all(append_conds):
 66 |             with open(self._filepath) as fp:
 67 |                 loaded_items = json.load(fp)
 68 |             self._collection.update(**loaded_items)
 69 | 
 70 |     def __del__(self):
 71 |         if self._collection is not None:
 72 |             self.flush()
 73 | 
 74 |     def flush(self):
 75 |         """Flush all changes to disk."""
 76 |         write_conds = [self.mode in [WRITE, APPEND],
 77 |                        bool(self._filepath)]
 78 |         if all(write_conds):
 79 |             with open(self._filepath, 'w') as fp:
 80 |                 json.dump(self._collection, fp)
 81 | 
 82 |     def get(self, uri):
 83 |         """Get the record for the given URI."""
 84 |         urilib.validate(uri)
 85 |         return self._collection.get(uri)
 86 | 
 87 |     def put(self, uri, record, atomic=False):
 88 |         """Store a record under the given URI.
 89 | 
 90 |         Parameters
 91 |         ----------
 92 |         uri : str
 93 |             URI under which to write the record.
 94 | 
 95 |         record : dict
 96 |             Dictionary object to write.
 97 |         """
 98 |         urilib.validate(uri)
 99 |         # What happens if `uri` is in self._collection?
100 |         self._collection[uri] = record
101 |         if self.atomic or atomic:
102 |             self.flush()
103 | 
104 |     def delete(self, uri):
105 |         """Delete the record for a given URI.
106 | 
107 |         Parameters
108 |         ----------
109 |         uri : str
110 |             URI to delete. Passes quietly if URI does not exist.
111 |         """
112 |         urilib.validate(uri)
113 |         if uri in self._collection:
114 |             self._collection.pop(uri)
115 | 
116 |     def uris(self, kind=None):
117 |         """Returns an iterator over the URIs in the Client.
118 | 
119 |         Parameters
120 |         ----------
121 |         kind : str, default=None
122 |             Optionally filter over the URI kind in the database.
123 | 
124 |         Yields
125 |         ------
126 |         uri : str
127 |             A URI in the collection.
128 |         """
129 |         for uri in self._collection.keys():
130 |             if kind is None or kind == urilib.split(uri)[0]:
131 |                 yield uri
132 | 
133 | 
134 | class GClient(object):
135 |     """Thin wrapper for gcloud's DataStore client.
136 | 
137 |     Notes:
138 |     - We use a URI format (<kind>:<gid>) to pass DataStore "kinds" around.
139 |       This doesn't allow us to hierarchically nest keys, which DS makes
140 |       possible, but we *probably* won't need to leverage this functionality.
141 |     - The put/get interface for Google's native Datastore client requires
142 |       some wrangling in terms of how Key objects are constructed. This
143 |       interface serves to abstract that behavior away.
144 |     """
145 | 
146 |     def __init__(self, project):
147 |         """Create a GCP Datastore client.
148 | 
149 |         Parameters
150 |         ----------
151 |         project : str
152 |             Unique identifier for the owner of this storage object.
153 |         """
154 |         self.project = project
155 | 
156 |     @property
157 |     def _client(self):
158 |         return datastore.Client(self.project)
159 | 
160 |     def get(self, uri):
161 |         """Return a record for the given URI."""
162 |         kind, gid = urilib.split(uri)
163 |         key = self._client.key(kind, gid)
164 |         return dict(**self._client.get(key))
165 | 
166 |     def put(self, uri, record, exclude_from_indexes=None):
167 |         """Put a record into the database."""
168 |         exclude_from_indexes = exclude_from_indexes or []
169 | 
170 |         # Create Entity from record + key
171 |         kind, gid = urilib.split(uri)
172 |         key = self._client.key(kind, gid)
173 | 
174 |         entity = datastore.Entity(
175 |             key, exclude_from_indexes=exclude_from_indexes)
176 |         entity.update(record)
177 |         self._client.put(entity)
178 | 
179 |     def uris(self, kind=None):
180 |         """Iterator over the URIs in the database.
181 | 
182 |         Parameters
183 |         ----------
184 |         kind : str, default=None
185 |             Optionally filter over the URI kind in the database.
186 | 
187 |         Yields
188 |         ------
189 |         uri : str
190 |             A URI in the collection.
191 |         """
192 |         kwargs = dict()
193 |         if kind:
194 |             kwargs.update(kind=kind)
195 |         query = self._client.query(**kwargs)
196 | 
197 |         # Sets a filter in-place on the query to return keys.
198 |         query.keys_only()
199 |         for v in query.fetch():
200 |             yield urilib.join(v.kind, v.key.name)
201 | 
202 | 
203 | BACKENDS = {
204 |     GCLOUD: GClient,
205 |     LOCAL: LocalClient
206 | }
207 | 
208 | 
209 | def Database(project, backend, **kwargs):
210 |     """Factory constructor for different database backends.
211 | 
212 |     Parameters
213 |     ----------
214 |     project : str
215 |         Unique identifier for the owner of this storage object.
216 | 
217 |     backend : str, default='gcloud'
218 |         Backend storage platform to use, one of ['local', 'gcloud'].
219 | 
220 |     **kwargs : Additional arguments to pass through to the different backends.
221 |     """
222 |     return BACKENDS[backend](project, **kwargs)
223 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/models.py:
--------------------------------------------------------------------------------
 1 | import copy
 2 | import json
 3 | 
 4 | 
 5 | class BaseRecord(dict):
 6 |     """Data model for records in the database.
 7 | 
 8 |     Database technologies in use cannot handle nested objects. Records exist
 9 |     to flatten / expand nested fields through JSON serialization.
10 | 
11 |     To subclass, specify the keys to flatten / expand via the `serialized_keys`
12 |     class variable.
13 |     """
14 |     serialized_keys = []
15 | 
16 |     def flatten(self):
17 |         """Return a flattened view of the object."""
18 |         obj = copy.deepcopy(self)
19 |         obj.update(**{k: json.dumps(v) for k, v in obj.items()
20 |                       if k in self.serialized_keys})
21 |         return obj
22 | 
23 |     @classmethod
24 |     def from_flat(cls, **kwargs):
25 |         """Create a record from a set of flattened key-value data."""
26 |         kwargs.update(**{k: json.loads(v) for k, v in kwargs.items()
27 |                          if k in cls.serialized_keys})
28 |         return cls(**kwargs)
29 | 
30 | 
31 | class AnnotationResponse(BaseRecord):
32 |     serialized_keys = ['response']
33 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/oauth.py:
--------------------------------------------------------------------------------
  1 | """Consolidated OAuth interfaces to third-party authentication."""
  2 | 
  3 | import flask_oauthlib.client as client
  4 | 
  5 | GOOGLE = 'google'
  6 | SPOTIFY = 'spotify'
  7 | TOKEN = 'access_token'
  8 | 
  9 | 
 10 | class BaseClient(object):
 11 | 
 12 |     # Subclasses should set the common name of the Client.
 13 |     NAME = ''
 14 | 
 15 |     def __init__(self, oauth, session, client_id, client_secret):
 16 |         if not self.NAME:
 17 |             raise NotImplementedError(
 18 |                 "Subclasses must set `NAME` as a class variable")
 19 |         self.oauth = oauth
 20 |         self.session = session
 21 |         self.client_id = client_id
 22 |         self.client_secret = client_secret
 23 |         self.client = self._build_client()
 24 |         self.client.tokengetter(self._tokengetter)
 25 | 
 26 |     def _build_client(self):
 27 |         raise NotImplementedError("Subclass for third-party apps.")
 28 | 
 29 |     @property
 30 |     def user(self):
 31 |         raise NotImplementedError("Subclass for third-party apps.")
 32 | 
 33 |     def _tokengetter(self):
 34 |         return self.session.get(TOKEN)
 35 | 
 36 | 
 37 | class Google(BaseClient):
 38 |     NAME = GOOGLE
 39 | 
 40 |     def _build_client(self):
 41 |         return self.oauth.remote_app(
 42 |             self.NAME,
 43 |             consumer_key=self.client_id,
 44 |             consumer_secret=self.client_secret,
 45 |             request_token_params={'scope': 'email'},
 46 |             base_url='https://www.googleapis.com/oauth2/v1/',
 47 |             request_token_url=None,
 48 |             access_token_method='POST',
 49 |             access_token_url='https://accounts.google.com/o/oauth2/token',
 50 |             authorize_url='https://accounts.google.com/o/oauth2/auth')
 51 | 
 52 |     @property
 53 |     def user(self):
 54 |         return self.client.get('userinfo').data
 55 | 
 56 | 
 57 | class Spotify(BaseClient):
 58 |     NAME = SPOTIFY
 59 | 
 60 |     def _build_client(self):
 61 |         return self.oauth.remote_app(
 62 |             self.NAME,
 63 |             consumer_key=self.client_id,
 64 |             consumer_secret=self.client_secret,
 65 |             base_url='https://www.spotify.com/account/',
 66 |             authorize_url='https://accounts.spotify.com/authorize?'
 67 |                           'scope=user-read-email',
 68 |             access_token_url='https://accounts.spotify.com/api/token',
 69 |             request_token_url=None,
 70 |             request_token_params=dict(show_dialog=True),
 71 |             access_token_method='POST')
 72 | 
 73 |     @property
 74 |     def user(self):
 75 |         return self.client.get('https://api.spotify.com/v1/me').data
 76 | 
 77 | 
 78 | APPS = {
 79 |     Google.NAME: Google,
 80 |     Spotify.NAME: Spotify,
 81 | }
 82 | 
 83 | 
 84 | class OAuth(object):
 85 | 
 86 |     def __init__(self, app, session):
 87 |         """Create a multi-OAuth interface.
 88 | 
 89 |         Parameters
 90 |         ----------
 91 |         app : flask.Flask
 92 |             Identifier of the running Flask application.
 93 | 
 94 |         session : flask.session
 95 |             View of the current session.
 96 |         """
 97 |         self.oauth = client.OAuth(app)
 98 |         self.session = session
 99 |         self.apps = dict()
100 |         for name, kwargs in app.config['oauth'].items():
101 |             self.apps[name] = APPS[name](self.oauth, self.session, **kwargs)
102 | 
103 |     def get(self, name, default=None):
104 |         """Get an interface to a 3rd-party OAuth app, e.g. 'google'."""
105 |         return self.apps.get(name, default)
106 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/storage.py:
--------------------------------------------------------------------------------
  1 | """Client interfaces for local and backend (binary) data storage.
  2 | 
  3 | Example
  4 | -------
  5 | >>> import pybackend.storage as S
  6 | >>> store = S.Storage(name='blah-blah-5678', project='my-project-3',
  7 |                       backend=S.LOCAL, local_dir="tmp")
  8 | >>> key = "my_song"
  9 | >>> store.upload(b"never gonna give you up...", key)
 10 | >>> print(store.download(key))
 11 | b"hello darkness my old friend"
 12 | """
 13 | from google.cloud import storage
 14 | import io
 15 | import logging
 16 | import os
 17 | import warnings
 18 | 
 19 | from . import GCLOUD, LOCAL
 20 | 
 21 | logger = logging.getLogger(__name__)
 22 | 
 23 | 
 24 | def _makedirs(dpath):
 25 |     if not os.path.exists(dpath):
 26 |         os.makedirs(dpath)
 27 |     return dpath
 28 | 
 29 | 
 30 | class LocalData(object):
 31 | 
 32 |     def __init__(self, name, root):
 33 |         self.name = name
 34 |         self.root = root
 35 | 
 36 |     @property
 37 |     def path(self):
 38 |         return os.path.join(self.root, self.name)
 39 | 
 40 | 
 41 | class LocalBlob(LocalData):
 42 | 
 43 |     def upload_from_string(self, bstream, content_type):
 44 |         """Upload data as a bytestring.
 45 | 
 46 |         Parameters
 47 |         ----------
 48 |         bstream : bytes
 49 |             Bytestring to upload.
 50 | 
 51 |         content_type : str
 52 |             Not used; preserved for consistency with gcloud.storage.
 53 |         """
 54 |         # obj = dict(bstream=bstream, content_type=content_type)
 55 |         with open(self.path, 'wb') as fp:
 56 |             fp.write(bstream)
 57 | 
 58 |     def download_as_string(self):
 59 |         """Upload data as a bytestring.
 60 | 
 61 |         Returns
 62 |         -------
 63 |         bstream : bytes
 64 |             Bytestring format of the data.
 65 |         """
 66 |         with open(self.path, 'rb') as fp:
 67 |             fdata = fp.read()
 68 |         return fdata
 69 | 
 70 | 
 71 | class LocalBucket(LocalData):
 72 | 
 73 |     def __init__(self, name, root):
 74 |         super(LocalBucket, self).__init__(name, root)
 75 | 
 76 |     def blob(self, name):
 77 |         return LocalBlob(name, root=_makedirs(self.path))
 78 | 
 79 |     def get_blob(self, name):
 80 |         return LocalBlob(name, root=self.path)
 81 | 
 82 | 
 83 | class LocalClient(object):
 84 | 
 85 |     def __init__(self, project, root_dir):
 86 |         """Create a local storage client.
 87 | 
 88 |         Paratmeters
 89 |         -----------
 90 |         project : str
 91 |             Unique identifier for the owner of the client.
 92 | 
 93 |         root_dir : str, default=None
 94 |             A directory on disk for writing binary data.
 95 |         """
 96 |         self.project = project
 97 |         self.root_dir = _makedirs(root_dir)
 98 | 
 99 |     def get_bucket(self, name):
100 |         """Returns a bucket for the given name."""
101 |         return LocalBucket(name=name, root=self.root_dir)
102 | 
103 | 
104 | BACKENDS = {
105 |     GCLOUD: storage.Client,
106 |     LOCAL: LocalClient
107 | }
108 | 
109 | 
110 | class Storage(object):
111 | 
112 |     def __init__(self, name, project, backend=GCLOUD,
113 |                  local_dir=None):
114 |         """Create a storage object.
115 | 
116 |         Parameters
117 |         ----------
118 |         name : str
119 |             Unique name for the bucket to use, persistent across instances.
120 | 
121 |         project : str
122 |             Unique identifier for the owner of this storage object.
123 | 
124 |         backend : str, default='gcloud'
125 |             Backend storage platform to use, one of ['local', 'gcloud'].
126 | 
127 |         local_dir : str, default=None
128 |             A local directory on disk to use for local clients; only used if
129 |             backend='local'.
130 |         """
131 |         if backend == LOCAL and local_dir is None:
132 |             raise ValueError(
133 |                 "`local_dir` must be given if backend is '{}'".format(LOCAL))
134 |         self.name = name
135 |         self.project = project
136 |         self._backend = backend
137 |         self._client_kwargs = dict(project=project)
138 |         if self._backend == LOCAL:
139 |             self._client_kwargs.update(
140 |                 root_dir=os.path.abspath(os.path.expanduser(local_dir)))
141 | 
142 |     @property
143 |     def client(self):
144 |         return BACKENDS[self._backend](**self._client_kwargs)
145 | 
146 |     def put(self, key, fdata):
147 |         """Put filedata into GCS.
148 | 
149 |         Parameters
150 |         ----------
151 |         key : str
152 |             Key for writing the file data.
153 | 
154 |         fdata : str
155 |             File's bytestream.
156 |         """
157 |         logger.debug("Uploading {} bytes to {}.".format(len(fdata), key))
158 |         bucket = self.client.get_bucket(self.name)
159 |         blob = bucket.blob(key)
160 |         blob.upload_from_string(fdata, content_type="application/octet-stream")
161 | 
162 |     def get(self, key):
163 |         """Retrieve binary data for the given key.
164 | 
165 |         Parameters
166 |         ----------
167 |         key : str
168 |             Name of the object to retrieve.
169 | 
170 |         Returns
171 |         -------
172 |         data : bytes
173 |             Binary data.
174 |         """
175 |         bucket = self.client.get_bucket(self.name)
176 |         blob = bucket.get_blob(key)
177 |         return blob.download_as_string()
178 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/urilib.py:
--------------------------------------------------------------------------------
 1 | SEP = ":"
 2 | 
 3 | 
 4 | def validate(uri):
 5 |     if uri.count(SEP) != 1 or not all(uri.split(SEP)):
 6 |         raise ValueError(
 7 |             "URI ({}) is malformed; expected `<kind>:<gid>`".format(uri))
 8 | 
 9 | 
10 | def split(uri):
11 |     """Split a URI into an (kind, gid) tuple."""
12 |     validate(uri)
13 |     kind, gid = uri.split(SEP)
14 |     return kind, gid
15 | 
16 | 
17 | def join(*data):
18 |     """Join an (kind, gid) tuple into a URI."""
19 |     if len(data) != 2 or any([SEP in v for v in data]):
20 |         raise ValueError(
21 |             "`data` ({}) is malformed; expected `(kind, gid)`".format(data))
22 |     return SEP.join(data)
23 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/utils.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | import logging
 3 | import mimetypes
 4 | import six
 5 | import six.moves.urllib.error as urlerror
 6 | import six.moves.urllib.parse as urlparse
 7 | import six.moves.urllib.request as urlrequest
 8 | from uuid import UUID
 9 | 
10 | logger = logging.getLogger()
11 | 
12 | 
13 | def uuid(data):
14 |     """Create a unique (deterministic) identifier.
15 | 
16 |     Parameters
17 |     ----------
18 |     data : str
19 |         Some data to drive a deterministic hash.
20 | 
21 |     Returns
22 |     -------
23 |     uuid : uuid
24 |         Generated unique identifier.
25 |     """
26 |     if isinstance(data, six.string_types) and six.PY2:
27 |         data = six.BytesIO(data).buf
28 |     elif isinstance(data, six.string_types) and six.PY3:
29 |         data = bytearray(data, 'utf-8')
30 | 
31 |     hex_data = hashlib.md5(data).hexdigest()
32 |     return UUID(hex=hex_data, version=4)
33 | 
34 | 
35 | def check_connection(default='http://google.com', timeout=1):
36 |     """Test the internet connection.
37 | 
38 |     Parameters
39 |     ----------
40 |     default : str
41 |         URL to test; defaults to a Google IP address.
42 | 
43 |     timeout : number
44 |         Time in seconds to wait before giving up.
45 | 
46 |     Returns
47 |     -------
48 |     success : bool
49 |         True if appears to be online, else False
50 |     """
51 |     success = True
52 |     try:
53 |         surl = urlparse.quote(default, safe=':./')
54 |         urlrequest.urlopen(surl, timeout=timeout)
55 |     except urlerror.URLError as derp:
56 |         success = False
57 |         logger.debug("Network unreachable: {}".format(derp))
58 |     return success
59 | 
60 | 
61 | def mimetype_for_file(fname, strict=False):
62 |     """Return the mimetype for a given file.
63 | 
64 |     If one is not found, defaults to 'application/octect-stream'
65 |     """
66 |     mtype, enc = mimetypes.guess_type(fname)
67 |     if mtype is None and not strict:
68 |         mtype, enc = mimetypes.guess_type('foo.bin')
69 |     return mtype
70 | 


--------------------------------------------------------------------------------
/backend_server/pybackend/version.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | """Version info"""
4 | 
5 | short_version = '0.1'
6 | version = '0.1.0dev'
7 | 


--------------------------------------------------------------------------------
/backend_server/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | import imp
 4 | 
 5 | version = imp.load_source('pybackend.version', 'pybackend/version.py')
 6 | 
 7 | setup(
 8 |     name='pybackend',
 9 |     version=version.version,
10 |     description='Content annotation system machinery.',
11 |     author='open-mic-dev',
12 |     author_email='open-mic-dev@googlegroups.com',
13 |     url='http://github.com/cosmir/open-mic',
14 |     download_url='http://github.com/cosmir/open-mic/releases',
15 |     packages=find_packages(),
16 |     package_data={},
17 |     long_description="""Content annotation system machinery.""",
18 |     classifiers=[
19 |         "License :: OSI Approved :: MIT License (MIT)",
20 |         "Programming Language :: Python",
21 |         "Development Status :: 3 - Alpha",
22 |         "Intended Audience :: Developers",
23 |         "Programming Language :: Python :: 2",
24 |         "Programming Language :: Python :: 2.7",
25 |         "Programming Language :: Python :: 3",
26 |         "Programming Language :: Python :: 3.4",
27 |         "Programming Language :: Python :: 3.5",
28 |     ],
29 |     keywords='audio music sound',
30 |     license='MIT',
31 |     install_requires=[
32 |         'audioread >= 2.0.0',
33 |         'Flask >= 0.11.1',
34 |         'Flask-OAuthlib >= 0.9',
35 |         'requests',
36 |         'six >= 1.3',
37 |         'PyYAML',
38 |         'google-cloud >= 0.22.0'
39 |     ],
40 |     extras_require={
41 |         'tests': ['pytest', 'pytest-cov']
42 |     }
43 | )
44 | 


--------------------------------------------------------------------------------
/backend_server/templates/index.html:
--------------------------------------------------------------------------------
 1 | {% extends "layout.html" %}
 2 | {% block body %}
 3 | <body>
 4 |     <div class="row header">
 5 |         <div class="col s12">
 6 |             <div class="divider"></div>
 7 |         </div>
 8 |         <div class="col s6">
 9 |             <div class="left">
10 |                 <h5>Recording <span id="recording-index"></span> of 9</h5>
11 |                 <h6 class="left">approx. <span id="time-remaining"></span> minutes remaining</h6>
12 |             </div>
13 |         </div>
14 |         <div class="col s6 ">
15 |             <div class="right">
16 |                 <h5>Open-MIC Challenge</h5>
17 |                 <a class="waves-effect waves-light modal-trigger right" href="#modal1">Tutorial Video</a>
18 |             </div>
19 |         </div>
20 |         <div class="col s12">
21 |             <div class="divider bottom"></div>
22 |         </div>
23 |     </div>
24 |     <!-- Modal Structure -->
25 |         <div id="modal1" class="modal">
26 |             <div class="modal-content">
27 |                 <h4>Tutorial Video</h4>
28 |                 <div class="videowrapper">
29 |                     <iframe id="tutorial-video" width="100%" height="100%" frameborder="0" allowfullscreen></iframe>
30 |                 </div>
31 |             </div>
32 |             <div class="modal-footer">
33 |                 <a href="#!" class=" modal-action modal-close waves-effect waves-red btn-flat">Close</a>
34 |             </div>
35 |         </div>
36 |     <div class="row prompt">
37 |         <h4 class="center">Highlight &amp; Tag Each Sound</h4>
38 |         <h6 class="center">Click and drag to create a new annotation. Listen for sound events and tag them from the list under the audio recording.</h6>
39 |     </div>
40 |     <div class="annotation">
41 |         <div class="labels"></div>
42 |         <div class="audio_visual"></div>
43 |         <div class="play_bar"></div>
44 |         <div class="hidden_img"></div>
45 |         <div class="creation_stage_container"></div>
46 |         <div class="submit_container"></div>
47 |     </div>
48 |     <script>
49 |         var dataUrl = 'api/v0.1/task';
50 |         var postUrl = 'api/v0.1/annotation/submit';
51 | 
52 |         $(document).ready(function(){
53 |             $('.modal-trigger').leanModal();
54 |         });
55 |     </script>
56 | {% endblock %}
57 | 


--------------------------------------------------------------------------------
/backend_server/templates/layout.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |     <title>Open-MIC Challenge</title>
 5 | 
 6 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
 7 |     <link rel="stylesheet" href="static/css/materialize.min.css">
 8 |     <link rel="stylesheet" type="text/css" href="static/css/urban-ears.css">
 9 | 
10 |     <script type="text/javascript" src="static/js/lib/jquery-2.2.3.min.js"></script>
11 |     <script type="text/javascript" src="static/js/lib/materialize.min.js"></script>
12 |     <script type="text/javascript" src="static/js/lib/wavesurfer.min.js"></script>
13 |     <script type="text/javascript" src="static/js/lib/wavesurfer.spectrogram.min.js"></script>
14 |     <script type="text/javascript" src="static/js/colormap/colormap.min.js"></script>
15 | 
16 |     <script type="text/javascript" src="static/js/src/message.js"></script>
17 |     <script type="text/javascript" src="static/js/src/wavesurfer.regions.js"></script>
18 |     <script type="text/javascript" src="static/js/src/wavesurfer.drawer.extended.js"></script>
19 |     <script type="text/javascript" src="static/js/src/wavesurfer.labels.js"></script>
20 |     <script type="text/javascript" src="static/js/src/hidden_image.js"></script>
21 |     <script type="text/javascript" src="static/js/src/components.js"></script>
22 |     <script type="text/javascript" src="static/js/src/annotation_stages.js"></script>
23 |     <script type="text/javascript" src="static/js/src/main.js" defer></script>
24 | </head>
25 | 
26 | {% block body %}{% endblock %}


--------------------------------------------------------------------------------
/backend_server/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | import os
 4 | import yaml
 5 | 
 6 | 
 7 | @pytest.fixture()
 8 | def sample_app():
 9 |     import main
10 | 
11 |     cfg_file = os.path.join(os.path.dirname(__file__), os.pardir,
12 |                             'configs', 'local.DEFAULT.yaml')
13 |     with open(cfg_file) as fp:
14 |         cfg = yaml.load(fp)
15 | 
16 |     main.app.config.update(cloud=cfg['cloud'], oauth=cfg['oauth'], noauth=True)
17 |     main.app.testing = True
18 |     with main.app.test_client() as client:
19 |         # This forces the app to pass authentication; however, it doesn't (yet)
20 |         # let us test that authenticated routes are blocked.
21 |         with client.session_transaction() as sess:
22 |             sess['access_token'] = ('fluflu', None)
23 |         return client
24 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_main.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | from io import BytesIO
 4 | import json
 5 | import requests.status_codes
 6 | 
 7 | import pybackend.urilib as urilib
 8 | import pybackend.utils as utils
 9 | 
10 | 
11 | def test_audio_upload(sample_app):
12 |     data = dict(audio=(BytesIO(b'my file contents'), 'blah.wav'))
13 |     r = sample_app.post('/api/v0.1/audio', data=data)
14 |     assert r.status_code == requests.status_codes.codes.OK
15 |     data = json.loads(r.data.decode('utf-8'))
16 |     assert data['uri']
17 |     kind, gid = urilib.split(data['uri'])
18 |     assert kind == 'audio'
19 | 
20 | 
21 | def test_audio_upload_method_not_allowed(sample_app):
22 |     r = sample_app.get('/api/v0.1/audio')
23 |     assert r.status_code == requests.status_codes.codes.METHOD_NOT_ALLOWED
24 | 
25 | 
26 | def test_audio_upload_bad_filetype(sample_app):
27 |     data = dict(audio=(BytesIO(b'new file contents'), 'blah.exe'))
28 |     r = sample_app.post('/api/v0.1/audio', data=data)
29 |     assert r.status_code == requests.status_codes.codes.BAD_REQUEST
30 | 
31 | 
32 | def test_audio_get(sample_app):
33 |     # First we'll generate data...
34 |     content = b'my new file contents'
35 |     data = dict(audio=(BytesIO(content), 'blah.wav'))
36 |     r = sample_app.post('/api/v0.1/audio', data=data)
37 |     assert r.status_code == requests.status_codes.codes.OK
38 |     uri = json.loads(r.data.decode('utf-8'))['uri']
39 |     kind, gid = urilib.split(uri)
40 |     # Now let's go looking for it
41 |     r = sample_app.get('/api/v0.1/audio/{}'.format(gid))
42 |     assert r.status_code == requests.status_codes.codes.OK
43 |     assert r.data == content
44 | 
45 | 
46 | def test_audio_get_no_resource(sample_app):
47 |     r = sample_app.get('/api/v0.1/audio/{}'.format("definitelydoesntexist"))
48 |     assert r.status_code == requests.status_codes.codes.NOT_FOUND
49 | 
50 | 
51 | def test_audio_post_fails(sample_app):
52 |     data = dict(audio=(BytesIO(b'my new file contents'), 'blah.wav'))
53 |     r = sample_app.post('/api/v0.1/audio/{}'.format("abc"), data=data)
54 |     assert r.status_code == requests.status_codes.codes.METHOD_NOT_ALLOWED
55 | 
56 | 
57 | def test_annotation_submit(sample_app):
58 |     r = sample_app.post('/api/v0.1/annotation/submit',
59 |                         data=json.dumps(dict(foo='bar')),
60 |                         content_type='application/json')
61 |     assert r.status_code == requests.status_codes.codes.OK
62 | 
63 | 
64 | @pytest.mark.skipif(not utils.check_connection(), reason='No internet')
65 | def test_annotation_taxonomy(sample_app):
66 |     r = sample_app.get('/api/v0.1/annotation/taxonomy')
67 |     assert r.status_code == requests.status_codes.codes.OK
68 | 
69 | 
70 | def test_task_get(sample_app):
71 |     r = sample_app.get('/api/v0.1/task')
72 |     assert r.status_code == requests.status_codes.codes.OK
73 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_database.py:
--------------------------------------------------------------------------------
  1 | import flask
  2 | import pytest
  3 | import json
  4 | import os
  5 | 
  6 | import pybackend.database as D
  7 | 
  8 | TEST_GCP_PROJECT = os.environ.get('TEST_GCP_PROJECT', None)
  9 | 
 10 | 
 11 | @pytest.fixture()
 12 | def json_file(tmpdir):
 13 |     return os.path.join(str(tmpdir), 'json_file.json')
 14 | 
 15 | 
 16 | def test_LocalClient___init__():
 17 |     db = D.LocalClient('my-project')
 18 |     assert db
 19 |     assert db.get('a:1234') is None
 20 | 
 21 | 
 22 | def test_LocalClient_put_get():
 23 |     uri = 'a:1234'
 24 |     db = D.LocalClient('my-project')
 25 |     assert db
 26 |     assert db.get(uri) is None
 27 | 
 28 |     exp_rec = dict(x=1, y='13')
 29 |     db.put(uri, exp_rec)
 30 |     act_rec = db.get(uri)
 31 |     assert act_rec == exp_rec
 32 | 
 33 | 
 34 | def test_LocalClient_read(json_file):
 35 |     uri = 'a:1234'
 36 |     exp_rec = dict(x=1, y='13')
 37 |     collec = {uri: exp_rec}
 38 |     with open(json_file, 'w') as fp:
 39 |         json.dump(collec, fp)
 40 | 
 41 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.READ)
 42 |     act_rec = db.get(uri)
 43 |     assert act_rec == exp_rec
 44 | 
 45 |     uri2 = 'b:1235'
 46 |     db.put(uri2, dict(x=12049, y='blah blah'))
 47 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.READ)
 48 | 
 49 |     assert db.get(uri2) is None
 50 | 
 51 | 
 52 | def test_LocalClient_write(json_file):
 53 |     uri = 'a:1234'
 54 |     exp_rec = dict(x=1, y='13')
 55 |     collec = {uri: exp_rec}
 56 |     with open(json_file, 'w') as fp:
 57 |         json.dump(collec, fp)
 58 | 
 59 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.WRITE)
 60 |     assert db.get(uri) is None
 61 | 
 62 |     uri2 = 'b:5678'
 63 |     db.put(uri2, exp_rec)
 64 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.READ)
 65 |     assert db.get(uri2) == exp_rec
 66 | 
 67 | 
 68 | def test_LocalClient_append(json_file):
 69 |     uri1 = 'g:1357'
 70 |     exp_rec = dict(x=1, y='13')
 71 |     collec = {uri1: exp_rec}
 72 |     with open(json_file, 'w') as fp:
 73 |         json.dump(collec, fp)
 74 | 
 75 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.APPEND)
 76 |     assert db.get(uri1) == exp_rec
 77 | 
 78 |     uri2 = 'apple:158902'
 79 |     rec2 = dict(x='asdlkfj', y=[13])
 80 |     db.put(uri2, rec2)
 81 | 
 82 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.APPEND)
 83 |     assert db.get(uri1) == exp_rec
 84 |     assert db.get(uri2) == rec2
 85 | 
 86 | 
 87 | def test_LocalClient_delete(json_file):
 88 |     uri = 'g:9876'
 89 |     exp_rec = dict(x=1, y='13')
 90 |     collec = {uri: exp_rec}
 91 |     with open(json_file, 'w') as fp:
 92 |         json.dump(collec, fp)
 93 |     db = D.LocalClient('my-project', filepath=json_file, mode=D.APPEND)
 94 |     assert db.get(uri) == exp_rec
 95 |     db.delete(uri)
 96 |     assert db.get(uri) is None
 97 | 
 98 | 
 99 | @pytest.fixture()
100 | def sample_client(json_file):
101 |     uri = 'animal:1h2j34'
102 |     exp_rec = dict(x=1, y='13')
103 |     collec = {uri: exp_rec}
104 |     with open(json_file, 'w') as fp:
105 |         json.dump(collec, fp)
106 |     return D.LocalClient('my-project', filepath=json_file, mode=D.READ)
107 | 
108 | 
109 | def test_LocalClient_uris(sample_client):
110 |     uris = list(sample_client.uris())
111 |     assert len(uris) == 1
112 |     assert sample_client.get(uris[0]) == dict(x=1, y='13')
113 | 
114 | 
115 | def test_GClient___init__():
116 |     assert D.GClient('my-proj') is not None
117 | 
118 | 
119 | @pytest.mark.skipif(
120 |     TEST_GCP_PROJECT is None,
121 |     reason="Environment variable `TEST_GCP_PROJECT` is unset; "
122 |            "unable to test DataStore")
123 | def test_GClient__client():
124 |     db = D.GClient(TEST_GCP_PROJECT)
125 |     assert db._client is not None
126 | 
127 | 
128 | @pytest.mark.skipif(
129 |     TEST_GCP_PROJECT is None,
130 |     reason="Environment variable `TEST_GCP_PROJECT` is unset; "
131 |            "unable to test DataStore")
132 | def test_GClient_put_get():
133 |     uri = 'book:asdf1234'
134 |     record = dict(title='my favorite book', author='aristotle')
135 |     db = D.GClient(TEST_GCP_PROJECT)
136 |     db.put(uri, record)
137 |     assert db.get(uri) == record
138 | 
139 | 
140 | @pytest.mark.skipif(
141 |     TEST_GCP_PROJECT is None,
142 |     reason="Environment variable `TEST_GCP_PROJECT` is unset; "
143 |            "unable to test DataStore")
144 | def test_GClient_uris():
145 | 
146 |     uri = 'book:asdf123456789'
147 |     record = dict(title='a lot of words', author='tolstoy')
148 |     db = D.GClient(TEST_GCP_PROJECT)
149 |     db.put(uri, record)
150 | 
151 |     for uri in db.uris():
152 |         break
153 |     assert uri
154 | 
155 |     for uri in db.uris(kind='book'):
156 |         break
157 |     assert "book:" in uri
158 | 
159 | 
160 | def test_Database_local(json_file):
161 |     db = D.Database('my-project', backend='local',
162 |                     filepath=json_file, mode=D.APPEND)
163 |     assert db
164 |     uri = 'a:1582934'
165 |     db.put(uri, dict(name='ringo'))
166 |     assert db.get(uri)
167 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_models.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import json
 3 | import pybackend.models as M
 4 | 
 5 | 
 6 | def test_BaseRecord___init__():
 7 |     rec = M.BaseRecord()
 8 |     assert len(rec.serialized_keys) == 0
 9 | 
10 | 
11 | class DummyRecord(M.BaseRecord):
12 |     serialized_keys = ['a']
13 | 
14 | 
15 | def test_DummyRecord_flatten():
16 |     a = dict(x=13, y=['d', 'e', 'f'])
17 |     b = "fluflu"
18 |     rec = DummyRecord(a=a, b=b)
19 |     flatrec = rec.flatten()
20 | 
21 |     assert isinstance(flatrec['a'], str)
22 |     assert isinstance(rec['a'], dict)
23 |     assert flatrec['b'] == rec['b'] == b
24 | 
25 | 
26 | def test_DummyRecord_expand():
27 |     a = dict(x=13, y=['d', 'e', 'f'])
28 |     aflat = json.dumps(a)
29 |     b = "fluflu"
30 | 
31 |     rec = DummyRecord.from_flat(**{'a': aflat, 'b': b})
32 |     assert rec['a'] == a
33 |     assert rec['b'] == b
34 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_oauth.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | import flask
 4 | import flask_oauthlib.client as client
 5 | 
 6 | import pybackend.oauth as OA
 7 | 
 8 | 
 9 | @pytest.fixture()
10 | def dummy_oauth(sample_app):
11 |     return client.OAuth(sample_app)
12 | 
13 | 
14 | class DummyClient(object):
15 |     def tokengetter(self, *args, **kwargs):
16 |         pass
17 | 
18 | 
19 | def test_BaseClient___init__(sample_app):
20 | 
21 |     with pytest.raises(NotImplementedError):
22 |         OA.BaseClient(None, None, 'id', 'secret')
23 | 
24 |     class TestBaseClient(OA.BaseClient):
25 |         NAME = "test-base-client"
26 | 
27 |         def _build_client(self):
28 |             return DummyClient()
29 | 
30 |         def user(self):
31 |             return {'me': 'abcd'}
32 | 
33 |     bc = TestBaseClient(sample_app, flask.session, 'id', 'secret')
34 |     assert bc is not None
35 |     assert bc.user is not None
36 | 
37 | 
38 | def test_Google___init__(dummy_oauth):
39 |     bc = OA.Google(dummy_oauth, flask.session, 'id', 'secret')
40 |     assert bc is not None
41 | 
42 | 
43 | def test_Spotify___init__(dummy_oauth):
44 |     bc = OA.Spotify(dummy_oauth, flask.session, 'id', 'secret')
45 |     assert bc is not None
46 | 
47 | 
48 | def test_OAuth___init__(sample_app):
49 |     sample_app.config = dict(
50 |         oauth=dict(spotify=dict(client_id='foo', client_secret='shhh'),
51 |                    google=dict(client_id='bar', client_secret='dontell')))
52 |     oauth = OA.OAuth(sample_app, flask.session)
53 |     assert oauth is not None
54 | 
55 | 
56 | def test_OAuth_get(sample_app):
57 |     sample_app.config = dict(
58 |         oauth=dict(spotify=dict(client_id='foo', client_secret='shhh'),
59 |                    google=dict(client_id='bar', client_secret='dontell')))
60 |     oauth = OA.OAuth(sample_app, flask.session)
61 |     for name in ["spotify", "google"]:
62 |         assert oauth.get(name)
63 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_storage.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import os
 3 | 
 4 | import pybackend.storage as S
 5 | 
 6 | 
 7 | def test_LocalData___init__(tmpdir):
 8 |     assert S.LocalData('foo', str(tmpdir)) is not None
 9 | 
10 | 
11 | def test_LocalData_path(tmpdir):
12 |     name = 'foobar'
13 |     ldata = S.LocalData(name, str(tmpdir))
14 |     assert ldata.path.endswith(name)
15 | 
16 | 
17 | def test_LocalBlob_upload_from_string(tmpdir):
18 |     blob = S.LocalBlob('foobaz.json', str(tmpdir))
19 |     sdata = b"hooo boy, hooeee"
20 |     blob.upload_from_string(sdata, "application/octet-stream")
21 |     assert os.path.exists(blob.path)
22 | 
23 | 
24 | def test_LocalBlob_download_as_string(tmpdir):
25 |     blob = S.LocalBlob('foobaz.json', str(tmpdir))
26 |     sdata = b"hooo boy, hooeee"
27 |     blob.upload_from_string(sdata, "application/octet-stream")
28 |     assert blob.download_as_string() == sdata
29 | 
30 | 
31 | def test_LocalBucket_blob(tmpdir):
32 |     bucket = S.LocalBucket('foobizbaz', str(tmpdir))
33 |     key = "barbar.json"
34 |     blob = bucket.blob(key)
35 |     assert os.path.exists(bucket.path)
36 |     assert blob.path.endswith(key)
37 | 
38 | 
39 | def test_LocalBucket_get_blob(tmpdir):
40 |     bucket = S.LocalBucket('foobizbaz', str(tmpdir))
41 |     key = "barbar.json"
42 |     blob = bucket.blob(key)
43 |     assert os.path.exists(bucket.path)
44 |     assert blob.path.endswith(key)
45 | 
46 |     blob2 = bucket.get_blob(key)
47 |     assert blob2
48 | 
49 | 
50 | def test_LocalClient___init__(tmpdir):
51 |     assert S.LocalClient('my-project', str(tmpdir))
52 | 
53 | 
54 | def test_LocalClient_get_bucket(tmpdir):
55 |     client = S.LocalClient('my-project', str(tmpdir))
56 |     bucket = client.get_bucket('fluflu')
57 |     assert bucket
58 |     assert isinstance(bucket, S.LocalBucket)
59 | 
60 | 
61 | def test_Storage___init__(tmpdir):
62 |     assert S.Storage('blah-blah', 'my-project', backend=S.GCLOUD)
63 |     with pytest.raises(ValueError):
64 |         S.Storage('blah-blah', 'my-project', backend=S.LOCAL)
65 |     assert S.Storage('blah-blah', 'my-project', backend=S.LOCAL,
66 |                      local_dir=str(tmpdir))
67 | 
68 | 
69 | def test_Storage_client(tmpdir):
70 |     store = S.Storage('blah-blah-1234', 'my-project-2', backend=S.LOCAL,
71 |                       local_dir=str(tmpdir))
72 |     assert store.client
73 |     assert isinstance(store.client, S.LocalClient)
74 | 
75 | 
76 | def test_Storage_put(tmpdir):
77 |     store = S.Storage('blah-blah-5678', 'my-project-3', backend=S.LOCAL,
78 |                       local_dir=str(tmpdir))
79 |     store.put('song', b"hello darkness my old friend")
80 | 
81 | 
82 | def test_Storage_download(tmpdir):
83 |     store = S.Storage('blah-blah-5678', 'my-project-3', backend=S.LOCAL,
84 |                       local_dir=str(tmpdir))
85 |     key = 'my_song'
86 |     fdata = b"hello darkness my old friend"
87 |     store.put(key, fdata)
88 |     res = store.get(key)
89 |     assert res == fdata
90 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_urilib.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | 
 3 | import pybackend.urilib as U
 4 | 
 5 | 
 6 | def test_validate():
 7 |     U.validate("x:y")
 8 |     with pytest.raises(ValueError):
 9 |         U.validate(":x")
10 | 
11 |     with pytest.raises(ValueError):
12 |         U.validate("y:")
13 | 
14 |     with pytest.raises(ValueError):
15 |         U.validate(":")
16 | 
17 |     with pytest.raises(ValueError):
18 |         U.validate("x:x:y")
19 | 
20 | 
21 | def test_split():
22 |     assert U.split("x:y") == ("x", "y")
23 |     with pytest.raises(ValueError):
24 |         U.split(":x")
25 | 
26 | 
27 | def test_join():
28 |     assert U.join("x", "y") == "x:y"
29 | 
30 |     with pytest.raises(ValueError):
31 |         U.join("x")
32 | 
33 |     with pytest.raises(ValueError):
34 |         U.join("x", "y", "z")
35 | 
36 |     with pytest.raises(ValueError):
37 |         U.join(":x", "y")
38 | 


--------------------------------------------------------------------------------
/backend_server/tests/test_pybackend_utils.py:
--------------------------------------------------------------------------------
 1 | from __future__ import print_function
 2 | import pytest
 3 | 
 4 | import pybackend.utils
 5 | 
 6 | 
 7 | def test_utils_uuid():
 8 |     data = 'blahblah'
 9 |     # Expected hash determined by inspection
10 |     exp = "42d388f8-b1db-497f-aaf7-dab487f11290"
11 |     uuid1 = pybackend.utils.uuid(data)
12 |     assert uuid1 == pybackend.utils.uuid(data)
13 |     assert str(uuid1) == exp
14 |     assert uuid1 != pybackend.utils.uuid('foobar')
15 | 
16 | 
17 | def test_check_connection():
18 |     assert not pybackend.utils.check_connection("http://blahblah")
19 |     assert pybackend.utils.check_connection("http://google.com")
20 | 
21 | 
22 | def test_mimetype_for_file():
23 |     fnames = ['x.json', 'x.monkey']
24 |     mtypes = ['application/json', 'application/octet-stream']
25 |     for fn, m in zip(fnames, mtypes):
26 |         assert pybackend.utils.mimetype_for_file(fn) == m
27 | 


--------------------------------------------------------------------------------
/data/audio/267508__mickleness__3nf.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/data/audio/267508__mickleness__3nf.ogg


--------------------------------------------------------------------------------
/data/audio/273427__darshak-bhatti__harmony.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/data/audio/273427__darshak-bhatti__harmony.ogg


--------------------------------------------------------------------------------
/data/audio/345515__furbyguy__strings-piano.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/data/audio/345515__furbyguy__strings-piano.ogg


--------------------------------------------------------------------------------
/data/audio/55248__crescendo__asdsdasd.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/data/audio/55248__crescendo__asdsdasd.ogg


--------------------------------------------------------------------------------
/data/audio/58239__crescendo__strings75960.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/data/audio/58239__crescendo__strings75960.ogg


--------------------------------------------------------------------------------
/data/audio/filelist.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "filename": "data/audio/267508__mickleness__3nf.ogg",
 4 |     "metadata": {
 5 |       "url": "http://freesound.org/people/mickleness/sounds/267508/"
 6 |     }
 7 |   },
 8 |   {
 9 |     "filename": "data/audio/273427__darshak-bhatti__harmony.ogg",
10 |     "metadata": {
11 |       "url": "http://freesound.org/people/darshak_bhatti/sounds/273427/"
12 |     }
13 |   },
14 |   {
15 |     "filename": "data/audio/345515__furbyguy__strings-piano.ogg",
16 |     "metadata": {
17 |       "url": "http://freesound.org/people/furbyguy/sounds/345515/"
18 |     }
19 |   },
20 |   {
21 |     "filename": "data/audio/55248__crescendo__asdsdasd.ogg",
22 |     "metadata": {
23 |       "url": "http://freesound.org/people/crescendo/sounds/55248/"
24 |     }
25 |   },
26 |   {
27 |     "filename": "data/audio/58239__crescendo__strings75960.ogg",
28 |     "metadata": {
29 |       "url": "http://freesound.org/people/crescendo/sounds/58239/"
30 |     }
31 |   }
32 | ]


--------------------------------------------------------------------------------
/data/instrument_taxonomy_v0.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "tag_open_mic_instruments":
 3 |     {
 4 |         "value": {
 5 |             "enum": [
 6 |                 "accordion",
 7 |                 "banjo",
 8 |                 "bass",
 9 |                 "cello",
10 |                 "clarinet",
11 |                 "cymbals",
12 |                 "drums",
13 |                 "flute",
14 |                 "guitar",
15 |                 "harmonica",
16 |                 "harp",
17 |                 "harpsichord",
18 |                 "mallet percusion",
19 |                 "mandolin",
20 |                 "oboe",
21 |                 "organ",
22 |                 "piano",
23 |                 "saxophone",
24 |                 "synthesizer",
25 |                 "trombone",
26 |                 "trumpet",
27 |                 "ukulele",
28 |                 "violin",
29 |                 "vocals"
30 |             ]
31 |         },
32 |         "dense": false,
33 |         "description": "Open-Mic Instrument Taxonomy -- v0"
34 |     }
35 | }


--------------------------------------------------------------------------------
/data/jamendo/instruments_taxonomy_per_category.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "electric": [
  3 |         "bass", 
  4 |         "electric guitar", 
  5 |         "electric piano", 
  6 |         "hammond", 
  7 |         "harmonium", 
  8 |         "mellotron", 
  9 |         "rhodes", 
 10 |         "slide guitar", 
 11 |         "theremin"
 12 |     ], 
 13 |     "percussion": [
 14 |         "balafon", 
 15 |         "bell", 
 16 |         "bodhran", 
 17 |         "bongo", 
 18 |         "cabasa", 
 19 |         "cajon", 
 20 |         "carillon", 
 21 |         "castanets", 
 22 |         "conga", 
 23 |         "cowbell", 
 24 |         "cymbal", 
 25 |         "djembe", 
 26 |         "drum", 
 27 |         "dunun", 
 28 |         "glockenspiel", 
 29 |         "gobletdrum", 
 30 |         "handbell", 
 31 |         "hang drum", 
 32 |         "marimba", 
 33 |         "metallophone", 
 34 |         "pandeiro", 
 35 |         "shekere", 
 36 |         "steelpan", 
 37 |         "tabla", 
 38 |         "taiko", 
 39 |         "tambourine", 
 40 |         "tamtam", 
 41 |         "timpani", 
 42 |         "triangle", 
 43 |         "tubular bell", 
 44 |         "udu", 
 45 |         "vibraphone", 
 46 |         "xylophone"
 47 |     ], 
 48 |     "others": [
 49 |         "accordion", 
 50 |         "bagpipes", 
 51 |         "bandoneon", 
 52 |         "bugle", 
 53 |         "celesta", 
 54 |         "clavichord", 
 55 |         "concertina", 
 56 |         "glass armonica", 
 57 |         "guiro", 
 58 |         "harmonica", 
 59 |         "harpsichord", 
 60 |         "jew's-harp", 
 61 |         "kalimba", 
 62 |         "mbira", 
 63 |         "mellophone", 
 64 |         "melodica", 
 65 |         "organ", 
 66 |         "piano", 
 67 |         "sarrusophone", 
 68 |         "saxophone", 
 69 |         "singing bowl", 
 70 |         "sousaphone", 
 71 |         "trombone", 
 72 |         "trumpet"
 73 |     ], 
 74 |     "popular": [
 75 |         "acoustic guitar", 
 76 |         "banjo", 
 77 |         "bass", 
 78 |         "bongo", 
 79 |         "cello", 
 80 |         "clarinet", 
 81 |         "conga", 
 82 |         "djembe", 
 83 |         "drums", 
 84 |         "electric guitar", 
 85 |         "flute", 
 86 |         "harmonica", 
 87 |         "keyboard", 
 88 |         "piano", 
 89 |         "saxophone", 
 90 |         "triangle", 
 91 |         "trumpet", 
 92 |         "ukulele", 
 93 |         "violin", 
 94 |         "xylophone"
 95 |     ], 
 96 |     "electronic": [
 97 |         "computer", 
 98 |         "cvp-509", 
 99 |         "drum machine", 
100 |         "electronic organ", 
101 |         "ewi", 
102 |         "hammond", 
103 |         "kaosspad", 
104 |         "keyboard", 
105 |         "sampler", 
106 |         "synthesizer"
107 |     ], 
108 |     "wind": [
109 |         "alphorn", 
110 |         "bassoon", 
111 |         "bombarde", 
112 |         "clarinet", 
113 |         "didgeridoo", 
114 |         "flugelhorn", 
115 |         "flute", 
116 |         "hautbois", 
117 |         "horn", 
118 |         "kazoo", 
119 |         "ney", 
120 |         "oboe", 
121 |         "ocarina", 
122 |         "pan flute", 
123 |         "piccolo", 
124 |         "pipe organ", 
125 |         "tin whistle", 
126 |         "tuba"
127 |     ], 
128 |     "string": [
129 |         "acoustic bass guitar", 
130 |         "acoustic guitar", 
131 |         "balalaika", 
132 |         "banjo", 
133 |         "berimbau", 
134 |         "cello", 
135 |         "charango", 
136 |         "cimbalom", 
137 |         "double bass", 
138 |         "erhu", 
139 |         "fiddle", 
140 |         "gimbri", 
141 |         "harp", 
142 |         "kanun", 
143 |         "koto", 
144 |         "lap steel guitar", 
145 |         "lute", 
146 |         "mandola", 
147 |         "mandolin", 
148 |         "oud", 
149 |         "santur", 
150 |         "shamisen", 
151 |         "sitar", 
152 |         "tambura", 
153 |         "ukulele", 
154 |         "viola", 
155 |         "violin"
156 |     ]
157 | }
158 | 


--------------------------------------------------------------------------------
/data/jamendo/instruments_taxonomy_per_instrument.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "cajon": [
  3 |         "percussion"
  4 |     ], 
  5 |     "mellotron": [
  6 |         "electric"
  7 |     ], 
  8 |     "tambura": [
  9 |         "string"
 10 |     ], 
 11 |     "flugelhorn": [
 12 |         "wind"
 13 |     ], 
 14 |     "electric guitar": [
 15 |         "electric", 
 16 |         "popular"
 17 |     ], 
 18 |     "bongo": [
 19 |         "percussion", 
 20 |         "popular"
 21 |     ], 
 22 |     "keyboard": [
 23 |         "popular", 
 24 |         "electronic"
 25 |     ], 
 26 |     "clarinet": [
 27 |         "popular", 
 28 |         "wind"
 29 |     ], 
 30 |     "ocarina": [
 31 |         "wind"
 32 |     ], 
 33 |     "glass armonica": [
 34 |         "others"
 35 |     ], 
 36 |     "accordion": [
 37 |         "others"
 38 |     ], 
 39 |     "pandeiro": [
 40 |         "percussion"
 41 |     ], 
 42 |     "castanets": [
 43 |         "percussion"
 44 |     ], 
 45 |     "sampler": [
 46 |         "electronic"
 47 |     ], 
 48 |     "gobletdrum": [
 49 |         "percussion"
 50 |     ], 
 51 |     "piano": [
 52 |         "others", 
 53 |         "popular"
 54 |     ], 
 55 |     "drum machine": [
 56 |         "electronic"
 57 |     ], 
 58 |     "triangle": [
 59 |         "percussion", 
 60 |         "popular"
 61 |     ], 
 62 |     "pipe organ": [
 63 |         "wind"
 64 |     ], 
 65 |     "marimba": [
 66 |         "percussion"
 67 |     ], 
 68 |     "erhu": [
 69 |         "string"
 70 |     ], 
 71 |     "slide guitar": [
 72 |         "electric"
 73 |     ], 
 74 |     "gimbri": [
 75 |         "string"
 76 |     ], 
 77 |     "santur": [
 78 |         "string"
 79 |     ], 
 80 |     "bodhran": [
 81 |         "percussion"
 82 |     ], 
 83 |     "acoustic guitar": [
 84 |         "popular", 
 85 |         "string"
 86 |     ], 
 87 |     "organ": [
 88 |         "others"
 89 |     ], 
 90 |     "singing bowl": [
 91 |         "others"
 92 |     ], 
 93 |     "vibraphone": [
 94 |         "percussion"
 95 |     ], 
 96 |     "saxophone": [
 97 |         "others", 
 98 |         "popular"
 99 |     ], 
100 |     "lap steel guitar": [
101 |         "string"
102 |     ], 
103 |     "concertina": [
104 |         "others"
105 |     ], 
106 |     "electric piano": [
107 |         "electric"
108 |     ], 
109 |     "tubular bell": [
110 |         "percussion"
111 |     ], 
112 |     "horn": [
113 |         "wind"
114 |     ], 
115 |     "kalimba": [
116 |         "others"
117 |     ], 
118 |     "computer": [
119 |         "electronic"
120 |     ], 
121 |     "mandola": [
122 |         "string"
123 |     ], 
124 |     "trombone": [
125 |         "others"
126 |     ], 
127 |     "hautbois": [
128 |         "wind"
129 |     ], 
130 |     "pan flute": [
131 |         "wind"
132 |     ], 
133 |     "didgeridoo": [
134 |         "wind"
135 |     ], 
136 |     "tuba": [
137 |         "wind"
138 |     ], 
139 |     "conga": [
140 |         "percussion", 
141 |         "popular"
142 |     ], 
143 |     "jew's-harp": [
144 |         "others"
145 |     ], 
146 |     "ney": [
147 |         "wind"
148 |     ], 
149 |     "taiko": [
150 |         "percussion"
151 |     ], 
152 |     "sousaphone": [
153 |         "others"
154 |     ], 
155 |     "cabasa": [
156 |         "percussion"
157 |     ], 
158 |     "flute": [
159 |         "popular", 
160 |         "wind"
161 |     ], 
162 |     "mbira": [
163 |         "others"
164 |     ], 
165 |     "bass": [
166 |         "electric", 
167 |         "popular"
168 |     ], 
169 |     "tamtam": [
170 |         "percussion"
171 |     ], 
172 |     "mellophone": [
173 |         "others"
174 |     ], 
175 |     "sarrusophone": [
176 |         "others"
177 |     ], 
178 |     "cowbell": [
179 |         "percussion"
180 |     ], 
181 |     "drums": [
182 |         "popular"
183 |     ], 
184 |     "shamisen": [
185 |         "string"
186 |     ], 
187 |     "drum": [
188 |         "percussion"
189 |     ], 
190 |     "acoustic bass guitar": [
191 |         "string"
192 |     ], 
193 |     "rhodes": [
194 |         "electric"
195 |     ], 
196 |     "harmonica": [
197 |         "others", 
198 |         "popular"
199 |     ], 
200 |     "berimbau": [
201 |         "string"
202 |     ], 
203 |     "mandolin": [
204 |         "string"
205 |     ], 
206 |     "double bass": [
207 |         "string"
208 |     ], 
209 |     "bugle": [
210 |         "others"
211 |     ], 
212 |     "timpani": [
213 |         "percussion"
214 |     ], 
215 |     "bell": [
216 |         "percussion"
217 |     ], 
218 |     "kazoo": [
219 |         "wind"
220 |     ], 
221 |     "celesta": [
222 |         "others"
223 |     ], 
224 |     "steelpan": [
225 |         "percussion"
226 |     ], 
227 |     "tabla": [
228 |         "percussion"
229 |     ], 
230 |     "guiro": [
231 |         "others"
232 |     ], 
233 |     "synthesizer": [
234 |         "electronic"
235 |     ], 
236 |     "harpsichord": [
237 |         "others"
238 |     ], 
239 |     "harp": [
240 |         "string"
241 |     ], 
242 |     "charango": [
243 |         "string"
244 |     ], 
245 |     "udu": [
246 |         "percussion"
247 |     ], 
248 |     "xylophone": [
249 |         "percussion", 
250 |         "popular"
251 |     ], 
252 |     "koto": [
253 |         "string"
254 |     ], 
255 |     "oud": [
256 |         "string"
257 |     ], 
258 |     "glockenspiel": [
259 |         "percussion"
260 |     ], 
261 |     "shekere": [
262 |         "percussion"
263 |     ], 
264 |     "dunun": [
265 |         "percussion"
266 |     ], 
267 |     "bombarde": [
268 |         "wind"
269 |     ], 
270 |     "kaosspad": [
271 |         "electronic"
272 |     ], 
273 |     "cimbalom": [
274 |         "string"
275 |     ], 
276 |     "clavichord": [
277 |         "others"
278 |     ], 
279 |     "fiddle": [
280 |         "string"
281 |     ], 
282 |     "cello": [
283 |         "popular", 
284 |         "string"
285 |     ], 
286 |     "balalaika": [
287 |         "string"
288 |     ], 
289 |     "piccolo": [
290 |         "wind"
291 |     ], 
292 |     "djembe": [
293 |         "percussion", 
294 |         "popular"
295 |     ], 
296 |     "sitar": [
297 |         "string"
298 |     ], 
299 |     "carillon": [
300 |         "percussion"
301 |     ], 
302 |     "metallophone": [
303 |         "percussion"
304 |     ], 
305 |     "violin": [
306 |         "popular", 
307 |         "string"
308 |     ], 
309 |     "handbell": [
310 |         "percussion"
311 |     ], 
312 |     "harmonium": [
313 |         "electric"
314 |     ], 
315 |     "electronic organ": [
316 |         "electronic"
317 |     ], 
318 |     "ewi": [
319 |         "electronic"
320 |     ], 
321 |     "ukulele": [
322 |         "popular", 
323 |         "string"
324 |     ], 
325 |     "bassoon": [
326 |         "wind"
327 |     ], 
328 |     "trumpet": [
329 |         "others", 
330 |         "popular"
331 |     ], 
332 |     "oboe": [
333 |         "wind"
334 |     ], 
335 |     "theremin": [
336 |         "electric"
337 |     ], 
338 |     "viola": [
339 |         "string"
340 |     ], 
341 |     "tambourine": [
342 |         "percussion"
343 |     ], 
344 |     "banjo": [
345 |         "popular", 
346 |         "string"
347 |     ], 
348 |     "melodica": [
349 |         "others"
350 |     ], 
351 |     "hang drum": [
352 |         "percussion"
353 |     ], 
354 |     "hammond": [
355 |         "electric", 
356 |         "electronic"
357 |     ], 
358 |     "cvp-509": [
359 |         "electronic"
360 |     ], 
361 |     "cymbal": [
362 |         "percussion"
363 |     ], 
364 |     "bandoneon": [
365 |         "others"
366 |     ], 
367 |     "lute": [
368 |         "string"
369 |     ], 
370 |     "tin whistle": [
371 |         "wind"
372 |     ], 
373 |     "alphorn": [
374 |         "wind"
375 |     ], 
376 |     "bagpipes": [
377 |         "others"
378 |     ], 
379 |     "kanun": [
380 |         "string"
381 |     ], 
382 |     "balafon": [
383 |         "percussion"
384 |     ]
385 | }


--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
1 | /_site
2 | 


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | name: COSMIR
2 | description: Community for Open and Sustainable Music Information Research
3 | baseurl: /open-mic


--------------------------------------------------------------------------------
/docs/_layouts/page.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
 8 |     <link rel="stylesheet" href="/assets/bootstrap/css/bootstrap.min.css">
 9 |     <link rel="stylesheet" href="/assets/css/style.css">
10 |     <script src="/assets/bootstrap/js/bootstrap.min.js"></script>
11 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css">
12 |     <script type="text/x-mathjax-config">
13 |       MathJax.Hub.Config({
14 |         tex2jax: {inlineMath: [['$','$']]}
15 |       });
16 |     </script>
17 |     <script type="text/javascript" async src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_CHTML"></script>
18 | 
19 |     <title>{{ page.title }}</title>
20 |   </head>
21 |   <body>
22 | 
23 |     <nav class="navbar navbar-inverse">
24 |       <div class="container">
25 |         <div class="navbar-header">
26 |           <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
27 |             <span class="sr-only">Toggle navigation</span>
28 |             <span class="icon-bar"></span>
29 |             <span class="icon-bar"></span>
30 |             <span class="icon-bar"></span>
31 |           </button>
32 |           <a class="navbar-brand" href="/">COSMIR</a>
33 |         </div>
34 |         <div id="navbar" class="navbar-collapse collapse">
35 |           <ul class="nav navbar-nav">
36 |             <li><a href="/">Home</a></li>
37 |             <li class="active"><a href="/{{ site.github.project_title }}/">OpenMIC Challenge</a></li><!-- always active because we're under a challenge's site -->
38 |           </ul>
39 |           <ul class="nav navbar-nav navbar-right">
40 |             <li><a href="/about.html">About</a></li>
41 |           </ul>
42 |         </div><!--/.nav-collapse -->
43 |       </div>
44 |     </nav>
45 | 
46 |     <div class="container" role="main">
47 |       <ul class="nav nav-tabs nav-tabs-left">
48 |         <li role="presentation" {% if page.url == "/" %}class="active"{% endif %}><a href="/{{ site.github.project_title }}/">OpenMIC</a></li>
49 |         <li role="presentation" {% if page.url == "/task1.html" %}class="active"{% endif %}><a href="/{{ site.github.project_title }}/task1.html">Task 1</a></li>
50 |         <li role="presentation" {% if page.url == "/task2.html" %}class="active"{% endif %}><a href="/{{ site.github.project_title }}/task2.html">Task 2</a></li>
51 |         <li role="presentation" {% if page.url == "/contribute.html" %}class="active"{% endif %}><a href="/{{ site.github.project_title }}/contribute.html">Contribute</a></li>
52 |         <li role="presentation" {% if page.url == "/downloads.html" %}class="active"{% endif %}><a href="#">Downloads</a></li>
53 |       </ul>
54 |       <ul class="nav nav-tabs nav-tabs-right">
55 |         <li role="presentation" {% if page.url == "/submit.html" %}class="active"{% endif %}><a href="#">Submit</a></li>
56 |       </ul>
57 |       <div class="tab-content">
58 |         <div class="tab-pane active" id="1">
59 |           {{ content }}
60 |         </div>
61 |       </div>
62 |     </div>
63 | 
64 |     <div class="container" style="margin-top:40px">
65 |       <div class="alert alert-info text-center" role="alert">This website is still under development!</div>
66 |     </div>
67 | 
68 |     <footer class="bs-footer small">
69 |       <div class="container">
70 |         <div class="pull-left">&copy; 2016 COSMIR</div>
71 |         <div class="pull-right">
72 |           <ul>
73 |             <li><a href="/code-of-conduct.html">Code of Conduct</a></li>
74 |             <li><a href="/contact.html">Contact</a></li>
75 |           </ul>
76 |         </div>
77 |       </div>
78 |     </footer>
79 | 
80 |   </body>
81 | </html>
82 | 


--------------------------------------------------------------------------------
/docs/annotator.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |     <title>Open-MIC Challenge</title>
 5 | 
 6 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
 7 |     <link rel="stylesheet" href="../audio-annotator/static/css/materialize.min.css">
 8 |     <link rel="stylesheet" type="text/css" href="../audio-annotator/static/css/urban-ears.css">
 9 | 
10 |     <script type="text/javascript" src="../audio-annotator/static/js/lib/jquery-2.2.3.min.js"></script>
11 |     <script type="text/javascript" src="../audio-annotator/static/js/lib/materialize.min.js"></script>
12 |     <script type="text/javascript" src="../audio-annotator/static/js/lib/wavesurfer.min.js"></script>
13 |     <script type="text/javascript" src="../audio-annotator/static/js/lib/wavesurfer.spectrogram.min.js"></script>
14 |     <script type="text/javascript" src="../audio-annotator/static/js/colormap/colormap.min.js"></script>
15 | 
16 |     <script type="text/javascript" src="../audio-annotator/static/js/src/message.js"></script>
17 |     <script type="text/javascript" src="../audio-annotator/static/js/src/wavesurfer.regions.js"></script>
18 |     <script type="text/javascript" src="../audio-annotator/static/js/src/wavesurfer.drawer.extended.js"></script>
19 |     <script type="text/javascript" src="../audio-annotator/static/js/src/wavesurfer.labels.js"></script>
20 |     <script type="text/javascript" src="../audio-annotator/static/js/src/hidden_image.js"></script>
21 |     <script type="text/javascript" src="../audio-annotator/static/js/src/components.js"></script>
22 |     <script type="text/javascript" src="../audio-annotator/static/js/src/annotation_stages.js"></script>
23 |     <script type="text/javascript" src="../audio-annotator/static/js/src/main.js" defer></script>
24 | </head>
25 | <body>
26 |     <div class="row header">
27 |         <div class="col s12">
28 |             <div class="divider"></div>
29 |         </div>
30 |         <div class="col s6">
31 |             <div class="left">
32 |                 <h5>Recording <span id="recording-index"></span> of 9</h5>
33 |                 <h6 class="left">approx. <span id="time-remaining"></span> minutes remaining</h6>
34 |             </div>
35 |         </div>
36 |         <div class="col s6 ">
37 |             <div class="right">
38 |                 <h5>Open-MIC Challenge</h5>
39 |                 <a class="waves-effect waves-light modal-trigger right" href="#modal1">Tutorial Video</a>
40 |             </div>
41 |         </div>
42 |         <div class="col s12">
43 |             <div class="divider bottom"></div>
44 |         </div>
45 |     </div>
46 |     <!-- Modal Structure -->
47 |         <div id="modal1" class="modal">
48 |             <div class="modal-content">
49 |                 <h4>Tutorial Video</h4>
50 |                 <div class="videowrapper">
51 |                     <iframe id="tutorial-video" width="100%" height="100%" frameborder="0" allowfullscreen></iframe>
52 |                 </div>
53 |             </div>
54 |             <div class="modal-footer">
55 |                 <a href="#!" class=" modal-action modal-close waves-effect waves-red btn-flat">Close</a>
56 |             </div>
57 |         </div>
58 |     <div class="row prompt">
59 |         <h4 class="center">Highlight &amp; Tag Each Sound</h4>
60 |         <h6 class="center">Click and drag to create a new annotation. Listen for sound events and tag them from the list under the audio recording.</h6>
61 |     </div>
62 |     <div class="annotation">
63 |         <div class="labels"></div>
64 |         <div class="audio_visual"></div>
65 |         <div class="play_bar"></div>
66 |         <div class="hidden_img"></div>
67 |         <div class="creation_stage_container"></div>
68 |         <div class="submit_container"></div>
69 |     </div>
70 |     <script>
71 |         // Change me! Is there an easy way to config this?
72 |         var netloc = 'http://localhost:8080'
73 |         var dataUrl = netloc + '/api/v0.1/task';
74 |         var postUrl = netloc + '/api/v0.1/annotation/submit';
75 | 
76 |         $(document).ready(function(){
77 |             $('.modal-trigger').leanModal();
78 |         });
79 |     </script>
80 | </body>
81 | </html>


--------------------------------------------------------------------------------
/docs/contribute.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: page
 3 | title: OpenMIC - Contrinute
 4 | ---
 5 | 
 6 | # How to Contribute to OpenMIC
 7 | 
 8 | OpenMIC is a collaborative effort led by a [community of researchers](https://github.com/cosmir/open-mic/watchers) interested in Open Science. We are therefore happy to receive as much help as you can give us!.
 9 | 
10 | There are different ways to contribute to OpenMIC. Most of the discussion and development is concentrated in a [<i class="fa fa-github"></i> GitHub repository](https://github.com/cosmir/open-mic). You can take a look at the current [list of issues](https://github.com/cosmir/open-mic/issues) and give feedback or propose new ideas. In particular, we have issues related to [<span class="label label-primary">research</span>](https://github.com/cosmir/open-mic/labels/research) questions and issues related to the [<span class="label label-warning">software</span>](https://github.com/cosmir/open-mic/labels/software) aspects of the challenge. Of course, you are welcome to contribute with code as well!
11 | 
12 | There is also a [<i class="fa fa-google-plus-square"></i> Google Group](https://groups.google.com/forum/#!forum/open-mic-users) set up to receive more high-level notifications about OpenMIC.
13 | 
14 | You are also welcome to contribute in other ways, such as with data. If you want to help us with the annotations, that will still take some time to set up, but please drop us an email or subscribe to the [Google Group](https://groups.google.com/forum/#!forum/open-mic-users) to stay up to date.
15 | 
16 | However you want to contribute, please take a look first at the [code of conduct](/code-of-conduct.html).


--------------------------------------------------------------------------------
/docs/downloads.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: OpenMIC - Contrinute
4 | ---
5 | 
6 | openmic website under construction
7 | 


--------------------------------------------------------------------------------
/docs/img/annotation_state_diagram.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/docs/img/annotation_state_diagram.png


--------------------------------------------------------------------------------
/docs/img/cas_architecture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/docs/img/cas_architecture.png


--------------------------------------------------------------------------------
/docs/img/data-collection.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/docs/img/data-collection.png


--------------------------------------------------------------------------------
/docs/img/roadmap.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/docs/img/roadmap.png


--------------------------------------------------------------------------------
/docs/img/system_architecture.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cosmir/openmic-annotator/ebb4612ff5a6c6f7b6fbc908d837857f8377d95a/docs/img/system_architecture.png


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: page
 3 | title: OpenMIC
 4 | ---
 5 | 
 6 | # Open Music Instrument Classification challenge (OpenMIC)
 7 | 
 8 | OpenMIC will evaluate systems for the detection of the musical instruments played in music audio files. For this first edition, we will contemplate two uses cases, which lead to two different tasks for participation:
 9 | 
10 | - **Task 1 (classification):** systems receive a music audio file and they have to identify the instruments that are played anywhere in that file. See [details](task1.html).
11 | - **Task 2 (retrieval):** systems receive an instrument and a corpus of audio files, and they have to return a list of files where the instrument is played. See [details](task2.html).
12 | 
13 | Tasks are independent of each other, even if systems for task 2 can benefit from systems for task 1. Submissions for one task are independent of submissions for the other task, so you can participate in just one or the two of them.
14 | 
15 | [TBD] Systems will produce their output based solely on the contents of the audio files. That is, systems are not allowed to use metadata or any other type of data.
16 | 


--------------------------------------------------------------------------------
/docs/task1.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: page
 3 | title: Task 1
 4 | ---
 5 | 
 6 | # Task 1: Classification
 7 | 
 8 | ## Description
 9 | 
10 | The input to the system is a music audio file. The output is the set of instruments that are played anywhere in the input file. Such systems can be used to create instrument-related tags, which can serve as features for high level systems such as recommenders. 
11 | 
12 | ## Format
13 | 
14 | [TBD]
15 | 
16 | ## Evaluation
17 | 
18 | [TBD]
19 | 
20 | In the following, let $X=\\{x_1,\dots,x_n\\}$ be the set of instruments annotated for the input audio file, and let $Y=\\{y_1,\dots,y_m\\}$ be the set of instruments predicted by the system for that same audio file. In addition, let $1[e]$ be an indicator function that evaluates to $1$ if $e$ is true and $0$ otherwise.
21 | 
22 | ### Hierarchy-unaware Measures
23 | 
24 | The following measures are defined ignoring the hierarchy of classes:
25 | 
26 | - **Precision** evaluates the ability of the system to identify instruments without making mistakes (avoid false positives). It computes the fraction of predictions that are correct:
27 | 
28 | $$P=\frac{1}{m}\sum_{y\in Y}{1[y\in X]}$$
29 | 
30 | - **Recall** evaluates the ability of the system to identify all instruments present in the input file (avoid false negatives). It computes the fraction of annotations correctly predicted:
31 | 
32 | $$R=\frac{1}{n}\sum_{x\in X}{1[x\in Y]}$$
33 | 
34 | - **F-measure** integrates both Precision and Recall in a single score:
35 | 
36 | $$F=2\frac{P\cdot R}{P+R}$$
37 | 
38 | ### Hierarchy-aware Measures
39 | 
40 | We will use the hierarchical counterparts of $P$, $R$ and $F$ defined by Kiritchenko et al. Let $anc(x)$ be a function that returns the set of ancestors of class $x$, excluding the root of the hierarchy. The extended set of reference annotations is thus $X^\*=\cup_{x\in X}{anc(x)}$, while the extended set of predictions is similarly $Y^\*=\cup_{y\in Y}{anc(y)}$. The above measures can now be reformulated as follows to account for the hierarchy:
41 | 
42 | - **hPrecision:**
43 | 
44 | $$hP=\frac{1}{|Y^*|}\sum_{y^*\in Y^*}{1[y^*\in X^*]}$$
45 | 
46 | - **hRecall:**
47 | 
48 | $$hR=\frac{1}{|X^*|}\sum_{x^*\in X^*}{1[x^*\in Y^*]}$$
49 | 
50 | - **hF-measure:**
51 | 
52 | $$hF=2\frac{hP\cdot hR}{hP+hR}$$
53 | 


--------------------------------------------------------------------------------
/docs/task2.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | layout: page
 3 | title: Task 2
 4 | ---
 5 | 
 6 | # Task 2: Retrieval
 7 | 
 8 | The input is a query instrument and a corpus of audio music files. The output is a list of at most 100 files from the corpus where the query instrument is played. Such systems can be used for instance by amateur players who want to practice some particular instrument.
 9 | 
10 | ## Format
11 | 
12 | [TBD]
13 | 
14 | ## Evaluation
15 | 
16 | [TBD]
17 | 
18 | In the following, let $q$ be the query instrument, let $X=\\{x_1,\dots,x_n\\}$ be the set of excerpts annotated as containing the query instrument, and let $Y=\langle y_1,\dots,y_m \rangle$ be the list of excerpts retrieved by the system.
19 | 
20 | ### Hierarchy-unaware Measures
21 | 
22 | - **Reciprocal Rank** evaluates the (inverse of the) effort required from the user to find the first relevant excerpt retrieved:
23 | 
24 | $$RR=\frac{1}{\min_{i}{\{i : y_i\in X\}}}$$
25 | 
26 | - **Precision at k** evaluates the ability of the system to retrieve relevant excerpts among the top $k$ retrieved:
27 | 
28 | $$P@k=\frac{1}{k}\sum_{i=1}^k{1[y_i\in X]}$$
29 | 
30 | We will evaluate with cutoffs k=5,10,15,20,50,100.
31 | 
32 | - **Average Precision** evaluates the ability of the system to retrieve all relevant excerpts and at the top of the results list:
33 | 
34 | $$AP=\frac{1}{|X|}\sum_{i=1}^m{1[y_i\in X]\cdot P@i}$$
35 | 
36 | ### Hierarchy-aware Measures
37 | 
38 | ERR, EP@k and GAP
39 | 


--------------------------------------------------------------------------------
/scripts/audio_uploader.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """Upload a number of audio files and metadata to the backend CMS.
  3 | 
  4 | Example
  5 | -------
  6 | $ ./scripts/audio_uploader.py \
  7 |     data/audio/filelist.json \
  8 |     http://localhost:8080/api/v0.1/audio \
  9 |     --verbose 50 \
 10 |     --n_jobs -1
 11 | 
 12 | Note
 13 | ----
 14 | The JSON object input to this script should be an array of objects, containing
 15 | values for `filename` and `metadata`:
 16 | 
 17 | ```
 18 |   [
 19 |     {
 20 |       "filename": "foo.ogg",
 21 |       "metadata": {"source": "internet", "genre": "noise"}
 22 |     },
 23 |     ...
 24 |   ]
 25 | ```
 26 | 
 27 | See `data/audio/filelist.json` for a more complete example.
 28 | """
 29 | from __future__ import print_function
 30 | 
 31 | import argparse
 32 | import datetime
 33 | import joblib
 34 | import json
 35 | import logging
 36 | from requests.packages.urllib3.util.retry import Retry
 37 | from requests.adapters import HTTPAdapter
 38 | import requests
 39 | from six.moves.urllib.parse import urlparse
 40 | 
 41 | LOG = logging.getLogger('audio_uploader')
 42 | 
 43 | 
 44 | def upload(filename, metadata, url):
 45 |     """Upload an audio file and corresponding metadata to the CMS.
 46 | 
 47 |     Parameters
 48 |     ----------
 49 |     filename : str
 50 |         Path to an audio file on disk.
 51 | 
 52 |     metadata : dict
 53 |         Object containing arbitrary metadata matching this audio file.
 54 | 
 55 |     url : str
 56 |         Destination for uploading data.
 57 | 
 58 |     Returns
 59 |     -------
 60 |     response : obj
 61 |         Dictionary containing data about the upload event, including the URI of
 62 |         the newly minted object.
 63 |     """
 64 |     start = datetime.datetime.now()
 65 |     session = requests.Session()
 66 |     adapter = HTTPAdapter(max_retries=Retry(total=8, backoff_factor=0.02))
 67 |     session.mount('{}://'.format(urlparse(url).scheme), adapter)
 68 | 
 69 |     response = session.post(
 70 |         url,
 71 |         data=metadata,
 72 |         files=dict(audio=open(filename, 'rb'))
 73 |     )
 74 |     end = datetime.datetime.now()
 75 |     elapsed = end - start
 76 |     result = dict(status=response.status_code, time_elapsed=str(elapsed),
 77 |                   start_time=str(start), filename=filename, **response.json())
 78 |     LOG.info(json.dumps(result))
 79 | 
 80 | 
 81 | def init_logger(log_file, level=logging.INFO):
 82 |     logging.basicConfig(level=level)
 83 |     handler = logging.FileHandler(log_file)
 84 |     handler.setLevel(logging.INFO)
 85 | 
 86 |     # create a logging format
 87 |     formatter = logging.Formatter('%(message)s')
 88 |     handler.setFormatter(formatter)
 89 | 
 90 |     # add the handlers to the logger
 91 |     LOG.addHandler(handler)
 92 | 
 93 | 
 94 | if __name__ == '__main__':
 95 |     parser = argparse.ArgumentParser(description=__doc__)
 96 |     parser.add_argument(
 97 |         "audio_files", type=str,
 98 |         help="Collection of filenames and corresponding metadata.")
 99 |     parser.add_argument(
100 |         "upload_url", type=str,
101 |         help="URL endpoint for uploading audio.")
102 |     now = datetime.datetime.now()
103 |     parser.add_argument(
104 |         "--log_file", type=str,
105 |         default='upload_results-{}.log'.format(now.strftime("%Y%m%d-%H%M%S")),
106 |         help="Filepath for writing response data as JSON.")
107 |     parser.add_argument(
108 |         "--verbose", type=int, default=0,
109 |         help="Verbosity level for the uploader.")
110 |     parser.add_argument(
111 |         "--n_jobs", type=int, default=-2,
112 |         help="Number of parallel jobs to run; -1 for all, -2 for all but one.")
113 | 
114 |     args = parser.parse_args()
115 |     audio_files = json.load(open(args.audio_files))
116 |     init_logger(args.log_file)
117 |     joblib.Parallel(n_jobs=args.n_jobs, verbose=args.verbose)(
118 |         joblib.delayed(upload)(url=args.upload_url, **record)
119 |         for record in audio_files)
120 | 


--------------------------------------------------------------------------------
/scripts/cli_login_demo.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | """Demonstrate the OAuth login process for commandline tools.
 3 | 
 4 | Example
 5 | -------
 6 | $ ./scripts/cli_login_demo.py http://localhost:8080
 7 | 
 8 | """
 9 | from __future__ import print_function
10 | 
11 | import argparse
12 | from builtins import input
13 | import os
14 | import requests
15 | from requests.packages.urllib3.util.retry import Retry
16 | from requests.adapters import HTTPAdapter
17 | from six.moves.urllib.parse import urlparse
18 | import webbrowser
19 | 
20 | 
21 | def demo(base_url):
22 |     """Login through a third-party OAuth handler and print some stats.
23 | 
24 |     Parameters
25 |     ----------
26 |     base_url : str
27 |         Base URL of the CMS server.
28 |     """
29 |     session = requests.Session()
30 |     adapter = HTTPAdapter(max_retries=Retry(total=3, backoff_factor=0.02))
31 |     session.mount('{}://'.format(urlparse(base_url).scheme), adapter)
32 | 
33 |     wb = webbrowser.get()
34 |     login_url = os.path.join(base_url, "login?complete=no")
35 |     session.get(login_url)
36 |     wb.open(login_url)
37 | 
38 |     auth_url = input("Enter the URL returned after authentication:")
39 |     response = session.get(auth_url.replace("complete=no", 'complete=yes'))
40 |     assert response.status_code == 200
41 | 
42 |     print(session.get(os.path.join(base_url, 'me')).content)
43 | 
44 | 
45 | if __name__ == '__main__':
46 |     parser = argparse.ArgumentParser(description=__doc__)
47 |     parser.add_argument(
48 |         "base_url", type=str,
49 |         help="Base URL of the server.")
50 | 
51 |     args = parser.parse_args()
52 |     demo(args.base_url)
53 | 


--------------------------------------------------------------------------------
/scripts/demo.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | """Run a local demo of the server-annotator system.
  3 | 
  4 | Performs the following:
  5 | - Starts the CMS server
  6 | - Uploads some audio content
  7 | - Restarts the CMS server
  8 | - Holds until the user shuts down the demo.
  9 | 
 10 | Note: It is advisable to use a private / incognito browser session to avoid
 11 | caching behavior, which can cause the web app to use stale source files.
 12 | """
 13 | from __future__ import print_function
 14 | 
 15 | import argparse
 16 | import atexit
 17 | from builtins import input
 18 | import logging
 19 | import os
 20 | import requests
 21 | from requests.packages.urllib3.util.retry import Retry
 22 | from requests.adapters import HTTPAdapter
 23 | import signal
 24 | import subprocess
 25 | 
 26 | SERVER_PORT = 8080
 27 | PROCESSES = []
 28 | 
 29 | 
 30 | def kill(*proccesses):
 31 |     """Kills a list of processes.
 32 | 
 33 |     Parameters
 34 |     ----------
 35 |     processes: list
 36 |         List of process ids to be killed.
 37 |     """
 38 |     for proc in proccesses:
 39 |         os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
 40 | 
 41 | 
 42 | @atexit.register
 43 | def kill_all():
 44 |     kill(*PROCESSES)
 45 | 
 46 | 
 47 | def launch_cms(port, noauth=False, max_retries=8):
 48 |     """Thin wrapper around kick-starting the CMS server.
 49 | 
 50 |     Parameters
 51 |     ----------
 52 |     port : int
 53 |         Port for running the server locally.
 54 | 
 55 |     noauth : bool, default=False
 56 |         If True, do not use authentication.
 57 | 
 58 |     Returns
 59 |     -------
 60 |     pid : int
 61 |         Process ID of the server.
 62 |     """
 63 |     flags = ['--debug']
 64 |     if noauth:
 65 |         flags += ['--noauth']
 66 | 
 67 |     cmd = "python {} --port {} --config {} {}".format(
 68 |         os.path.join('backend_server', 'main.py'), port,
 69 |         os.path.join('backend_server', '.config-local.yaml'), " ".join(flags))
 70 |     logging.info("server: {}".format(cmd))
 71 |     server = subprocess.Popen(cmd.split(" "), stdout=subprocess.PIPE,
 72 |                               preexec_fn=os.setsid)
 73 | 
 74 |     # Test that the server is on; will raise an exception after enough attempts
 75 |     session = requests.Session()
 76 |     adapter = HTTPAdapter(max_retries=Retry(total=max_retries,
 77 |                                             backoff_factor=0.1))
 78 |     session.mount('http://', adapter)
 79 |     try:
 80 |         session.get('http://localhost:{}'.format(port))
 81 |     except requests.exceptions.ConnectionError:
 82 |         kill(server)
 83 |         raise EnvironmentError(
 84 |             "Unable to confirm that the server started successfully.")
 85 |     return server
 86 | 
 87 | 
 88 | def run(port):
 89 |     """Main process to run the demo.
 90 | 
 91 |     Parameters
 92 |     ----------
 93 |     port: int
 94 |         Server port number.
 95 |     """
 96 |     # Some sanity checks
 97 |     if not os.path.isdir("backend_server"):
 98 |         raise EnvironmentError(
 99 |             "This script must be launched from OpenMic's root directory.")
100 |     if not os.path.isdir("audio-annotator"):
101 |         raise EnvironmentError("Audio Annotator not found: please run:\n\t"
102 |                                "git submodule update --init")
103 | 
104 |     # Run the server
105 |     server = launch_cms(port, noauth=True)
106 | 
107 |     # Upload audio to the server
108 |     fnames = ["267508__mickleness__3nf.ogg",
109 |               "345515__furbyguy__strings-piano.ogg"]
110 |     for fn in fnames:
111 |         fpath = os.path.abspath(os.path.join('data', 'audio', fn))
112 |         requests.post('http://localhost:{}/api/v0.1/audio'.format(port),
113 |                       files=dict(audio=open(fpath, 'rb')))
114 |     kill(server)
115 | 
116 |     # Run the two servers
117 |     PROCESSES.append(launch_cms(port, noauth=False))
118 |     logging.info("Now serving at: http://localhost:{}".format(port))
119 |     try:
120 |         input("Press return to exit.\n")
121 |     except KeyboardInterrupt:
122 |         # Capturing Ctrl-C, to make sure we always shutdown the server
123 |         pass
124 |     logging.info("Shutting down server")
125 | 
126 | 
127 | if __name__ == '__main__':
128 |     parser = argparse.ArgumentParser(
129 |         description="Run a local demo of the server-annotator system.",
130 |         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
131 |     parser.add_argument("-p",
132 |                         dest="port",
133 |                         default=SERVER_PORT,
134 |                         type=int,
135 |                         help="Server port number")
136 |     args = parser.parse_args()
137 | 
138 |     # Setup the logger
139 |     logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s',
140 |                         level=logging.INFO)
141 | 
142 |     # Call main process
143 |     run(args.port)
144 | 


--------------------------------------------------------------------------------
/scripts/filter_successful_uploads.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | """Filter the successfully uploaded files from a list of files.
 3 | 
 4 | Example
 5 | -------
 6 | $ ./scripts/filter_successful_uploads.py \
 7 |     data/audio/filelist.json \
 8 |     data/sample_upload_log.json \
 9 |     new_filelist.json
10 | 
11 | """
12 | from __future__ import print_function
13 | 
14 | import argparse
15 | import json
16 | 
17 | 
18 | def filter_successes(filelist, upload_results):
19 |     """Filter the records in `filelist` that uploaded successfully in
20 |     `upload_results`.
21 | 
22 |     Parameters
23 |     ----------
24 |     filelist : list
25 |         Collection of audio file data to filter.
26 | 
27 |     upload_results : list
28 |         Collection of audio uploader result objects.
29 | 
30 |     Returns
31 |     -------
32 |     remaining_files : list
33 |         Objects in filelist that were not uploaded successfully, according to
34 |         `upload_results`.
35 |     """
36 |     successful_files = set([res['filename'] for res in upload_results
37 |                             if res['status'] == 200])
38 |     remaining_files = [fdata for fdata in filelist
39 |                        if fdata['filename'] not in successful_files]
40 |     return remaining_files
41 | 
42 | 
43 | def parse_log(log_file):
44 |     """Parse a newline-separated logfile into result objects."""
45 |     with open(log_file, 'r') as fp:
46 |         results = [json.loads(line.strip()) for line in fp]
47 |     return results
48 | 
49 | 
50 | if __name__ == '__main__':
51 |     parser = argparse.ArgumentParser(description=__doc__)
52 |     parser.add_argument(
53 |         "audio_files", type=str,
54 |         help="Collection of filenames and corresponding metadata.")
55 |     parser.add_argument(
56 |         "log_file", type=str,
57 |         help="Filepath to the upload results of `audio_uploader`.")
58 |     parser.add_argument(
59 |         "remaining_files", type=str,
60 |         help="Filepath to the upload results of `audio_uploader`.")
61 | 
62 |     args = parser.parse_args()
63 |     audio_files = json.load(open(args.audio_files))
64 |     upload_results = parse_log(args.log_file)
65 |     remaining_files = filter_successes(audio_files, upload_results)
66 |     with open(args.remaining_files, 'w') as fp:
67 |         json.dump(remaining_files, fp, indent=2)
68 | 


--------------------------------------------------------------------------------