Dadabot_Autochiptune.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:459bc68da517eaff8fe1cfacc53d6a10da4d1486f86ea49f442f2c2377db0a9d"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 0
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#!/usr/bin/env python\n",
      "# -*- encoding: utf-8 -*-\n",
      "\n",
      "# ### Algorithm:\n",
      "# 1. HPSS => Harmonics, Percussives\n",
      "# 1. Percussives => peak pick => noise generator\n",
      "# 1. Harmonics => CQT\n",
      "# 1. CQT => Bass range => peak pick => triangle generator\n",
      "# 1. CQT => Treble range => peak pick => harmony => pulse generator\n",
      "\n",
      "import argparse\n",
      "import sys\n",
      "import os\n",
      "import time\n",
      "\n",
      "import librosa\n",
      "import numpy as np\n",
      "import scipy.signal\n",
      "import scipy.ndimage\n",
      "import functools\n",
      "\n",
      "import warnings\n",
      "warnings.filterwarnings(\"ignore\")\n",
      "\n",
      "# MAGIC NUMBERS\n",
      "sr = 22050\n",
      "MIDI_MIN = 18\n",
      "MIDI_MAX = 96\n",
      "fmin = librosa.midi_to_hz(MIDI_MIN)\n",
      "n_fft = 2048\n",
      "hop_length = 512\n",
      "\n",
      "TREBLE_MIN = 54 - MIDI_MIN\n",
      "TREBLE_MAX = MIDI_MAX - MIDI_MIN\n",
      "BASS_MIN = 24 - MIDI_MIN\n",
      "BASS_MAX = TREBLE_MIN + 24\n",
      "\n",
      "\n",
      "def triangle(*args, **kwargs):\n",
      "    '''Synthesize a triangle wave'''\n",
      "    v = scipy.signal.sawtooth(*args, **kwargs)\n",
      "\n",
      "    return 2 * np.abs(v) - 1.\n",
      "\n",
      "\n",
      "def nes_triangle(*args, **kwargs):\n",
      "    '''Synthesize a quantized NES triangle'''\n",
      "\n",
      "    # http://wiki.nesdev.com/w/index.php/APU_Triangle\n",
      "    # NES triangle is quantized to 16 values\n",
      "    w = triangle(*args, **kwargs)\n",
      "\n",
      "    qw = w - np.mod(w, 2./15)\n",
      "\n",
      "    return qw\n",
      "\n",
      "\n",
      "def noise(seq):\n",
      "    '''Synthesize binary noise'''\n",
      "    v = np.random.randint(0, 2, size=(len(seq),))\n",
      "\n",
      "    return 2 * v - 1.\n",
      "\n",
      "\n",
      "def quantize_values(X, v=15):\n",
      "    '''Quantize values to at most v discrete values'''\n",
      "\n",
      "    X = X - X.min()\n",
      "    X = X / X.max()\n",
      "    X = X - np.mod(X, 1./v)\n",
      "    return X\n",
      "\n",
      "\n",
      "def synthesize(beats, piano_roll, fmin=0, bins_per_octave=12,\n",
      "               tuning=0.0, wave=None, n=None):\n",
      "    '''Synthesize a weighted piano roll'''\n",
      "\n",
      "    # Quantize the piano roll\n",
      "    sr = 22050\n",
      "\n",
      "    piano_roll = quantize_values(piano_roll)\n",
      "\n",
      "    if wave is None:\n",
      "        wave = functools.partial(scipy.signal.square, duty=0.5)\n",
      "\n",
      "    bins_per_semi = bins_per_octave/12\n",
      "    first_bin = bins_per_semi/2\n",
      "\n",
      "    frequencies = librosa.cqt_frequencies(n_bins=piano_roll.shape[0],\n",
      "                                          fmin=fmin,\n",
      "                                          bins_per_octave=bins_per_octave,\n",
      "                                          tuning=tuning)\n",
      "\n",
      "    beats -= beats[0]\n",
      "\n",
      "    if n is None:\n",
      "        n = beats[-1] + 0.5 * sr\n",
      "\n",
      "    beats = librosa.util.fix_frames(beats, x_min=0, x_max=n)\n",
      "    beat_intervals = librosa.util.frame(beats, frame_length=2, hop_length=1).T\n",
      "\n",
      "    output = np.zeros(n)\n",
      "\n",
      "    correction = 2.0 ** (tuning / bins_per_octave)\n",
      "    stream = correction * 2.0 * np.pi * np.arange(len(output)) / sr\n",
      "\n",
      "    active_bins = piano_roll.sum(axis=1) > 0\n",
      "\n",
      "    for n, freq in enumerate(frequencies):\n",
      "        if not active_bins[n * bins_per_semi + first_bin]:\n",
      "            continue\n",
      "\n",
      "        my_f = freq * stream\n",
      "\n",
      "        sine = wave(my_f)\n",
      "\n",
      "        # Align beat timings to zero crossings of sine\n",
      "        zc_mask = librosa.zero_crossings(sine)\n",
      "\n",
      "        beat_f = match_zc(beat_intervals, zc_mask, freq * correction, sr)\n",
      "\n",
      "        # Mask out this frequency wherever it's inactive\n",
      "        for m, (start, end) in enumerate(beat_f):\n",
      "            sine[start:end] *= piano_roll[n*bins_per_semi + first_bin, m]\n",
      "\n",
      "        output += sine\n",
      "\n",
      "    output = librosa.util.normalize(output)\n",
      "    return output, sr\n",
      "\n",
      "\n",
      "def match_zc(queries, zc_mask, my_f, sr):\n",
      "\n",
      "    # For each query, bound define a search range\n",
      "    window = int(np.ceil(sr / my_f))\n",
      "\n",
      "    output = np.empty(queries.size, dtype=int)\n",
      "\n",
      "    for i, q in enumerate(queries.ravel()):\n",
      "        s = np.maximum(0, q - window)\n",
      "        t = np.minimum(len(zc_mask), q + window)\n",
      "\n",
      "        vals = s + np.flatnonzero(zc_mask[s:t])\n",
      "        output[i] = vals[np.argmin(np.abs(q - vals))]\n",
      "\n",
      "    return output.reshape(queries.shape)\n",
      "\n",
      "\n",
      "def peakgram(C, max_peaks=1, note_search=8):\n",
      "    '''Compute spectrogram column-wise peaks subject to constraints'''\n",
      "\n",
      "    mask = np.zeros_like(C)\n",
      "\n",
      "    for t in range(C.shape[1]):\n",
      "        if t == 0 or not np.any(mask[:, t-1]):\n",
      "            col = C[:, t]\n",
      "        else:\n",
      "            col = np.min(C[:, t]) * np.ones(C.shape[0])\n",
      "\n",
      "            # Find peaks in the previous column\n",
      "            # zero out anything outside of +- note_search from a peak\n",
      "            for v in np.argwhere(mask[:, t-1]):\n",
      "                r_min = max(0, v-note_search)\n",
      "                r_max = min(col.shape[0], v+note_search+1)\n",
      "                col[r_min:r_max] = C[r_min:r_max, t]\n",
      "\n",
      "        # Local normalization\n",
      "        z = col.max()\n",
      "        if z > 0:\n",
      "            col = col / z\n",
      "\n",
      "        # Don't look for 2nds or 11ths\n",
      "        # Compute max over an octave range, +- 3 semitones\n",
      "        peaks = librosa.util.peak_pick(col, 3, 3, 6, 6, 1e-2, 3)\n",
      "\n",
      "        if len(peaks) == 0:\n",
      "            continue\n",
      "\n",
      "        # Order the peaks by loudness\n",
      "        idx = np.argsort(col[peaks])[::-1]\n",
      "        peaks = peaks[idx]\n",
      "\n",
      "        # Clip to max_peaks\n",
      "        peaks = peaks[:min(len(peaks), max_peaks)]\n",
      "\n",
      "        # If there are any peaks, pick them out\n",
      "        mask[peaks, t] = 1\n",
      "\n",
      "    return mask\n",
      "\n",
      "\n",
      "def dft_normalize(c):\n",
      "\n",
      "    D = np.fft.rfft(c, axis=0)\n",
      "    D = D / (1e-8 + np.mean(np.abs(D)**2, axis=1, keepdims=True)**0.5)\n",
      "    cinv = np.fft.irfft(D, axis=0)\n",
      "    return np.clip(cinv, 0, None)\n",
      "\n",
      "\n",
      "def process_audio(y):\n",
      "    '''load the audio, do feature extraction'''\n",
      "\n",
      "\n",
      "    # Get the harmonic and percussive components\n",
      "    y_harm, y_perc = librosa.effects.hpss(y)\n",
      "\n",
      "    # compute CQT\n",
      "    cq = librosa.cqt(y_harm, sr, fmin=fmin, n_bins=MIDI_MAX-MIDI_MIN, hop_length=hop_length)\n",
      "\n",
      "    cq = dft_normalize(cq)\n",
      "\n",
      "    \"\"\"\n",
      "    # Trim to match cq and P shape\n",
      "    P = (librosa.feature.rmse(y=y_perc, hop_length=hop_length)\n",
      "         / librosa.feature.rmse(y=y, hop_length=hop_length))\n",
      "\n",
      "    P[~np.isfinite(P)] = 0.0\n",
      "    \"\"\"\n",
      "    duration = cq.shape[-1]\n",
      "    # P = librosa.util.fix_length(P, duration, axis=-1)\n",
      "    cq = librosa.util.fix_length(cq, duration, axis=-1)\n",
      "\n",
      "    return y, cq, y_perc\n",
      "\n",
      "\n",
      "def get_wav(cq, nmin=60, nmax=120, width=5, max_peaks=1, wave=None, n=None):\n",
      "\n",
      "    # Slice down to the bass range\n",
      "    cq = cq[nmin:nmax]\n",
      "\n",
      "    # Pick peaks at each time\n",
      "    mask = peakgram(librosa.logamplitude(cq**2, top_db=60, ref_power=np.max),\n",
      "                    max_peaks=max_peaks)\n",
      "\n",
      "    # Smooth in time\n",
      "    mask = scipy.ndimage.median_filter(mask,\n",
      "                                       size=(1, width),\n",
      "                                       mode='mirror')\n",
      "\n",
      "    # resynthesize with some magnitude compression\n",
      "    wav = synthesize(librosa.frames_to_samples(np.arange(cq.shape[-1]),\n",
      "                                               hop_length=hop_length),\n",
      "                     mask * cq**(1./3),\n",
      "                     fmin=librosa.midi_to_hz(nmin + MIDI_MIN),\n",
      "                     bins_per_octave=12,\n",
      "                     wave=wave,\n",
      "                     n=n)[0]\n",
      "\n",
      "    return wav\n",
      "\n",
      "\n",
      "def get_drum_wav(percussion, width=5, n=None):\n",
      "\n",
      "    # Compute volume shaper\n",
      "    percussion = librosa.util.normalize(percussion.ravel())\n",
      "\n",
      "    v = scipy.ndimage.median_filter(percussion,\n",
      "                                    width,\n",
      "                                    mode='mirror')\n",
      "    v = np.atleast_2d(v)\n",
      "\n",
      "    wav = synthesize(librosa.frames_to_samples(np.arange(v.shape[-1]),\n",
      "                                               hop_length=hop_length),\n",
      "                     v,\n",
      "                     fmin=librosa.midi_to_hz(0),\n",
      "                     bins_per_octave=12,\n",
      "                     wave=noise,\n",
      "                     n=n)[0]\n",
      "\n",
      "    return wav\n",
      "\n",
      "\n",
      "def process_arguments(args):\n",
      "\n",
      "    parser = argparse.ArgumentParser(description='Auto Chip Tune')\n",
      "\n",
      "    parser.add_argument('input_file',\n",
      "                        action='store',\n",
      "                        help='Path to the input audio file')\n",
      "\n",
      "    parser.add_argument('output_file',\n",
      "                        action='store',\n",
      "                        help='Path to store the generated chiptune')\n",
      "\n",
      "    parser.add_argument('-s', '--stereo',\n",
      "                        action='store_true',\n",
      "                        default=False,\n",
      "                        help='Mix original and synthesized tracks in stereo')\n",
      "\n",
      "    return vars(parser.parse_args(args))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'''Robust PCA in python.'''\n",
      "# CREATED:2013-04-29 08:50:44 by Brian McFee <brm2132@columbia.edu>\n",
      "#  \n",
      "import numpy as np\n",
      "import scipy\n",
      "import scipy.linalg\n",
      "import scipy.weave\n",
      "\n",
      "def nuclear_prox(A, r=1.0):\n",
      "    '''Proximal operator for scaled nuclear norm:\n",
      "    Y* <- argmin_Y  r * ||Y||_* + 1/2 * ||Y - A||_F^2\n",
      "    Arguments:\n",
      "        A    -- (ndarray) input matrix\n",
      "        r    -- (float>0) scaling factor\n",
      "    Returns:\n",
      "        Y    -- (ndarray) if A = USV', then Y = UTV'\n",
      "                          where T = max(S - r, 0)\n",
      "    '''\n",
      "    \n",
      "    U, S, V = scipy.linalg.svd(A, full_matrices=False)\n",
      "    T = np.maximum(S - r, 0.0)\n",
      "    Y = (U * T).dot(V)\n",
      "    return Y\n",
      "\n",
      "def l1_prox(A, r=1.0, nonneg=False):\n",
      "    '''Proximal operator for entry-wise matrix l1 norm:\n",
      "    Y* <- argmin_Y r * ||Y||_1 + 1/2 * ||Y - A||_F^2\n",
      "    Arguments:\n",
      "        Arguments:\n",
      "        A    -- (ndarray) input matrix\n",
      "        r    -- (float>0) scaling factor\n",
      "        nonneg -- (bool) retain only the non-negative portion\n",
      "    Returns:\n",
      "        Y    -- (ndarray) Y = A after shrinkage\n",
      "    '''\n",
      "    \n",
      "    Y = np.zeros_like(A)\n",
      "    \n",
      "    numel = A.size\n",
      "    \n",
      "    shrinkage = r\"\"\"\n",
      "    int NN = (int)nonneg;\n",
      "    for (int i = 0; i < numel; i++) {\n",
      "        Y[i] = 0;\n",
      "        if (A[i] - r > 0) {\n",
      "            Y[i] = A[i] - r;\n",
      "        } else if (!NN && (A[i] + r <= 0)) {\n",
      "            Y[i] = A[i] + r;\n",
      "        }\n",
      "    }\n",
      "    \"\"\"\n",
      "    \n",
      "    scipy.weave.inline(shrinkage, ['numel', 'A', 'r', 'Y', 'nonneg'])\n",
      "    return Y\n",
      "\n",
      "def robust_pca_cost(Y, Z, alpha):\n",
      "    '''Get the cost of an RPCA solution.\n",
      "    Arguments:\n",
      "        Y       -- (ndarray)    the low-rank component\n",
      "        Z       -- (ndarray)    the sparse component\n",
      "        alpha   -- (float>0)    the balancing factor\n",
      "    Returns:\n",
      "        total, nuclear_norm, l1_norm -- (list of floats)\n",
      "    '''\n",
      "    nuclear_norm = scipy.linalg.svd(Y, full_matrices=False, compute_uv=False).sum()\n",
      "    \n",
      "    l1_norm = np.abs(Z).sum()\n",
      "    \n",
      "    return nuclear_norm + alpha * l1_norm, nuclear_norm, l1_norm\n",
      "\n",
      "\n",
      "def robust_pca(X, alpha=None, max_iter=100, verbose=False, nonneg=False):\n",
      "    '''ADMM solver for robust PCA.\n",
      "    min_Y  ||Y||_* + alpha * ||X-Y||_1\n",
      "    Arguments:\n",
      "        X        -- (ndarray) input data (d-by-n)\n",
      "        alpha    -- (float>0) weight of the l1 penalty\n",
      "                    if unspecified, defaults to 1.0 / sqrt(max(d, n))\n",
      "        nonneg   -- (bool) constrain to non-negative noise\n",
      "    Returns:\n",
      "        Y        -- (ndarray) low-rank component of X\n",
      "        Z        -- (ndarray) sparse component of X\n",
      "        diags    -- (dict)    diagnostic output\n",
      "    '''\n",
      "    \n",
      "    RHO_MIN      = 1e-1\n",
      "    RHO_MAX      = 1e6\n",
      "    MAX_RATIO    = 1e1\n",
      "    SCALE_FACTOR = 3.0e0\n",
      "    ABS_TOL      = 1e-4\n",
      "    REL_TOL      = 1e-3\n",
      "    \n",
      "    # update rules:\n",
      "    #  Y+ <- nuclear_prox(X - Z - W, 1/rho)\n",
      "    #  Z+ <- l1_prox(X - Y - W, alpha/rho)\n",
      "    #  W+ <- W + Y + Z - X\n",
      "    \n",
      "    # Initialize\n",
      "    rho = RHO_MIN\n",
      "    \n",
      "    Y   = X.copy()\n",
      "    Z   = np.zeros_like(X)\n",
      "    W   = np.zeros_like(X)\n",
      "    \n",
      "    norm_X = scipy.linalg.norm(X)\n",
      "    \n",
      "    if alpha is None:\n",
      "        alpha = max(X.shape)**(-0.5)\n",
      "\n",
      "    m   = X.size\n",
      "\n",
      "    _DIAG = {\n",
      "         'err_primal': [],\n",
      "         'err_dual':   [],\n",
      "         'eps_primal': [],\n",
      "         'eps_dual':   [],\n",
      "         'rho':        []\n",
      "    }\n",
      "    \n",
      "    for t in range(max_iter):\n",
      "        Y = nuclear_prox(X - Z - W, 1.0/  rho)\n",
      "        Z_old = Z.copy()\n",
      "        Z = l1_prox(X - Y - W, alpha /  rho, nonneg)\n",
      "        \n",
      "        if nonneg:\n",
      "            Z = np.maximum(Z, X)\n",
      "\n",
      "        residual_pri  = Y + Z - X\n",
      "        residual_dual = Z - Z_old\n",
      "        \n",
      "        res_norm_pri  = scipy.linalg.norm(residual_pri)\n",
      "        res_norm_dual = rho * scipy.linalg.norm(residual_dual)\n",
      "        \n",
      "        W = W + residual_pri\n",
      "        \n",
      "        eps_pri  = np.sqrt(m) * ABS_TOL + REL_TOL * max(scipy.linalg.norm(Y), scipy.linalg.norm(Z), norm_X)\n",
      "        eps_dual = np.sqrt(m) * ABS_TOL + REL_TOL * scipy.linalg.norm(W)\n",
      "        \n",
      "        _DIAG['eps_primal'].append(eps_pri)\n",
      "        _DIAG['eps_dual'  ].append(eps_dual)\n",
      "        _DIAG['err_primal'].append(res_norm_pri)\n",
      "        _DIAG['err_dual'  ].append(res_norm_dual)\n",
      "        _DIAG['rho'       ].append(rho)\n",
      "        \n",
      "        if res_norm_pri <= eps_pri and res_norm_dual <= eps_dual:\n",
      "            break\n",
      "            \n",
      "        if res_norm_pri > MAX_RATIO * res_norm_dual and rho * SCALE_FACTOR <= RHO_MAX:\n",
      "            rho = rho * SCALE_FACTOR\n",
      "            W   = W / SCALE_FACTOR\n",
      "            \n",
      "            \n",
      "        elif res_norm_dual > MAX_RATIO * res_norm_pri and rho / SCALE_FACTOR >= RHO_MIN:\n",
      "            rho = rho / SCALE_FACTOR\n",
      "            W   = W * SCALE_FACTOR\n",
      "       \n",
      "    if verbose:\n",
      "        if t < max_iter - 1:\n",
      "            print 'Converged in %d steps' % t\n",
      "        else:\n",
      "            print 'Reached maximum iterations'\n",
      "    \n",
      "    Y = X - Z\n",
      "    _DIAG['cost'] = robust_pca_cost(Y, Z, alpha)\n",
      "    \n",
      "    return (Y, Z, _DIAG)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "\n",
      "# From https://github.com/bmcfee/musichacks/blob/master/2013yyz/frankenmash/mangler.py\n",
      "# Robust PCA method of vocal removal\n",
      "\n",
      "def rpca_correct(X, L, S, p=0):\n",
      "    \n",
      "    # Recombobulate into an energy partition\n",
      "    L = np.maximum(0.0, L)\n",
      "    L = np.minimum(X, L)\n",
      "    S = X - L\n",
      "    \n",
      "    # Wiener-filter to smooth out the edges\n",
      "    if p > 0:\n",
      "        zS = S == 0\n",
      "        S = S ** p\n",
      "        S[zS] = 0.0\n",
      "    \n",
      "        zL = L == 0\n",
      "        L = L ** p\n",
      "        L[zL] = 0.0\n",
      "    \n",
      "        L[zL & zS] = 0.5\n",
      "        S[zL & zS] = 0.5\n",
      "    \n",
      "        Ml = L / (L + S)\n",
      "        Ms = S / (L + S)\n",
      "    \n",
      "        return (X * Ml, X * Ms)\n",
      "    else:\n",
      "        return (L, S)\n",
      "\n",
      "    \n",
      "def remove_vocals(y):\n",
      "    \n",
      "    # Step 1: compute STFT\n",
      "    D = librosa.stft(y, n_fft=n_fft, hop_length=hop_length).astype(np.complex64)\n",
      "    \n",
      "    # Step 2: separate magnitude and phase\n",
      "    S, P = librosa.magphase(D)\n",
      "    S    = S / S.max()\n",
      "    \n",
      "    tau = (D.shape[0] * 3) / 4\n",
      "\n",
      "    \n",
      "    # Step 3: RPCA to separate voice and background\n",
      "    S1, S2, _ = robust_pca(S[:tau,:], max_iter=25)\n",
      "    S1, S2    = rpca_correct(S[:tau,:], S1, S2)\n",
      "\n",
      "    S1 = np.vstack((S1, S[tau:,:]))\n",
      "    \n",
      "    del D\n",
      "    del S\n",
      "    del S2\n",
      "    # Step 4: recombine with phase, return vocals\n",
      "    return S1 * P\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def autochip(input_file=None, output_file=None, stereo=False):\n",
      "    #global y_treb, y_bass, y_perc, percussion\n",
      "    \n",
      "    print 'Processing {:s}'.format(os.path.basename(input_file))\n",
      "    \n",
      "    y, sr = librosa.load(input_file)\n",
      "    \"\"\" TODO: remove vocals in percussion layer \n",
      "    print \"remove vox\"\n",
      "    y_novox = remove_vocals(y)\n",
      "    print \"leny\"\n",
      "    leny = len(y)\n",
      "    print \"process audio\"\n",
      "    y, cq, _ = process_audio(y) # include vocals in harmony\n",
      "    _, _, y_perc = process_audio(y_novox) # build the percussion from the version without vocals\n",
      "    del y\n",
      "    \"\"\"\n",
      "    leny = len(y)\n",
      "    y, cq, y_perc = process_audio(y)\n",
      "    del y\n",
      "    \n",
      "    print 'Synthesizing squares...'\n",
      "    y_treb = get_wav(cq,\n",
      "                     nmin=MIDI_MIN,\n",
      "                     nmax=MIDI_MAX,\n",
      "                     max_peaks=20,\n",
      "                     n=leny)\n",
      "\n",
      "    print 'Synthesizing triangles...'\n",
      "    y_bass = get_wav(cq,\n",
      "                     nmin=MIDI_MIN,\n",
      "                     nmax=BASS_MAX,\n",
      "                     wave=nes_triangle,\n",
      "                     max_peaks=4,\n",
      "                     n=leny)\n",
      "\n",
      "    del cq\n",
      "    \n",
      "    print 'Synthesizing drums...'\n",
      "    #1 11325 5798016\n",
      "    \n",
      "    #y_drum = get_drum_wav(percussion, n=len(y))\n",
      "    #y_drum = librosa.istft(percussion, hop_length, n_fft)\n",
      "    #print len(y_bass), len(y_perc), y_perc.size\n",
      "    \n",
      "    \n",
      "    \n",
      "    bits = pow(2,2)\n",
      "    bitcrush_ = np.vectorize(lambda x: round(x*bits)/bits) \n",
      "    y_perc = bitcrush_(y_perc)\n",
      "    \n",
      "\n",
      "    print 'Mixing... '\n",
      "    y_chip = librosa.util.normalize(0.5 * y_treb +\n",
      "                                    0.7 * y_bass +\n",
      "                                    0.8 * y_perc) # took the drum out\n",
      "\n",
      "    del y_treb\n",
      "    del y_bass\n",
      "    del y_perc\n",
      "    \n",
      "    \"\"\"\n",
      "    bitcrush = np.vectorize(lambda x, bits: floor(x*bits)/bits) \n",
      "    \n",
      "    y_chip = y_treb + y_bass\n",
      "    del y_treb\n",
      "    del y_bass\n",
      "    y_chip = bitcrush(y_chip, pow(2,16))\n",
      "    y_perc = bitcrush(y_perc,1.2)\n",
      "    y_chip = (y_chip) + (0.3 * y_perc)\n",
      "    \n",
      "    del y_perc\n",
      "    y_chip = librosa.util.normalize(y_chip)\n",
      "    #y_chip = bitcrush(y_chip, pow(2,8))\n",
      "    \n",
      "    \"\"\"\n",
      "    \n",
      "    if stereo:\n",
      "        y_out = np.vstack([librosa.util.normalize(y), y_chip])\n",
      "    else:\n",
      "        y_out = y_chip\n",
      "\n",
      "    del y_chip \n",
      "    \n",
      "    librosa.output.write_wav(output_file, y_out, sr)\n",
      "    del y_out\n",
      "    print 'Done.'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#!/usr/bin/env python\n",
      "# encoding: utf=8\n",
      "\"\"\"\n",
      "offliberty gnabber\n",
      "downloads tracks from soundcloud, always 128k mp3\n",
      "\n",
      "cortexel.us 2012\n",
      "\"\"\"\n",
      "import urllib2, urllib, re, json\n",
      "\n",
      "usage = \"Offliberty Gnabber. Downloads tracks from soundcloud, youtube, etc.\\n\\\n",
      "Usage: offliberty.py url\\\n",
      "Example: offliberty.py http://soundcloud.com/chopshopshockshack/mt-analogue-you-know-what-time\"\n",
      "\n",
      "def gnab_download(url, file_name):\n",
      "    print \"gnab download..\"\n",
      "    url = url.replace(\"https\",\"http\")\n",
      "    #print \"url: %s / filename: %s\" % (url, file_name)\n",
      "    print \"opening url\", url\n",
      "    u = urllib2.urlopen(url)\n",
      "    #print u\n",
      "    #print \"opening filename\", file_name\n",
      "    f = open(file_name, 'wb')\n",
      "    #print f\n",
      "    meta = u.info()\n",
      "    #print meta\n",
      "    file_size = False\n",
      "    if(meta.getheaders(\"Content-Length\")):\n",
      "        file_size = int(meta.getheaders(\"Content-Length\")[0])\n",
      "        #print file_size\n",
      "        #print \"Downloading: %s \\nBytes: %s\" % (file_name, file_size)\n",
      "\n",
      "    #if(file_size >= self.MAX_FILE_SIZE):\n",
      "    #    raise Exception(\"File size too big!! %i > %i \" % [file_size, self.MAX_FILE_SIZE])\n",
      "        \n",
      "    file_size_dl = 0\n",
      "    block_sz = 8192\n",
      "    while True:\n",
      "        buffer = u.read(block_sz)\n",
      "        if not buffer:\n",
      "            break\n",
      "\n",
      "        file_size_dl += len(buffer)\n",
      "        f.write(buffer)\n",
      "        if(file_size):\n",
      "            status = r\"%10d  [%3.2f%%]\" % (file_size_dl, file_size_dl * 100. / file_size)\n",
      "        else:\n",
      "            status = r\"%10d\" % (file_size_dl)\n",
      "        status = status + chr(8)*(len(status)+1)\n",
      "        #print status,\n",
      "\n",
      "    print \"\\n\"\n",
      "    f.close()\n",
      "    \n",
      "#gnab_download('https://i1.sndcdn.com/avatars-000008456211-qo1al2-large.jpg', './dadabots/art/\u1d04\u042f\u0367tx\u013dz\\n.avatar.jpg')\n",
      "\n",
      "def gnabsong(url, filename):\n",
      "    gnab_download(geturl(url), filename)\n",
      "    \n",
      "# given url, grabs mp3 using offliberty\n",
      "def geturl(song_url):\n",
      "    if \"soundcloud.com\" in song_url:\n",
      "        return get_soundcloud_song(song_url)\n",
      "    off_url = \"http://offliberty.com/off02.php\"\n",
      "    req = urllib2.Request(off_url) \n",
      "    #res = urllib2.urlopen(req)\n",
      "    print sc_url \n",
      "    req.add_header(\"User-agent\", \"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.155 Safari/537.36\")\n",
      "    req.add_header(\"Referer\",\"http://offliberty.com/\")\n",
      "\n",
      "    data = { 'track' : sc_url, 'refext' : \"\"} \n",
      "    req.add_data(urllib.urlencode(data))\n",
      "    res = urllib2.urlopen(req)\n",
      "    \n",
      "    offpage = res.read(4000)\n",
      "    \n",
      "    if(\"You can't use Offliberty so often\" in offpage):\n",
      "        print \"Offliberty limit reached. . sleeping for one hour\"\n",
      "        sys.stdout.flush()\n",
      "        time.sleep(60*60) \n",
      "    url_list = re.findall('(?:https?://|www.)[^\"\\' ]+', offpage)\n",
      "    return url_list[0]\n",
      "\n",
      "def get_soundcloud_song(song_url):\n",
      "    # given url, grabs mp3 using offliberty\n",
      "    api_url = \"https://api.soundcloud.com/resolve.json?\" + urllib.urlencode([(\"url\",song_url), (\"client_id\",client_id)])\n",
      "    req = urllib2.Request(api_url) \n",
      "    #res = urllib2.urlopen(req)\n",
      "    print song_url, api_url\n",
      "    #req.add_header(\"User-agent\", \"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.155 Safari/537.36\")\n",
      "    #req.add_header(\"Referer\",\"http://offliberty.com/\")\n",
      "\n",
      "    result = json.loads(urllib2.urlopen(req).read())\n",
      "    mp3_url = result[\"stream_url\"] + \"?client_id=\" + client_id\n",
      "    return mp3_url\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from PIL import Image\n",
      "import PIL.ImageOps\n",
      "import PIL.ImageFilter as ImageFilter\n",
      "import ImageChops\n",
      "\n",
      "\n",
      "# resizes image so its all blurred\n",
      "def autochip_art(bot,track_art):\n",
      "    image = Image.open(track_art)\n",
      "    image = image.resize((16,16),Image.NEAREST).resize((800,800),Image.NEAREST)\n",
      "    new_track_art = track_art[:-3] + \"rmx.autochip.\" + track_art[-3:]\n",
      "    image.save(new_track_art) \n",
      "    return new_track_art\n",
      "\n",
      "# takes art, finds edges, creates horz and vert symmetry\n",
      "def art_florp(bot,track_art):\n",
      "    image = Image.open(track_art)\n",
      "    image = image.filter(ImageFilter.FIND_EDGES)\n",
      "    image = Image.blend(Image.blend(image, image.rotate(90), 0.5), Image.blend(image.rotate(180), image.rotate(270), 0.5), 0.5)\n",
      "    new_track_art = track_art[:-3] + \"rmx.florp.\" + track_art[-3:]\n",
      "    image.save(new_track_art) \n",
      "    return new_track_art\n",
      "\n",
      "# simple horz flip, kinda dumb\n",
      "def horzflip(bot,art):\n",
      "    image = Image.open(art)\n",
      "    image = Image.blend(image, image.rotate(180), 0.5)\n",
      "    new_art = art[:-3] + \"rmx.horzflip.\" + art[-3:]\n",
      "    image.save(new_art)\n",
      "    return new_art\n",
      "    \n",
      "#octogon flip\n",
      "def octoflip(bot,art):\n",
      "    image = Image.open(art)\n",
      "    image = Image.blend(Image.blend(image, image.rotate(90), 0.5), Image.blend(image.rotate(180), image.rotate(270), 0.5), 0.5)\n",
      "    image = Image.blend(image, image.rotate(45), 0.5)\n",
      "    image = image.filter(ImageFilter.SHARPEN)\n",
      "    image = image.filter(ImageFilter.SHARPEN)\n",
      "    new_art = art[:-3] + \"rmx.octo.\" + art[-3:]\n",
      "    image.save(new_art)\n",
      "    return new_art"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#!/usr/bin/env python\n",
      "# encoding: utf-8\n",
      "\n",
      "\"\"\"\n",
      "DadaBot.py\n",
      "\n",
      "Class for soundcloud bots. \n",
      "\n",
      "By CJ Carr [cortexel.us]\n",
      "Zack Zukowski\n",
      "\"\"\"\n",
      "import soundcloud\n",
      "import time\n",
      "import sys\n",
      "import os.path\n",
      "import urllib2\n",
      "from random import choice\n",
      "import random\n",
      "from random import randint\n",
      "from requests.exceptions import HTTPError \n",
      "import pickle\n",
      "import copy\n",
      "import subprocess\n",
      "from random import shuffle\n",
      "usage = \"Use it correctly, not incorrectly\"\n",
      "\n",
      "class DadaBot:\n",
      "     \n",
      "    def __init__(bot):    \n",
      "        bot.client = None #  need to call connectSC()\n",
      "        bot.bot_user = None # need to call connectSC()\n",
      "        bot.followers = None # list of all followers\n",
      "        bot.follower = None # follower sc object whose music is remixed\n",
      "\n",
      "        bot.track = None # track sc object to be remixed\n",
      "        bot.track_mp3 = \"\" # file name of downloaded song to be remixed\n",
      "        bot.track_art = \"\" # filename of track art downloaded\n",
      "        bot.user_art = \"\" # filename of user art downloaded\n",
      "        \n",
      "        bot.always_find_new_tracks = True \n",
      "        # If True, will not remix a track which has been favorited by the bot\n",
      "        # If False, all tracks are fair game.\n",
      "        \n",
      "        bot.creative_commons_only = True\n",
      "        # ignores tracks which aren't creative commons\n",
      "\n",
      "        bot.followerid = 0\n",
      "        bot.trackid = 0\n",
      "        bot.remix_trackid = 0\n",
      "        bot.bot_userid = 0\n",
      "        \n",
      "        bot.remix_track = None # track sc of new remix track\n",
      "        bot.remix_title = \"\" # title of new remix track\n",
      "        bot.remix_mp3 = \"\" # filename of new remix \n",
      "        bot.remix_artwork = \"\" # filename of remixed artwork\n",
      "        bot.remix_completed = False\n",
      "        bot.remix_process_call = \"\"\n",
      "        \n",
      "        # DEFAULT info\n",
      "        bot.username = \"****\"\n",
      "        bot.password = \"******\"\n",
      "        bot.genre = \"chiptune\"\n",
      "        bot.tag = \"autochiptune\" # for file names example: \"song.rmx.weev.mp3\"\n",
      "        \n",
      "        # unicode(\"z \", errors='ignore')# unicode(\"  \", errors='ignore') # unicode(\"\\u0290 \", errors='replace') #\"  \" #.decode(\"utf-8\", \"replace\")\n",
      "\n",
      "        bot.MAX_TRACK_DURATION = 1000 * 60 * 8 # no tracks longer than 8 minutes\n",
      "        bot.MIN_TRACK_DURATION = 10 * 1000 # minimum 10 seconds\n",
      "        bot.MAX_FILE_SIZE = 10000000\n",
      "        bot.comments = [\n",
      "            'autochiptune_remix: %s',\n",
      "        ] \n",
      "    \n",
      "    def connect(bot, *args):\n",
      "        global client_id, client_secret \n",
      "        if len(args)==2:\n",
      "            username = args[0]\n",
      "            password = args[1]\n",
      "        else:\n",
      "            username = bot.username\n",
      "            password = bot.password\n",
      "        \n",
      "        # intiialize\n",
      "        print \"Initializing soundcloud.Client . . . \"\n",
      "        bot.client = soundcloud.Client(\n",
      "            client_id=client_id, \n",
      "            client_secret=client_secret,\n",
      "            username=username, \n",
      "            password=password)\n",
      "        bot.bot_user = bot.client.get('/me')\n",
      "        bot.bot_userid = bot.bot_user.id\n",
      "        \n",
      "    # Get a list of all the given user's followers. stop at \n",
      "    def get_followers(bot, user_id, max_limit):\n",
      "        followers = []\n",
      "        url = ('/users/%s/followers') % user_id\n",
      "        # soundcloud api only gives you 200 at a time, so we need to loop through with next_href\n",
      "        # see: https://developers.soundcloud.com/docs#pagination\n",
      "        while len(followers)<max_limit:\n",
      "            result = bot.client.get(url, limit=200, linked_partitioning=1)\n",
      "            followers.extend(result.obj[\"collection\"])\n",
      "            if(result.next_href):\n",
      "                url = result.next_href\n",
      "            else:\n",
      "                break\n",
      "        return followers\n",
      "            \n",
      "        \n",
      "    # follows all the followers' followers\n",
      "    def amicabilify(bot, user_id):\n",
      "        global followers\n",
      "        print \"Following some of the followers' followers . . . \"\n",
      "        #print user_id        \n",
      "        limit = 10\n",
      "        followers = bot.get_followers(user_id,200)\n",
      "        #print followers\n",
      "        shuffle(followers)\n",
      "        followers = followers[:10]\n",
      "        try:\n",
      "            for follower in followers:\n",
      "                bot.client.put('/me/followings/%d' % follower['id'])\n",
      "        except:\n",
      "            print \"failed at following the followers' followers\"\n",
      "            print sys.exc_info() \n",
      "            traceback.print_exc(file=sys.stdout)\n",
      "            \n",
      "        return followers\n",
      "        \n",
      "    def like_track(bot, track):\n",
      "        print \"Liking track . . . \"\n",
      "        bot.client.put('/me/favorites/%d' % track.id)\n",
      "            \n",
      "    # gets the user's list of favorite tracks\n",
      "    def get_favorites(bot, user):\n",
      "        # return bot.client.get('/users/%i/favorites' % user.id)\n",
      "        favorites = []\n",
      "        url = ('/users/%s/favorites' % user.id)\n",
      "        while True:\n",
      "            result = bot.client.get(url, limit=200, linked_partitioning=1)\n",
      "            favorites.extend(result.obj[\"collection\"])\n",
      "            if('next_href' in result.obj):\n",
      "                url = result.obj['next_href']\n",
      "            else:\n",
      "                break\n",
      "        return favorites\n",
      "    \n",
      "    # returns true if user has favorited track\n",
      "    def is_track_favorited(bot, track):\n",
      "        for fav in bot.favorites:\n",
      "            if track.id == fav['id']:\n",
      "                return True\n",
      "        return False\n",
      "        \n",
      "    # if bot has remixed this song before, returns false\n",
      "    # (based on the assumption that the bot liked the track after posting the remix)\n",
      "    def havent_heard_this_before(bot, track):\n",
      "        return not bot.is_track_favorited(track)\n",
      "    \n",
      "    # returns True if track has creative commons license \n",
      "    def is_creative_commons(bot, track):\n",
      "        return track.license[:2] == \"cc\"\n",
      "        \n",
      "    def download_mp3_and_art(bot):\n",
      "        url = bot.track.permalink_url\n",
      "        print \"url\", url\n",
      "        p = bot.track.permalink_url.split('/')\n",
      "        bot.track_mp3  = './dadabots/mp3/' + p[-2] + \"_\" + p[-1] + \".mp3\"\n",
      "        bot.remix_mp3 = './dadabots/mp3/' + p[-2] + \"_\" + p[-1] + \".rmx.\" + bot.tag + \".mp3\"\n",
      "        bot.remix_track_art = ''\n",
      "        bot.remix_user_art = '' \n",
      "        bot.track_art  = './dadabots/art/' + p[-2] + \"_\" + p[-1] + \".jpg\"\n",
      "        bot.user_art = './dadabots/art/' + p[-2] + \".avatar.jpg\"\n",
      "        \n",
      "        try: \n",
      "            gnabsong(url, bot.track_mp3)\n",
      "        except:\n",
      "            print \"!! Error. Song isn't available. %s %s\\n\\n\" % (url, bot.track_mp3)\n",
      "            print sys.exc_info() \n",
      "            traceback.print_exc(file=sys.stdout)\n",
      "            \n",
      "            return False\n",
      "        \n",
      "        print \"bot.track.artwork_url\", bot.track.artwork_url \n",
      "        \n",
      "        if(bot.track.artwork_url):\n",
      "            bot.track.artwork_url = bot.track.artwork_url.replace(\"https://\",\"http://\")\n",
      "            \n",
      "            print \"artwork_url\", bot.track.artwork_url\n",
      "            gnab_download(bot.track.artwork_url, bot.track_art)\n",
      "            #print \"!! Failed to download trackartwork: \" + bot.track.artwork_url\n",
      "            #bot.track_art = \"\"\n",
      "        else:\n",
      "            bot.track_art = \"\"\n",
      "            \n",
      "        if(bot.follower['avatar_url']):\n",
      "            bot.follower['avatar_url'] = bot.follower['avatar_url'].replace(\"https://\",\"http://\")\n",
      "            print \"avatar_url\", bot.follower['avatar_url']\n",
      "            gnab_download(bot.follower['avatar_url'], bot.user_art)\n",
      "            #print \"!! Failed to download trackartwork: \" + bot.follower['avatar_url']\n",
      "            #bot.user_art = \"\"\n",
      "        else:\n",
      "            bot.user_art = \"\"\n",
      "            \n",
      "        print \"\\n\"\n",
      "        print \"MP3: \" + bot.track_mp3\n",
      "        print \"TRACK_ART: \" + bot.track_art\n",
      "        print \"USER_ART: \" + bot.user_art\n",
      "        return True\n",
      "    \n",
      "    def remix(bot):\n",
      "        # and here is where a large security flaw lays dormant\n",
      "        #print \"About to call the following process: \" + bot.remix_process_call\n",
      "        print \"Calling autochip(%s, %s)\" % (bot.track_mp3, bot.remix_mp3)\n",
      "        sys.stdout.flush()\n",
      "        #cmdline = ['avconv','-i', bot.track_mp3, bot.track_mp3 + \".wav\"]\n",
      "        #subprocess.call(cmdline)\n",
      "        autochip(bot.track_mp3, bot.remix_mp3, False)\n",
      "        #bot.remix_mp3 = bot.track_mp3\n",
      "        #subprocess.call(bot.remix_process_call % (bot.track_mp3, bot.remix_mp3))\n",
      "        bot.remix_completed = True\n",
      "    \n",
      "    # have we completed remixing yet?\n",
      "    def already_remixed(bot):\n",
      "        return bot.remix_completed and os.path.isfile(bot.track_mp3)\n",
      "        \n",
      "        \n",
      "    def grab_track(bot, url):\n",
      "        bot.track = bot.client.get('/resolve',url=url) \n",
      "        bot.follower = bot.client.get('/users/'+str(bot.track.user_id))\n",
      "        if bot.download_mp3_and_art():\n",
      "        \n",
      "        \n",
      "            bot.trackid = bot.track.id\n",
      "            bot.followerid = bot.follower.id\n",
      "            return True\n",
      "        else:\n",
      "            raise Exception (\"BAD URL\")\n",
      "        \n",
      "    #algorithm for choosing which track to download\n",
      "    def find_track(bot):\n",
      "        bot.favorites = bot.get_favorites(bot.bot_user)\n",
      "        \n",
      "        bot.followers = bot.get_followers(bot.bot_user.id,2000)\n",
      "        shuffle(bot.followers)\n",
      "        \n",
      "        track_found = False\n",
      "        for follower in bot.followers:\n",
      "            print \"Searching \" + follower['username'] + \"'s tracks . . . \"\n",
      "            #order='hotness' #filter='downloadable' #license='\n",
      "            tracks = bot.client.get('/users/' + str(follower['id']) + '/tracks', order='created_at', limit=200)\n",
      "            \n",
      "            tracktitles = []\n",
      "            for t in tracks:\n",
      "                tracktitles.append(t.title)\n",
      "            print \"Titles: \", tracktitles\n",
      "            \n",
      "            tracks = filter(lambda track: \n",
      "                ((bot.is_creative_commons(track) if bot.creative_commons_only else True) and \n",
      "                 (bot.havent_heard_this_before(track) if bot.always_find_new_tracks else True) and\n",
      "                 track.duration <= bot.MAX_TRACK_DURATION and \n",
      "                 track.duration >= bot.MIN_TRACK_DURATION), tracks)\n",
      "            shuffle(tracks)\n",
      "            \n",
      "            tracktitles = []\n",
      "            for t in tracks:\n",
      "                tracktitles.append(t.title)\n",
      "            print \"Filtered titles: \", tracktitles\n",
      "            \n",
      "            for track in tracks:\n",
      "                print \"Hmm.. \", track.title\n",
      "                bot.follower = follower\n",
      "                bot.track = track\n",
      "                if bot.download_mp3_and_art(): \n",
      "                    track_found = True\n",
      "                    break\n",
      "                \"\"\"else:\n",
      "                    sys.stdout.write(\"Keep searching through \" + follower.username + \"'s tracks?\")\n",
      "                    choice = raw_input().lower()\n",
      "                    if choice==\"y\" or choice==\"yes\":\n",
      "                        continue\n",
      "                    else:\n",
      "                        break\n",
      "                \"\"\"\n",
      "                    \n",
      "            if track_found:\n",
      "                break\n",
      "        \n",
      "        if not track_found:\n",
      "            raise Exception( \"NO TRACKS!!!!!!!!!!\" )\n",
      "            \n",
      "        print \"\\n\"\n",
      "        bot.trackid = bot.track.id\n",
      "        bot.followerid = bot.follower['id']\n",
      "        \n",
      "        return True\n",
      "        \n",
      "\n",
      "    def dump_intention(bot):\n",
      "        intention_filename = \"./dadabots/intn/\" + bot.track_mp3[6:-4] + \".\" + bot.tag + \".intention\"\n",
      "        \n",
      "        # an intention is a copy of the bot object\n",
      "        # except it does not contain the soundcloud objects (because this causes a stack overflow)\n",
      "        intention = copy.copy(bot)\n",
      "        intention.follower = None\n",
      "        intention.followers = None\n",
      "        intention.track = None\n",
      "        intention.remix_track = None\n",
      "        intention.client = None\n",
      "        intention.bot_user = None \n",
      "        \n",
      "        file = open(intention_filename, \"wb\" )\n",
      "        pickle.dump(intention, file)\n",
      "        file.close()\n",
      "        print intention_filename\n",
      "        return intention_filename\n",
      "    \n",
      "    @staticmethod\n",
      "    def load(intention_filename):\n",
      "        file = open( intention_filename, \"rb\" )\n",
      "        sys.setrecursionlimit(10000)\n",
      "        bot = pickle.load(file)\n",
      "        file.close()\n",
      "        bot.connect(bot.username, bot.password)\n",
      "        bot.track = bot.client.get('/tracks/'+str(bot.trackid))\n",
      "        bot.follower = bot.client.get('/users/'+str(bot.track.user_id))\n",
      "        \n",
      "        return bot\n",
      "    \n",
      "    def post_remix(bot):\n",
      "        print \"Uploading remix . . . \"\n",
      "        print \"Remix track art\", bot.remix_track_art\n",
      "        if(bot.remix_track_art):\n",
      "            art_bytes = open(bot.remix_track_art, 'rb')\n",
      "        elif(bot.remix_user_art):\n",
      "            art_bytes = open(bot.remix_user_art, 'rb')\n",
      "        else:\n",
      "            art_bytes = \"\"\n",
      "        if not bot.remix_description:\n",
      "            bot.remix_description = '%s remix of %s' % (bot.tag, bot.track.permalink_url)\n",
      "        try: \n",
      "            bot.remix_track = bot.client.post('/tracks', track={\n",
      "                'title': bot.remix_title,\n",
      "                'asset_data': open(bot.remix_mp3, 'rb'),\n",
      "                'sharing': 'public',\n",
      "                'description' : bot.remix_description,\n",
      "                'genre' : bot.genre,\n",
      "                'artwork_data' : art_bytes\n",
      "            })\n",
      "        except HTTPError as err:\n",
      "            print \"Err\", err\n",
      "            if \"422\" in err:\n",
      "                raise Exception(\"Error uploading track to SoundCloud. Account has probably reached upload limit. Limit=3 hours for standard SoundCloud accounts\")\n",
      "            else:\n",
      "                raise\n",
      "        except:\n",
      "            print \"Exception:\", sys.exc_info()[0]\n",
      "            raise\n",
      "        # print track link\n",
      "        print bot.remix_track.permalink_url\n",
      "        return bot.remix_track\n",
      "\n",
      "    def update_avatar(bot,image):\n",
      "        print \"Updating avatar...\" + image\n",
      "        user = bot.client.put('/me', user={\n",
      "            'avatar_data' :open(image, 'rb')\n",
      "        })\n",
      "        return user\n",
      "        \n",
      "    # returns a comment\n",
      "    def comment(bot, url):\n",
      "        comment = choice(bot.comments) % url\n",
      "        return comment\n",
      "        \n",
      "    def main(bot):\n",
      "        \n",
      "        print \"hi\"\n",
      "        \n",
      "        bot.creative_commons_only = False\n",
      "        \n",
      "        #connect to soundcloud API\n",
      "        bot.connect(bot.username, bot.password)\n",
      "        \n",
      "        # grab track from this follower\n",
      "        # downloads mp3, track art, and user art, and returns filenames\n",
      "        bot.find_track()\n",
      "        # bot.grab_track(\"https://soundcloud.com/leeloo0905/in-the-eye\")\n",
      "        \n",
      "        # update bot user art\n",
      "        if(bot.user_art):\n",
      "            bot.remix_user_art = autochip_art(bot, bot.user_art)\n",
      "            bot.update_avatar(bot.remix_user_art)\n",
      "        \n",
      "        # remix track art\n",
      "        if(bot.track_art):\n",
      "            print \"Remixing track art\", bot.track_art\n",
      "            bot.remix_track_art = autochip_art(bot, bot.track_art)\n",
      "        else:\n",
      "            print \"No track art to remix\"\n",
      "        \n",
      "        \n",
      "        bot.remix_description =\"Automatic chiptune remix bot.\\nFollow if you want your tracks remixed.\\nUnfollow if you don't.\"\n",
      "        bot.remix()\n",
      "        #bot.remix_mp3 = bot.track_mp3\n",
      "        \n",
      "        # remix title\n",
      "        bot.remix_title = \"%s: %s [autochip rmx]\" % tuple([bot.follower['username'], bot.track.title])\n",
      "        print \"Remix title: \"+bot.remix_title\n",
      "        sys.stdout.flush()\n",
      "        # POST remix\n",
      "        remix = bot.post_remix()\n",
      "        \n",
      "        # delete all the files \n",
      "        print \"deleting tracks\"\n",
      "        !rm {bot.remix_mp3}\n",
      "        !rm {bot.track_mp3}\n",
      "        !rm {bot.remix_track_art}\n",
      "        !rm {bot.remix_user_art}\n",
      "        !rm {bot.user_art}\n",
      "        !rm {bot.track_art}\n",
      "\n",
      "        # follow all the follower's followers\n",
      "        # off  for now\n",
      "        bot.amicabilify(bot.follower['id'])\n",
      "        \n",
      "        # like track\n",
      "        bot.like_track(bot.track)\n",
      "        \n",
      "        # comment on original track\n",
      "        comment_string = bot.comment(bot.remix_track.permalink_url)\n",
      "        print \"Commenting . . . \" + comment_string + \"\\n\"\n",
      "        track_comment = bot.client.post('/tracks/%d/comments' % bot.track.id, comment={\n",
      "            'body': comment_string,\n",
      "            'timestamp': random.randint(0,bot.track.duration-1)\n",
      "        })\n",
      "        \n",
      "        # comment on remix\n",
      "        remix_comment_string = \"Original: \" + bot.track.permalink_url\n",
      "        print \"Commenting . . . \" + remix_comment_string + \"\\n\"\n",
      "        track_comment = bot.client.post('/tracks/%d/comments' % bot.remix_track.id, comment={\n",
      "            'body': remix_comment_string,\n",
      "            'timestamp': 100\n",
      "        })\n",
      "        \n",
      "        # delete old mixes\n",
      "        \n",
      "        \n",
      "        print \"bye\"\n",
      "        return True"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import gc\n",
      "import traceback \n",
      "\n",
      "bot = DadaBot()\t\n",
      "gc.enable()\n",
      "\n",
      "client_id = '***********************'\n",
      "client_secret = '*********************'\n",
      "while True:\n",
      "    print \"Autochiptune remix.\"\n",
      "\n",
      "    tic = time.time()\n",
      "    bot = DadaBot()\t\n",
      "    try:\n",
      "        bot.main()\n",
      "    except:\n",
      "        print \"Unexpected error:\", sys.exc_info() \n",
      "        traceback.print_exc(file=sys.stdout)\n",
      "    \n",
      "    del bot  \n",
      "    toc = time.time()\n",
      "    \n",
      "    print \"sleeping..\"   \n",
      "    sys.stdout.flush()\n",
      "    gc.collect()\n",
      "    #time.sleep(1)  # Delay \n",
      "    time.sleep(10)  #delay \n",
      "    print \"awake.\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Autochiptune remix.\n",
        "hi\n",
        "Initializing soundcloud.Client . . . \n",
        "Searching hillary was here's tracks . . . "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Titles: "
       ]
      }
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}