def __init__(self):
# Creating logger for eman class
self.logger = logging.getLogger('ss.eman')
logger = self.logger
# Starting new logging sessions
logger.info('-' * 50)
logger.info('Starting new logging session %s' % \
datetime.datetime.now().__str__())
# Create Logging directory if it does not exist
logger.info('Checking if logs/ already exists')
if not os.path.exists(logdir):
logger.info('Could not find logs/ Creating...')
os.mkdir(logdir)
# Initialize ParserManager
logger.info('Initializing parsermanager')
self.pman = ParserManager()
# A schedule of scenarios to run
logger.debug('Current Scenario schedule : ')
self.schedule = [(self.run_scenario1, "Chou2006 experiments"),
(self.run_scenario2, "ss_5genes1 experiments")]
logger.debug([t[1] for t in self.schedule])
def __init__(self) :
# Creating logger for eman class
self.logger = logging.getLogger('ss.eman')
logger = self.logger
# Starting new logging sessions
logger.info('-'*50)
logger.info('Starting new logging session %s' % \
datetime.datetime.now().__str__())
# Create Logging directory if it does not exist
logger.info('Checking if logs/ already exists')
if not os.path.exists(logdir) :
logger.info('Could not find logs/ Creating...')
os.mkdir(logdir)
# Initialize ParserManager
logger.info('Initializing parsermanager')
self.pman = ParserManager()
# A schedule of scenarios to run
logger.debug('Current Scenario schedule : ')
self.schedule = [
(self.run_scenario1,"Chou2006 experiments"),
(self.run_scenario2,"ss_5genes1 experiments")
]
logger.debug([t[1] for t in self.schedule])
def read(self):
if not os.path.exists(self.session_file_location):
return []
tempitems = []
config = ConfigParser.ConfigParser()
config.read(self.session_file_location)
section_list = config.sections()
for section in section_list:
try:
index = int(section.strip("session_video_"))
except ValueError as exception:
print >> sys.stderr, "Session \"%s\" has invalid identifier" % section
continue
try:
page_url = config.get(section, "page_url")
youtube_video = parser_manager.validateURL(page_url)
if not youtube_video:
continue
title = config.get(section, "title")
youtube_video.setTitle(title)
real_url = config.get(section, "real_url")
youtube_video.setRealUrl(real_url)
flv_file = config.get(section, "flv_file")
youtube_video.setFlvFile(flv_file)
avi_file = config.get(section, "avi_file")
youtube_video.setOutputFile(avi_file)
file_format = config.getint(section, "file_format")
youtube_video.setFileFormat(file_format)
output_res = config.getint(section, "output_res")
youtube_video.setOutputRes(output_res)
embed_file_type = config.get(section, "embed_file_type")
youtube_video.parser.setEmbedType(embed_file_type)
file_size = config.getint(section, "file_size")
youtube_video.setFileSize(file_size)
status = config.getint(section, "status")
tempitems.append([index, SessionItem(youtube_video, status)])
except (ConfigParser.NoOptionError, TypeError) as exception:
print >> sys.stderr, "%s: %s" % (exception.__class__.__name__,
exception)
continue
tempitems.sort(lambda x, y: x[0] - y[0])
items = []
for item in tempitems:
items.append(item[1])
return items
def read (self):
if not os.path.exists (self.session_file_location):
return []
tempitems = []
config = ConfigParser.ConfigParser ()
config.read (self.session_file_location)
section_list = config.sections ()
for section in section_list:
try:
index = int (section.strip ("session_video_"))
except ValueError as exception:
print >> sys.stderr, "Session \"%s\" has invalid identifier" % section
continue
try:
page_url = config.get (section, "page_url")
youtube_video = parser_manager.validateURL (page_url)
if not youtube_video:
continue
title = config.get (section, "title")
youtube_video.setTitle (title)
real_url = config.get (section, "real_url")
youtube_video.setRealUrl (real_url)
flv_file = config.get (section, "flv_file")
youtube_video.setFlvFile (flv_file)
avi_file = config.get (section, "avi_file")
youtube_video.setOutputFile (avi_file)
file_format = config.getint (section, "file_format")
youtube_video.setFileFormat (file_format)
output_res = config.getint (section, "output_res")
youtube_video.setOutputRes (output_res)
embed_file_type = config.get (section, "embed_file_type")
youtube_video.parser.setEmbedType (embed_file_type)
file_size = config.getint (section, "file_size")
youtube_video.setFileSize (file_size)
status = config.getint (section, "status")
tempitems.append ([index, SessionItem (youtube_video, status)])
except (ConfigParser.NoOptionError, TypeError) as exception:
print >> sys.stderr, "%s: %s" % (exception.__class__.__name__, exception)
continue
tempitems.sort (lambda x, y: x[0]-y[0])
items = []
for item in tempitems:
items.append (item[1])
return items
def getVideoInformation(self, account="", password=""):
if not isinstance(account, str) or not isinstance(password, str):
raise TypeError("Username and password arguments must be strings")
page = newurl = ""
# VERY primitive video portal support
if self.parser.is_portal:
# Get initial video page
if account or password:
page, newurl = self.parser.getVideoPage(account, password)
else:
page, newurl = self.parser.getVideoPage()
# If no data was passed, assume that the portal is forwarding to a new site
if not page:
# Check if the portal forwarded to a site that is supported
from parsermanager import ParserManager as parser_manager
parser = parser_manager.validateURL(newurl, False)
if not parser:
raise self.parser.InvalidPortal(
"The portal forwarded to a site not supported by this application"
)
# Check if the parser has changed by checking the page urls
elif self.parser.page_url != parser.page_url:
self.parser = parser
# Get real video page data
if account or password:
page, newurl = self.parser.getVideoPage(account, password)
else:
page, newurl = self.parser.getVideoPage()
elif account or password:
page, newurl = self.parser.getVideoPage(account, password)
else:
page, newurl = self.parser.getVideoPage()
title, download_url, headers = self.parser.parseVideoPage(page)
self.setTitle(title)
self.real_url = download_url
if headers.get("Content-Length"):
self.input_file_size = long(headers.get("Content-Length"))
return True
def getVideoInformation (self, account="", password=""):
if not isinstance (account, str) or not isinstance (password, str):
raise TypeError ("Username and password arguments must be strings")
page = newurl = ""
# VERY primitive video portal support
if self.parser.is_portal:
# Get initial video page
if account or password:
page, newurl = self.parser.getVideoPage (account, password)
else:
page, newurl = self.parser.getVideoPage ()
# If no data was passed, assume that the portal is forwarding to a new site
if not page:
# Check if the portal forwarded to a site that is supported
from parsermanager import ParserManager as parser_manager
parser = parser_manager.validateURL (newurl, False)
if not parser:
raise self.parser.InvalidPortal ("The portal forwarded to a site not supported by this application")
# Check if the parser has changed by checking the page urls
elif self.parser.page_url != parser.page_url:
self.parser = parser
# Get real video page data
if account or password:
page, newurl = self.parser.getVideoPage (account, password)
else:
page, newurl = self.parser.getVideoPage ()
elif account or password:
page, newurl = self.parser.getVideoPage (account, password)
else:
page, newurl = self.parser.getVideoPage ()
title, download_url, headers = self.parser.parseVideoPage (page)
self.setTitle (title)
self.real_url = download_url
if headers.get ("Content-Length"):
self.input_file_size = long (headers.get ("Content-Length"))
return True
ss_copy.experiments = [exp]
yield ss_copy
class ARParams(object):
""" This object stores the AR params currently in use"""
def __init__(self, Cp, Cd, Lp, Ld, b, h, g, a, bd, bp, slopes):
self.Cp = Cp
self.Cd = Cd
self.Lp = Lp
self.Ld = Ld
self.b = b
self.h = h
self.g = g
self.a = a
self.bd = bd
self.bp = bp
self.slopes = slopes
if __name__ == '__main__':
pman = ParserManager()
for ii, ss in enumerate(pman.get_gen_chou2006()):
# Run Alternating Regression and the result
# Extract each individual ss and execute it
for expid, ss_exp in enumerate(_exp_splayer(ss)):
print("Running ss: %s mod: %d exp: %d" % (ss.name, ii, expid))
ar = ARSolver(ss_exp)
result_exp = ar.solve(save_trace=True, maxiter=10000, tol=10e-5)
#result_exp = ar.solve()
class ExperimentManager(object):
""" Class for managing all experiments """
def __init__(self):
# Creating logger for eman class
self.logger = logging.getLogger('ss.eman')
logger = self.logger
# Starting new logging sessions
logger.info('-' * 50)
logger.info('Starting new logging session %s' % \
datetime.datetime.now().__str__())
# Create Logging directory if it does not exist
logger.info('Checking if logs/ already exists')
if not os.path.exists(logdir):
logger.info('Could not find logs/ Creating...')
os.mkdir(logdir)
# Initialize ParserManager
logger.info('Initializing parsermanager')
self.pman = ParserManager()
# A schedule of scenarios to run
logger.debug('Current Scenario schedule : ')
self.schedule = [(self.run_scenario1, "Chou2006 experiments"),
(self.run_scenario2, "ss_5genes1 experiments")]
logger.debug([t[1] for t in self.schedule])
def run_scenario1(self):
""" Runs experiments for Chou2006"""
logger = logging.getLogger('ss.eman.sc1')
results_list = []
for ii, ss in enumerate(self.pman.get_gen_chou2006()):
logger.info("Running ss: %s mod: %d" % (ss.name, ii))
# Extract each individual ss and execute it
for expid, ss_exp in enumerate(self._exp_splayer(ss)):
logger.info("Running ss: %s mod: %d exp: %d" %
(ss.name, ii, expid))
res_ar = None # Placeholder for method call
results_list.append(Result(ss, res_ar))
res = ResultsScenario(results_list)
logger.info('Scenario1 Terminated')
def run_scenario2(self):
""" Runs experiments for ss_5genes1"""
logger = logging.getLogger('ss.eman.sc2')
results_list = []
for ii, ss in enumerate(self.pman.get_gen_5genes1()):
logger.info("Running ss: %s mod: %d" % (ss.name, ii))
# Extract each individual ss and execute it
for expid, ss_exp in enumerate(self._exp_splayer(ss)):
logger.info("Running ss: %s mod: %d exp: %d" %
(ss.name, ii, expid))
res_ar = None # Placeholder for method call
results_list.append(Result(ss, res_ar))
res = ResultsScenario(results_list)
logger.info('Scenario2 terminated')
def run_scenario3(self):
""" Runs all experiments in all s-systems"""
logger = logging.getLogger('ss.eman.sc3')
logger.info('Running all ssystems and modifications')
def _exp_splayer(self, ss):
""" Splays the experiments and packs them into a new ss"""
exp_list = ss.experiments
for exp in exp_list:
ss_copy = copy.copy(ss) # create a copy of original ss
ss_copy.experiments = [exp]
yield ss_copy
def set_params(self, **args):
""" Sets params of the Experiment Manager Class"""
self.logger.info('Setting eman params')
pass
def start(self):
""" Starts execution of Experiment Engine"""
# Some place for Tkinter GUI code initialization etc..
logger = logging.getLogger('ss.eman.start')
logger.info('Starting execution of scenarios')
# Execute all scenarios in schedule
for scenario in self.schedule:
run_scenario, description = scenario
logger.info('Running scenario ' + description)
run_scenario()
# Some code for storing results ???
# or let scenarios handle it themselves ?
logger.info('Schedule terminated')
sys.exit(1)
def _exp_splayer(ss) :
""" Splays the experiments and packs them into a new ss"""
exp_list = ss.experiments
for exp in exp_list :
ss_copy = copy.copy(ss) # create a copy of original ss
ss_copy.experiments = [exp]
yield ss_copy
class ALRTracker(ARTracker) :
""" Tracker for ALR class a child of ARTracker class"""
def __init__(self,ar,eqn,save_trace=False,\
maxiter=10000,tol=10e-6,**kwargs) :
super(ALRTracker,self).__init__(ar,eqn,save_trace,\
maxiter,tol,**kwargs)
if __name__ == '__main__' :
pman = ParserManager()
for ii,ss in enumerate(pman.get_gen_chou2006()) :
# Run Alternating Regression and the result
# Extract each individual ss and execute it
for expid,ss_exp in enumerate(_exp_splayer(ss)) :
print("Running ss: %s mod: %d exp: %d"%
(ss.name,ii,expid))
alr = ALRSolver(ss_exp)
result_exp = alr.solve(l1penalty=0.0,maxiter=10000,tol=10e-6)
#result_exp = alr.solve()
class ExperimentManager(object) :
""" Class for managing all experiments """
def __init__(self) :
# Creating logger for eman class
self.logger = logging.getLogger('ss.eman')
logger = self.logger
# Starting new logging sessions
logger.info('-'*50)
logger.info('Starting new logging session %s' % \
datetime.datetime.now().__str__())
# Create Logging directory if it does not exist
logger.info('Checking if logs/ already exists')
if not os.path.exists(logdir) :
logger.info('Could not find logs/ Creating...')
os.mkdir(logdir)
# Initialize ParserManager
logger.info('Initializing parsermanager')
self.pman = ParserManager()
# A schedule of scenarios to run
logger.debug('Current Scenario schedule : ')
self.schedule = [
(self.run_scenario1,"Chou2006 experiments"),
(self.run_scenario2,"ss_5genes1 experiments")
]
logger.debug([t[1] for t in self.schedule])
def run_scenario1(self) :
""" Runs experiments for Chou2006"""
logger = logging.getLogger('ss.eman.sc1')
results_list = []
for ii,ss in enumerate(self.pman.get_gen_chou2006()) :
logger.info("Running ss: %s mod: %d" %(ss.name,ii))
# Extract each individual ss and execute it
for expid,ss_exp in enumerate(self._exp_splayer(ss)) :
logger.info("Running ss: %s mod: %d exp: %d"%
(ss.name,ii,expid))
res_ar = None # Placeholder for method call
results_list.append(Result(ss,res_ar))
res = ResultsScenario(results_list)
logger.info('Scenario1 Terminated')
def run_scenario2(self) :
""" Runs experiments for ss_5genes1"""
logger = logging.getLogger('ss.eman.sc2')
results_list = []
for ii,ss in enumerate(self.pman.get_gen_5genes1()) :
logger.info("Running ss: %s mod: %d" % (ss.name,ii))
# Extract each individual ss and execute it
for expid,ss_exp in enumerate(self._exp_splayer(ss)) :
logger.info("Running ss: %s mod: %d exp: %d"%
(ss.name,ii,expid))
res_ar = None # Placeholder for method call
results_list.append(Result(ss,res_ar))
res = ResultsScenario(results_list)
logger.info('Scenario2 terminated')
def run_scenario3(self) :
""" Runs all experiments in all s-systems"""
logger = logging.getLogger('ss.eman.sc3')
logger.info('Running all ssystems and modifications')
def _exp_splayer(self,ss) :
""" Splays the experiments and packs them into a new ss"""
exp_list = ss.experiments
for exp in exp_list :
ss_copy = copy.copy(ss) # create a copy of original ss
ss_copy.experiments = [exp]
yield ss_copy
def set_params(self,**args) :
""" Sets params of the Experiment Manager Class"""
self.logger.info('Setting eman params')
pass
def start(self) :
""" Starts execution of Experiment Engine"""
# Some place for Tkinter GUI code initialization etc..
logger = logging.getLogger('ss.eman.start')
logger.info('Starting execution of scenarios')
# Execute all scenarios in schedule
for scenario in self.schedule :
run_scenario,description = scenario
logger.info('Running scenario '+description)
run_scenario()
# Some code for storing results ???
# or let scenarios handle it themselves ?
logger.info('Schedule terminated')
