##

# The main method that does the aligned feature extraction is down the bottom.

# Two thirds of this file, it is called

# def three_feature_sets_on_static_models

##

##

# docker pull russelljarvis/efel_allen_dm

# I build it with the name russelljarvis/efel_allen_dm.

# This uses the docker file in this directory.

# I build it with the name efl.

# and launch it with this alias.

# alias efel='cd /home/russell/outside/neuronunit; sudo docker run -it -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix -v /home/russell/outside/neuronunit:/home/jovyan/neuronunit -v /home/russell/Dropbox\ \(ASU\)/AllenDruckmanData:/home/jovyan/work/allendata efel /bin/bash'

##

##

# This is how my travis script builds and runs:

# before_install:

# - docker pull russelljarvis/efel_allen_dm

# - git clone -b barcelona https://github.com/russelljjarvis/neuronunit.git

#

# Run the unit test

# script:

# show that running the docker container at least works.

# - docker run -v neuronunit:/home/jovyan/neuronunit russelljarvis/efel_allen_dm python /home/jovyan/work/allendata/small_travis_run.py

#

##

from allensdk.ephys.ephys_extractor import EphysSweepSetFeatureExtractor

try:

import cPickle

except:

import _pickle as cPickle

import csv

import json

import os

import re

import shutil

import string

import urllib

import inspect

import numpy as np

from matplotlib import pyplot as plt

import dask.bag as dbag # a pip installable module, usually installs without complication

import dask

import urllib.request, json

import os

import requests

from neo.core import AnalogSignal

from quantities import mV, ms, nA

from neuronunit import models

import pickle

import efel

from types import MethodType

import quantities as pq

import pdb

from collections import Iterable, OrderedDict

import numpy as np

import efel

import pickle

from allensdk.ephys.extract_cell_features import extract_cell_features

import pandas as pd

import matplotlib.pyplot as plt

import ssl

ssl._create_default_https_context = ssl._create_unverified_context

from neuronunit.neuromldb import NeuroMLDBStaticModel

import dm_test_interoperable #import Interoperabe

from dask import bag as db

import glob

def generate_prediction(self,model):

return prediction

'''

def find_nearest(array, value):

#value = float(value)

array = np.asarray(array)

idx = (np.abs(array - value)).argmin()

return (array[idx], idx)

'''

def get_m_p(model,current):

return consolted

def update_static_model_methods(model,lookup):

return model#, tests

#Depreciated

def map_to_sms(tt):

return sms

def standard_nu_tests_two(model):

return nu_preds

def standard_nu_tests(model,lookup):

return nu_preds

def crawl_ids(url):

return Model_IDs

list_to_get =[ str('https://www.neuroml-db.org/api/search?q=traub'),

str('https://www.neuroml-db.org/api/search?q=markram'),

str('https://www.neuroml-db.org/api/search?q=Gouwens') ]

def get_all_cortical_cells(list_to_get):

return model_ids

def find_nearest(array, value):

return (array[idx], idx)

def get_waveform_current_amplitude(waveform):

return float(waveform["Waveform_Label"].replace(" nA", "")) * pq.nA

def get_static_models(cell_id):

return model

def allen_format(volts,times):

return final

def three_feature_sets_on_static_models(model,test_frame = None):

return {'efel':efel_frame,'dm':dm_frame,'allen':allen_frame}

def recoverable_interuptable_batch_process():

cnt+=1

#import numpy as np

def mid_to_model(mid_):

return

def faster_make_model_and_cache():

list(mid_bag.map(mid_to_model).compute())

def model_analysis(model):

return

def analyze_models_from_cache(file_paths):

list(models_bag.map(model_analysis).compute())

def faster_feature_extraction():

_ = analyze_models_from_cache(file_paths)

def more_challenging(model):

return efel_results_inh

def not_necessary_for_program_completion(DMTNMLO):

return

import get_allen_features_from_nml_db as runnable

import glob

#import aligned_feature_extraction as runnable

##

# The slow old way

# better for debugging

# uncomment

# runnable.recoverable_interuptable_batch_process()

##

# The faster way to complete everything when confident

##

runnable.faster_make_model_and_cache()

file_paths = glob.glob("models/*.p")

_ = runnable.analyze_models_from_cache(file_paths)