def read_dual_scene(conf_fname):
"""
Read dual-scene parameters, such as unchanging particle properties and
frame range. Values are stored in an INI-format file.
Arguments:
conf_fname - name of the config file
Returns:
a DualScene object initialized with the configuration values found.
"""
parser = SafeConfigParser()
parser.read(conf_fname)
particle = Particle(
parser.getfloat("Particle", "diameter"),
parser.getfloat("Particle", "density"))
frate = parser.getfloat("Scene", "frame rate")
tracer_file = parser.get("Scene", "tracers file")
part_file = parser.get("Scene", "particles file")
frange = (parser.getint("Scene", "first frame"),
parser.getint("Scene", "last frame") + 1)
return DualScene(tracer_file, part_file, frate, particle, frange)
def load_settings(self):
self.default_settings()
if not os.path.isfile(self.config_file_name):
return
config = SafeConfigParser()
config.read(self.config_file_name)
self.input_directory = config.get('main', 'input_directory').decode('utf-8')
self.output_directory = config.get('main', 'output_directory').decode('utf-8')
self.video_width = config.getint('main', 'video_width')
self.video_height = config.getint('main', 'video_height')
self.shift_start = config.getfloat('main', 'pad_start')
self.shift_end = config.getfloat('main', 'pad_end')
self.time_delta = config.getfloat('main', 'gap_between_phrases')
self.is_split_long_phrases = config.getboolean('main', 'is_split_long_phrases')
self.phrases_duration_limit = config.getint('main', 'phrases_duration_limit')
self.mode = config.get('main', 'mode')
self.is_write_output_subtitles = config.getboolean('main', 'is_write_output_subtitles')
self.is_ignore_sdh_subtitle = config.getboolean('main', 'is_ignore_sdh_subtitle')
self.is_add_dir_to_media_path = config.getboolean('main', 'is_add_dir_to_media_path')
value = [e.strip() for e in config.get('main', 'recent_deck_names').decode('utf-8').split(',')]
if len(value) != 0:
self.recent_deck_names.extendleft(value)
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
self.parser = parser
self.workspace = parser.get("basic", "workspace")
#result path
self.net_name = parser.get('basic', 'net_name')
self.nm_res = os.path.basename(self.workspace.rstrip(
os.sep)) + '_result'
self.path_res = os.path.join(self.workspace, self.nm_res,
self.net_name)
#for test set
self.annot = parser.get(self.test_set, 'annot')
self.data = parser.get(self.test_set, 'data')
self.mre_thre = parser.getfloat(self.test_set, 'mre_thre')
self.is_src_img = parser.getboolean(self.test_set, 'is_src_img')
self.is_mean_value = parser.getboolean(self.test_set, 'is_mean_value')
if parser.has_option(self.test_set, 'scale'):
self.scale = parser.getfloat(self.test_set, 'scale')
else:
self.scale = 0.0078125
if parser.has_option(self.test_set, 'mean_value'):
self.mean_value = parser.get(self.test_set, 'mean_value')
else:
self.mean_value = '127.5 127.5 127.5'
self.is_test_half = parser.getboolean(self.test_set, 'is_test_half')
self.is_test_roi = parser.getboolean(self.test_set, 'is_test_roi')
self.is_save_dmap = parser.getboolean(self.test_set, 'is_save_dmap')
nm_file = self.test_set
self.nm_py = 'eval.py'
self.end_file = os.path.join(self.path_res, nm_file)
def getCanvas(name = "c1", ratio = False, colz = False):
"""
Function for generation a TCanvas object.
Parameters:
-----------
name : string
Name of the canvas
ratio : bool
If True, the functions returns TCanvas with to pads. Pad 1 for
the plot and Pad 2 for the ratio
"""
logging.debug("Creating canvas with name {0}".format(name))
styleconfig = SafeConfigParser()
#logging.debug("Loading style config")
styleconfig.read("config/plotting.cfg")
cwidth = styleconfig.getint("Canvas","width")
cheight = styleconfig.getint("Canvas","height")
canvas = ROOT.TCanvas(name, name, cwidth, cheight)
margins = [ styleconfig.getfloat("Canvas","topmargin"),
styleconfig.getfloat("Canvas","rightmargin"),
styleconfig.getfloat("Canvas","leftmargin"),
styleconfig.getfloat("Canvas","bottommargin") ]
if not ratio:
logging.debug("Setting up single canvas")
canvas.SetTopMargin(margins[0])
if colz:
logging.debug("setting right border for 2D plot")
canvas.SetRightMargin(margins[1]+0.075)
else:
canvas.SetRightMargin(margins[1])
canvas.SetLeftMargin(margins[2])
canvas.SetBottomMargin(margins[3])
else:
logging.debug("Setting up canvas with ratioplots")
canvas.Divide(1,2)
canvas.cd(1).SetPad(0.,0.3-0.02,1.0,0.983)
canvas.cd(2).SetPad(0.,0.0,1.0,0.3*(1-0.02))
canvas.cd(1).SetBottomMargin(0.02)
canvas.cd(2).SetTopMargin(0.00)
canvas.cd(1).SetTopMargin(margins[0])
canvas.cd(2).SetBottomMargin(margins[3]*(1/0.3))
canvas.cd(1).SetRightMargin(margins[1])
canvas.cd(1).SetLeftMargin(margins[2])
canvas.cd(2).SetRightMargin(margins[1])
canvas.cd(2).SetLeftMargin(margins[2])
canvas.cd(2).SetTicks(1,1)
canvas.cd(1).SetTicks(1,1)
canvas.cd(2).SetFillStyle(0)
canvas.cd(1).SetFillStyle(0)
canvas.cd(2).SetFillColor(0)
canvas.cd(2).SetFrameFillStyle(4000)
return canvas
def read_sequence(conf_fname, smooth=False):
"""
Read sequence-wide parameters, such as unchanging particle properties and
frame range. Values are stored in an INI-format file.
Arguments:
conf_fname - name of the config file
smooth - whether the sequence shoud use tracers trajectory-smoothing.
Returns:
a Sequence object initialized with the configuration values found.
"""
parser = SafeConfigParser()
parser.read(conf_fname)
particle = Particle(
parser.getfloat("Particle", "diameter"),
parser.getfloat("Particle", "density"))
frate = parser.getfloat("Scene", "frame rate")
tracer_tmpl = parser.get("Scene", "tracers file")
part_tmpl = parser.get("Scene", "particles file")
frange = (parser.getint("Scene", "first frame"),
parser.getint("Scene", "last frame") + 1)
return Sequence(frange, frate, particle, part_tmpl, tracer_tmpl, smooth)
def __init__(self):
"""parameters from parameters.ini"""
parser = SafeConfigParser()
parser.read(configfile)
self.mog2History = parser.getint('PeopleCounting', 'mog2History')
self.mog2VarThrsh = parser.getint('PeopleCounting', 'mog2VarThrsh')
self.mog2Shadow = parser.getboolean('PeopleCounting', 'mog2Shadow')
self.mog2LearningRate = parser.getfloat('PeopleCounting', 'mog2LearningRate')
self.kernelSize = parser.getint('PeopleCounting', 'kernelSize')
self.scale = parser.getfloat('PeopleCounting', 'scale')
self.areaThreshold = math.pi * parser.getfloat('PeopleCounting', 'areaRadius')**2
self.peopleBlobSize = parser.getint('PeopleCounting', 'peopleBlobSize')
self.distThreshold = parser.getint('PeopleCounting', 'distThreshold')
self.countingRegion = map(int, parser.get('PeopleCounting', 'countingRegion').split(','))
self.upperTrackingRegion = map(int, parser.get('PeopleCounting', 'upperTrackingRegion').split(','))
self.lowerTrackingRegion = map(int, parser.get('PeopleCounting', 'lowerTrackingRegion').split(','))
self.inactiveThreshold = parser.getint('PeopleCounting', 'inactiveThreshold')
# self.singlePersonBlobSize = parser.getint('PeopleCounting', 'singlePersonBlobSize')
self.Debug = parser.getboolean('PeopleCounting', 'Debug')
self.Visualize = parser.getboolean('PeopleCounting', 'Visualize') or self.Debug
self.useRatioCriteria = parser.getboolean('PeopleCounting', 'useRatioCriteria')
self.RTSPurl = parser.get('PeopleCounting','RTSPurl')
self.RTSPframerate = parser.getint('PeopleCounting','RTSPframerate')
"""ASSUMPTION: ppl entering door walk downards(direction = 1) in the video"""
self.store_id = parser.getint('store', 'store_id')
self.camera_id = parser.getint('store', 'camera_id')
self.ipc_username = parser.get('store', 'ipc_username')
self.ipc_password = parser.get('store', 'ipc_password')
self.wl_dev_cam_id = parser.get('store', 'wl_dev_cam_id')
def getLabel(text, xstart, pos="top", scale=1):
if pos in ["top", "topSup", "under"]:
postouse = pos
elif isinstance(pos, float) or isinstance(pos, int):
postouse = float(pos)
else:
logging.warning(
"Position parameter required in {0} or of type float/int".format(
["top", "topSup", "under"]))
logging.warning("Falling back to top position")
postouse = "top"
styleconfig = SafeConfigParser()
styleconfig.read("config/plotting.cfg")
if pos == "top":
ystart = styleconfig.getfloat("GeneralLabel", "topPos")
elif pos == "topSup":
ystart = styleconfig.getfloat("GeneralLabel", "topSupPos")
scale = scale * styleconfig.getfloat("GeneralLabel", "topSupScale")
else:
ystart = styleconfig.getfloat("GeneralLabel", "underPos")
label = ROOT.TLatex(xstart, ystart,
'#scale[' + str(scale) + ']{' + text + '}')
label.SetTextFont(42)
label.SetTextSize(styleconfig.getfloat("CMSLabel", "textsize"))
label.SetNDC()
return label
def parse_config():
'''parse_config() -> (toth, inicio, timestamp)
toth -> int
inicio -> int
timestamp -> datetime.date
Analisa o arquivo em CONFIG e retorna o total de horas disponíveis, o dia da
semana de início da contagem (no formato ISO) e a data do último crédito de
horas, além de instanciar as atividades.'''
parser = SafeConfigParser()
try:
parser.readfp(codecs.open(CONFIG, 'r', ENCODING))
except IOError:
raise ArquivoError('Nenhum arquivo de configuração encontrado.')
try:
toth = parser.getint(HEADER, 'disponivel')
inicio = parser.getint(HEADER, 'inicio')
timestamp = parser.getint(HEADER, 'timestamp')
if timestamp:
ano, timestamp = divmod(timestamp, 10000)
mes, dia = divmod(timestamp, 100)
timestamp = datetime.date(ano, mes, dia)
for a in parser.sections():
if a != HEADER:
kwargs = {'nome':a, 'pts':parser.getfloat(a, 'pts'),
'saldo':parser.getfloat(a, 'saldo')}
Atividade(**kwargs)
except (TypeError, NoSectionError):
raise ArquivoError('Arquivo de configuração corrompido.')
return (toth, inicio, timestamp)
def read_sequence(conf_fname, smooth=None, traj_min_len=None):
"""
Read sequence-wide parameters, such as unchanging particle properties and
frame range. Values are stored in an INI-format file.
Arguments:
conf_fname - name of the config file
smooth - whether the sequence shoud use tracers trajectory-smoothing. Used
to override the config value if present, and supply it if missing. If
None and missing, default is False.
traj_min_len - tells the sequence to ignore trajectories shorter than this
many frames. Overrides file. If None and file has no value, default is
0.
Returns:
a Sequence object initialized with the configuration values found.
"""
parser = SafeConfigParser()
parser.read(conf_fname)
particle = Particle(
parser.getfloat("Particle", "diameter"),
parser.getfloat("Particle", "density"))
frate = parser.getfloat("Scene", "frame rate")
tracer_tmpl = parser.get("Scene", "tracers file")
part_tmpl = parser.get("Scene", "particles file")
frange = (parser.getint("Scene", "first frame"),
parser.getint("Scene", "last frame") + 1)
# The smoothing option is subject to default/override rules.
if parser.has_option("Scene", "apply smoothing"):
if smooth is None:
smooth = parser.getboolean("Scene", "apply smoothing")
else:
if smooth is None:
smooth = False
# Same goes for traj_min_len
if parser.has_option("Scene", "trajectory minimal length"):
if traj_min_len is None:
traj_min_len = parser.getint("Scene", "trajectory minimal length")
else:
if traj_min_len is None:
traj_min_len = 0
return Sequence(frange, frate, particle, part_tmpl, tracer_tmpl, smooth,
traj_min_len)
def new_ship(self, name):
config = SafeConfigParser()
config.read("./assets/sprites/ships/" + name + ".ini")
self.speed = config.getfloat("main", "speed")
self.create_images(name)
self.img = self.playerup
self.select_picture()
def getfloat(self, *args, **kwds): """ Locked getfloat() method. """ value = SafeConfigParser.getfloat(self, *args, **kwds) return float(value)
def get_setting(self, setting, setting_type=basestring):
"""
Returns a specified setting from etc/config.ini.
Parameters
----------
setting : basestring
the key of the setting to return under the [interfaces.{__interface_name__}] section
setting_type : type
[optional] the data type for the setting e.g. int or bool. default is basestring.
Returns
-------
basestring
string value of the setting
"""
path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..',
'etc', 'config.ini')
parser = SafeConfigParser()
parser.read(path)
section = 'interfaces.{}'.format(self.__interface_name__)
# return setting value using the specified setting_type
if setting_type is int:
return parser.getint(section, setting)
elif setting_type is bool:
return parser.getboolean(section, setting)
elif setting_type is float:
return parser.getfloat(section, setting)
else:
return parser.get(section, setting)
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.user_plda = '%s/data/user/user.plda' % root
self.mu = parser.getfloat("basic", "mu")
class Configuration:
"""
Parsing system conf args
"""
PROFILE_KEYS = [
"role", "host", "port", "queue",
"username", "password", "timeout",
]
def __init__(self, conf_path):
self.conf_path = conf_path if conf_path is not None else DEFAULT_CONF_PATH
self.parser = SafeConfigParser()
self.parser.read(self.conf_path)
def debug(self):
return self.parser.getboolean("default", "debug")
def window_time(self):
return self.parser.getfloat("default", "window_time")
def save_path(self):
return self.parser.get("default", "save_path")
def rabbit_profile(self):
profiles = {
key: self.parser.get(
"rabbit_messaging",
key
) for key in self.PROFILE_KEYS
}
return profiles
class MilightConfig():
def __init__(self):
app_path = os.path.dirname(os.path.realpath(__file__))
self.configfile = app_path + "/config.ini"
self.config = SafeConfigParser()
self.config.read( self.configfile )
self.milight_hostname = self.config.get('MILIGHT','hostname')
self.milight_port = self.config.getint('MILIGHT','port')
self.pixel_interval = self.config.getint('CPU_OPTMIZATION', 'pixel_interval') # interval between pixels
self.time_interval = self.config.getfloat('CPU_OPTMIZATION', 'time_interval') # time interval
self.debug = self.config.getboolean('CPU_OPTMIZATION', 'debug') # show color
def save_config(self):
self.config = SafeConfigParser()
self.config.add_section('MILIGHT')
self.config.set('MILIGHT', 'hostname', self.milight_hostname )
self.config.set('MILIGHT', 'port', str( int(self.milight_port) ) )
self.config.add_section('CPU_OPTMIZATION')
self.config.set('CPU_OPTMIZATION', 'pixel_interval', str( int(self.pixel_interval) ) )
self.config.set('CPU_OPTMIZATION', 'time_interval', str(self.time_interval) )
self.config.set('CPU_OPTMIZATION', 'debug', str(self.debug) )
with open(self.configfile, 'wb') as configfile:
self.config.write(configfile)
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.train_fraction = parser.getfloat("plda+", "train_fraction")
self.sample_training = '%s/data/train/paper.sampled.sf' % root
def __init__(self, args):
'''
:return:
'''
parser = SafeConfigParser()
parser.read(args.config)
self.corpusfile = parser.get('file', 'corpus')
self.dbfile = parser.get('file', 'db')
self.semidictfile = parser.get('file', 'semidict')
self.ontologyfile = parser.get('file', 'ontology')
self.split = literal_eval(parser.get('data', 'split'))
self.lengthen = parser.getint('data', 'lengthen')
self.percent = parser.get('data', 'percent')
self.shuffle = parser.get('data', 'shuffle')
self.trk_enc = parser.get('trk', 'trkenc')
self.verbose = parser.getint('gen', 'verbose')
self.mode = args.mode
self.policy = parser.get('ply', 'policy')
self.latent = parser.getint('ply',
'latent') if self.policy == 'latent' else 0
self.topk = parser.getint('gen', 'topk')
self.beamwidth = parser.getint('gen', 'beamwidth')
self.repeat_penalty = parser.get('gen', 'repeat_penalty')
self.token_reward = parser.getboolean('gen', 'token_reward')
self.alpha = parser.getfloat('gen', 'alpha')
def __init__(self, config=None, opts=None):
# not enough info to execute
if config == None and opts == None:
print("Please specify command option or config file ...")
return
# config parser
parser = SafeConfigParser()
parser.read(config)
self.debug = parser.getboolean('knn', 'debug')
self.seed = parser.getint('knn', 'random_seed')
self.obj = 'dt'
self.trainfile = parser.get('knn', 'train')
self.validfile = parser.get('knn', 'valid')
self.testfile = parser.get('knn', 'test')
self.vocabfile = parser.get('knn', 'vocab')
self.domain = parser.get('knn', 'domain')
self.percentage = float(parser.getfloat('knn', 'percentage')) / 100.0
# Setting generation specific parameters
self.topk = parser.getint('knn', 'topk')
self.detectpairs = parser.get('knn', 'detectpairs')
self.verbose = parser.getint('knn', 'verbose')
# set random seed
np.random.seed(self.seed)
random.seed(self.seed)
np.set_printoptions(precision=4)
# setting data reader, processors, and lexicon
self.setup_side_operators()
def load_config(self):
config = SafeConfigParser()
config.read(self.config_file)
print "Reading from config file: " + self.config_file
# Camera config
self.camera_ISO = config.getint('camera', 'ISO')
self.camera_shutter_speed = config.get('camera', 'shutter_speed')
# Capture config
self.capture_duration = config.getfloat('capture', 'duration')
self.capture_interval = config.getint('capture', 'interval')
self.output_dir = config.get('capture', 'output_dir')
self.capture_sequence_name = config.get('capture', 'sequence_name')
self.resolution = config.get('capture', 'resolution')
self.verbose = config.getboolean('capture', 'verbose')
self.crop_enabled = config.getboolean('capture', 'crop_enabled')
crop_string = config.get('capture', 'crop')
self.crop = tuple([float(n) for n in crop_string.split(",")])
# Pi config
self.pi_GPIO_light_channel = config.getint('pi', 'GPIO_light_channel')
class MilightConfig():
def __init__(self):
app_path = os.path.dirname(os.path.realpath(__file__))
self.configfile = app_path + "/config.ini"
self.config = SafeConfigParser()
self.config.read(self.configfile)
self.milight_hostname = self.config.get('MILIGHT', 'hostname')
self.milight_port = self.config.getint('MILIGHT', 'port')
self.pixel_interval = self.config.getint(
'CPU_OPTMIZATION', 'pixel_interval') # interval between pixels
self.time_interval = self.config.getfloat(
'CPU_OPTMIZATION', 'time_interval') # time interval
self.debug = self.config.getboolean('CPU_OPTMIZATION',
'debug') # show color
def save_config(self):
self.config = SafeConfigParser()
self.config.add_section('MILIGHT')
self.config.set('MILIGHT', 'hostname', self.milight_hostname)
self.config.set('MILIGHT', 'port', str(int(self.milight_port)))
self.config.add_section('CPU_OPTMIZATION')
self.config.set('CPU_OPTMIZATION', 'pixel_interval',
str(int(self.pixel_interval)))
self.config.set('CPU_OPTMIZATION', 'time_interval',
str(self.time_interval))
self.config.set('CPU_OPTMIZATION', 'debug', str(self.debug))
with open(self.configfile, 'wb') as configfile:
self.config.write(configfile)
def __init__(self, fn):
defaults = {
'title': 'Geoflow',
'listen_address': 'localhost',
'listen_port': 8082,
'logfile': 'geoflow.log',
'smtp_server_addr': '',
'email_source': '*****@*****.**',
'email_dests': 'root@localhost',
'scale_factor': 30.0,
'circles_quantity': 300,
'ip_list_source': 'demo',
'ip_list_format': 'ip_addr',
'ip_list_update_interval': 30,
'ip_list_filename': '',
'ip_list_url': '',
'ip_list_netflow_filename': '/var/cache/nfdump/',
'ip_list_netflow_address': 'source',
'ip_list_netflow_weight': 'none',
'drop_perc_threshold': 5,
'drop_abs_threshold': 15,
}
#TODO: validate strings from the .ini file ---> fmt = "-ofmt:%" + conf.ip_list_netflow_address
self.__slots__ = defaults.keys()
config = SafeConfigParser(defaults)
config.read(fn)
for name, default in defaults.iteritems():
if type(default) == int:
self.__dict__[name] = config.getint('global', name)
elif type(default) == float:
self.__dict__[name] = config.getfloat('global', name)
else:
self.__dict__[name] = config.get('global', name)
def load(self, cluster_files):
parser = SafeConfigParser(defaults=dict(core='', strict_order=None, max_insertions='0', min_coverage='0.1'))
try: parser.read(cluster_files)
except ConfigError as e:
print 'Error while parsing cluster configuration:\n%s' % str(e)
return False
self.clusters = []
for name in parser.sections():
try: full = parser.get(name, 'full')
except ConfigError:
print 'No "full" value in %s cluster definition.' % name
continue
try:
core = parser.get(name, 'core')
strict_order = parser.get(name, 'strict_order') is not None
max_insertions = parser.getint(name, 'max_insertions')
min_coverage = parser.getfloat(name, 'min_coverage')
except (ConfigError, ValueError) as e:
print '%s cluster definition is malformed:\n%s' % (name, str(e))
continue
self.clusters.append(ClusterDef(name, full, core, strict_order, max_insertions, min_coverage))
if not self.clusters:
print 'No cluster definitions were loaded from provided files.'
return False
return True
def config():
global settings
config = SafeConfigParser()
config.read(CONFIG_FILE)
settings['main'] = {}
settings['main']['update_interval'] = config.getint('main','update_interval')
settings['servos'] = {}
servo_settings = {'tilt_gpio':int, 'pan_gpio':int, 'servo_frequency':float,
'low_width':float, 'high_width':float,
'pan_left_limit':float, 'pan_right_limit':float,
'tilt_top_limit':float, 'tilt_bottom_limit':float,
'min_servo_speed':float, 'max_servo_speed':float}
for (key,key_type) in servo_settings.items():
if key_type == int:
settings['servos'][key] = config.getint('servos',key)
elif key_type == float:
settings['servos'][key] = config.getfloat('servos',key)
else:
print "Unknown key type: "+str(key_type)
settings['lasers'] = {}
settings['lasers']['laser1_gpio'] = config.getint('lasers','laser1_gpio')
settings['lasers']['laser2_gpio'] = config.getint('lasers','laser2_gpio')
config_servos()
def __init__(self, fn):
defaults = {
'title': 'Logaar',
'listen_address': 'localhost',
'listen_port': 8088,
'syslog_address': '0.0.0.0',
'syslog_udp_port': 5514,
'syslog_tcp_port': 5514,
'db_host': 'localhost',
'logfile': 'logaar.log',
'data_dir': '/var/lib/logaar',
'demo_mode': False,
'smtp_server_addr': '',
'email_source': '*****@*****.**',
'email_dests': 'root@localhost',
'public_url': None
}
self.__slots__ = defaults.keys()
config = SafeConfigParser(defaults)
config.read(fn)
for name, default in defaults.iteritems():
if type(default) == int:
self.__dict__[name] = config.getint('global', name)
elif type(default) == float:
self.__dict__[name] = config.getfloat('global', name)
else:
self.__dict__[name] = config.get('global', name)
def __init__(self,config=None,opts=None):
# not enough info to execute
if config==None and opts==None:
print "Please specify command option or config file ..."
return
# config parser
parser = SafeConfigParser()
parser.read(config)
self.debug = parser.getboolean('knn','debug')
self.seed = parser.getint('knn','random_seed')
self.obj = 'dt'
self.trainfile = parser.get('knn','train')
self.validfile = parser.get('knn','valid')
self.testfile = parser.get('knn','test')
self.vocabfile = parser.get('knn','vocab')
self.domain = parser.get('knn','domain')
self.percentage = float(parser.getfloat('knn','percentage'))/100.0
# Setting generation specific parameters
self.topk = parser.getint('knn','topk')
self.detectpairs= parser.get('knn','detectpairs')
self.verbose = parser.getint('knn','verbose')
# set random seed
np.random.seed(self.seed)
random.seed(self.seed)
np.set_printoptions(precision=4)
# setting data reader, processors, and lexicon
self.setupSideOperators()
def read_frame_data(conf_fname):
"""
Read a configuration file in INI format, which specifies the locations
where particle positions and velocities should be read from, and directly
stores some scalar frame values, like particle densidy etc.
Arguments:
conf_fname - name of the config file
Returns:
particle - a Particle object holding particle properties.
frate - the frame rate at which the scene was shot.
frame, next_frame - Frame objects holding the tracers and particles data
for the time points indicated in config, and the one immediately
following it.
"""
parser = SafeConfigParser()
parser.read(conf_fname)
particle = Particle(
parser.getfloat("Particle", "diameter"),
parser.getfloat("Particle", "density"))
first_frame = parser.getint("Scene", "frame")
frate = parser.getfloat("Scene", "frame rate")
fname = parser.get("Scene", "tracer_file")
tracer_trjs = trajectories(fname, first_frame, first_frame + 2,
frate, None)
tracer_ixs = trajectories_in_frame(tracer_trjs, first_frame, segs=True)
fname = parser.get("Scene", "part_file")
part_trjs = trajectories(fname, first_frame, first_frame + 2, frate, None)
part_ixs = trajectories_in_frame(part_trjs, first_frame, segs=True)
data = []
for frame_num in [first_frame, first_frame + 1]:
frame = Frame()
frame.tracers = take_snapshot([tracer_trjs[t] for t in tracer_ixs],
frame_num, tracer_trjs[0].schema())
frame.particles = take_snapshot([part_trjs[t] for t in part_ixs],
frame_num, part_trjs[0].schema())
data.append(frame)
return particle, frate, data[0], data[1]
def getfloat(self, section, option, default=None):
try:
value = SafeConfigParser.getfloat(self, section, option)
except AttributeError:
value = default
except ESGPublishError:
value = default
return value
def load_config(self, config_file):
cfg = SafeConfigParser()
cfg.read(config_file)
self.config = Config()
#daq_config.minV = cfg.getfloat('main', 'minV')
#daq_config.maxV = cfg.getfloat('main', 'maxV')
self.config.nsamp = cfg.getint('main', 'nsamp_per_chan_per_second')
self.config.nchan = cfg.getint('main', 'nchan')
self.config.nemg = cfg.getint('main', 'nemg')
self.config.nirq = self.freq = cfg.getint('main', 'nirq_per_second')
self.config.pre_trig = cfg.getfloat('main', 'pre_trigger')
self.config.trig_chan = cfg.getfloat('main', 'trig_chan')
self.config.perchan = self.config.nsamp / self.config.nirq
self.config.npt = self.config.nsamp * self.config.nchan / self.config.nirq
self.config.pre_trig_samp = self.config.pre_trig * self.config.nsamp
assert((self.config.nsamp * self.config.nchan) % self.config.nirq == 0)
assert(self.config.nsamp % self.config.nirq == 0)
def getfloatdefault(self, section, option, default=None):
"""A version of ConfigParser.getfloat that returns a default if the
option does not exist."""
try:
val = SafeConfigParser.getfloat(self, section, option)
except (NoSectionError, NoOptionError):
val = default
return val
def new_ship(self, name):
config = SafeConfigParser()
config.read("./assets/sprites/ships/" + name + ".ini")
self.speed = config.getfloat("main", "speed")
self.create_images(name)
self.img = self.playerup
self.select_img()
self.pos.size = self.img.get_size()
def read_frame_data(conf_fname):
"""
Read a configuration file in INI format, which specifies the locations
where particle positions and velocities should be read from, and directly
stores some scalar frame values, like particle densidy etc.
Arguments:
conf_fname - name of the config file
Returns:
particle - a Particle object holding particle properties.
frate - the frame rate at which the scene was shot.
frame, next_frame - Frame objects holding the tracers and particles data
for the time points indicated in config, and the one immediately
following it.
"""
parser = SafeConfigParser()
parser.read(conf_fname)
particle = Particle(parser.getfloat("Particle", "diameter"),
parser.getfloat("Particle", "density"))
first_frame = parser.getint("Scene", "frame")
frate = parser.getfloat("Scene", "frame rate")
fname = parser.get("Scene", "tracer_file")
tracer_trjs = trajectories(fname, first_frame, first_frame + 2, frate,
None)
tracer_ixs = trajectories_in_frame(tracer_trjs, first_frame, segs=True)
fname = parser.get("Scene", "part_file")
part_trjs = trajectories(fname, first_frame, first_frame + 2, frate, None)
part_ixs = trajectories_in_frame(part_trjs, first_frame, segs=True)
data = []
for frame_num in [first_frame, first_frame + 1]:
frame = Frame()
frame.tracers = take_snapshot([tracer_trjs[t] for t in tracer_ixs],
frame_num, tracer_trjs[0].schema())
frame.particles = take_snapshot([part_trjs[t] for t in part_ixs],
frame_num, part_trjs[0].schema())
data.append(frame)
return particle, frate, data[0], data[1]
def getfloat(self, section, option, default=None):
try:
value = SafeConfigParser.getfloat(self, section, option)
except AttributeError:
value = default
except ESGPublishError:
value = default
return value
def load(name):
"""Load savegame"""
global fullscreen
global screenx_current
global screeny_current
global debugscreen
global debugmode
global config
global skip
global pos_x
global pos_y
global volume
global saves
global screen
upd("get_saves")
config = SafeConfigParser()
for a in saves:
if a == name.encode("utf-8"):
config.read("./saves/" + a + ".ini")
if not (saves == []):
# tries to load and returns values in terminal that couldnt be loaded
import ConfigParser
try:
from . import sounds
#lint:disable
fullscreen = config.getboolean("main", "fullscreen")
screenx_current = int(config.getfloat("main", "screenx_current"))
screeny_current = int(config.getfloat("main", "screeny_current"))
debugscreen = config.getboolean("main", "debugscreen")
debugmode = config.getboolean("main", "debugmode")
skip = config.getboolean("main", "skip")
pos_x = config.getfloat("main", "posy")
pos_y = config.getfloat("main", "posx")
sounds.music.volume = config.getfloat("main", "volume")
#lint:enable
except ConfigParser.NoOptionError as test:
print(("Saved game couldn't be loaded completly: " + str(test)))
except Exception:
print(("Unexpected error:", sys.exc_info()[0]))
print((traceback.format_exc()))
screen = pygame.display.set_mode((screenx_current, screeny_current))
def getParameters():
parser = SafeConfigParser()
parser.read('params.ini')
iterations = parser.getint('Params', 'ITERATIONS')
layers = parser.getint('Params', 'LAYERS')
batch_size = parser.getint('Params', 'BATCH_SIZE')
l_rate = parser.getfloat('Params', 'LEARNING_RATE')
hidden = parser.getint('Params', 'HIDDEN')
return iterations, layers, l_rate, hidden, batch_size
def __init__(self):
path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
"config/configuration.ini")
config = SafeConfigParser()
config.read(path)
self.__max_distance = config.getfloat('position_memory',
'max_distance')
self.__list_balloon_already_reached = [
] #list of balloon already reached
def getTargets(iniFile):
"""Parses ini file and adds the targets found in the file to users_targets"""
global usersTargets
parser = SafeConfigParser()
parser.read(iniFile)
targList = parser.sections()
targList.sort()
for section in targList:
x = parser.getfloat(section, 'x')
y = parser.getfloat(section, 'y')
z = parser.getfloat(section, 'z')
t = Target(x, y, z)
t.baseJoint = parser.get(section, 'baseJoint')
t.middleJoint = parser.get(section, 'middleJoint')
t.hitJoint = parser.get(section, 'hitJoint')
if parser.has_option(section, 'calcLen'):
t.calcLen = parser.getboolean(section, 'calcLen')
usersTargets.append(t)
def getfloat(self, section, option, check_default=True):
if self.has_option(section, option, False):
return SafeConfigParser.getfloat(self, section, option)
elif check_default and self.has_default(option):
return self.getfloat_default(option)
elif not self.has_section(section):
raise NoSectionError(section)
else:
raise NoOptionError(option, section)
def loadConfig(self):
parser = SafeConfigParser()
parser.read('/opt/Catdoor/core/config.ini')
self.pin_irsensor_in = parser.getint('pin_settings', 'irsensor_in')
self.pin_buzzer_out = parser.getint('pin_settings', 'buzzer_out')
self.motor_delay = parser.getfloat('motor_settings', 'delay')
self.motor_distance = parser.getint('motor_settings', 'distance')
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.keep_n = parser.getint("basic", "dict_keep_n")
self.no_below = parser.getint("basic", "no_below")
self.no_above = parser.getfloat("basic", "no_above")
self.dict = '%s/data/train/paper.sampled.dict' % root
class captureRefImage():
def __init__(self, aConfigFilePath):
self.refImage = None
self.refImagePath = "./frameSetup/"
if not os.path.exists(self.refImagePath):
os.makedirs(self.refImagePath)
self.resolutionX = 640
self.resolutionY = 480
self.parser = SafeConfigParser()
self.setConfig(aConfigFilePath)
self.resolution = (self.resolutionX, self.resolutionY)
self.cam = picamera.PiCamera()
self.cam.resolution = self.resolution
def captureReferenceImage(self):
fileName = "ROIReferenceImage.jpg"
savePath = os.path.join(self.refImagePath, fileName)
self.cam.capture(savePath)
printStatement = "ROI reference image has been captured at resolution " + str(self.resolutionX) + "," + str(self.resolutionY) + ")"
print(printStatement)
def setParam(self, aParam, aParamType, aSection, aOption):
param = None
if self.parser.has_option(aSection, aOption):
if aParamType == 'int':
param = self.parser.getint(aSection, aOption)
elif aParamType == 'float':
param = self.parser.getfloat(aSection, aOption)
elif aParamType == 'bool':
param = self.parser.getboolean(aSection, aOption)
elif aParamType == 'str':
param = self.parser.get(aSection, aOption)
if param is None:
print(aOption + " in " + aSection + " was not found. Using" +
" default value.")
param = aParam
return param
def setConfig(self, aConfig):
if self.parser.read(aConfig):
self.resolutionX = self.setParam(self.resolutionX,
'int',
'Controller',
'resolutionX')
self.resolutionY = self.setParam(self.resolutionY,
'int',
'Controller',
'resolutionY')
class optionReader(object):
def __init__(self):
self.options = Options()
self.config = SafeConfigParser()
self.config.read([self.options['config']])
def getEmail(self):
sender = self.config.get('Email', 'From')
recepient = self.config.get('Email', 'To')
return (sender, recepient)
def getFTPDirectories(self):
localLog = self.config.get('FTP', 'localLogDir')
remoteLog = self.config.get('FTP', 'remoteLogDir')
return (localLog, remoteLog)
def getRecipeDirectories(self):
localDir = self.config.get('FTP', 'localRecipeDir')
remoteDir = self.config.get('FTP', 'remoteRecipeDir')
return (localDir, remoteDir)
def getLoggerHeader(self):
return flatten(self.config.get('SLC', 'Header').split(','))
def getFTPTime(self):
return self.config.getint('FTP', 'FTPTime')
def getPLCVariables(self):
return self.config.get('SLC', 'Parameters').split(',')
def getOEETime(self):
return self.config.getint('RS-232', 'OEETime')
def getPLCAlarms(self):
return self.config.get('SLC', 'Alarms').split(',')
def getPLCRecipe(self):
return self.config.get('SLC', 'Recipe').split(',')
def getAlarmTime(self):
return self.config.getfloat('RS-232', 'AlarmTime')
def getFTPparms(self):
host = self.config.get('FTP', 'host')
port = self.config.getint('FTP', 'port')
return (host, port)
def getRS232parms(self):
host = self.config.get('RS-232', 'host')
baud = self.config.getint('RS-232', 'baudrate')
return (host, baud)
def getRS422Parms(self):
host = self.config.get('RS-422', 'host')
baud = self.config.getint('RS-422', 'baudrate')
return (host, baud)
class optionReader(object):
def __init__(self):
self.options = Options()
self.config = SafeConfigParser()
self.config.read([self.options['config']])
def getEmail(self):
sender = self.config.get('Email', 'From')
recepient = self.config.get('Email', 'To')
return (sender, recepient)
def getFTPDirectories(self):
localLog = self.config.get('FTP', 'localLogDir')
remoteLog = self.config.get('FTP', 'remoteLogDir')
return (localLog, remoteLog)
def getRecipeDirectories(self):
localDir = self.config.get('FTP', 'localRecipeDir')
remoteDir = self.config.get('FTP', 'remoteRecipeDir')
return (localDir, remoteDir)
def getLoggerHeader(self):
return flatten(self.config.get('SLC', 'Header').split(','))
def getFTPTime(self):
return self.config.getint('FTP', 'FTPTime')
def getPLCVariables(self):
return self.config.get('SLC', 'Parameters').split(',')
def getOEETime(self):
return self.config.getint('RS-232', 'OEETime')
def getPLCAlarms(self):
return self.config.get('SLC', 'Alarms').split(',')
def getPLCRecipe(self):
return self.config.get('SLC', 'Recipe').split(',')
def getAlarmTime(self):
return self.config.getfloat('RS-232', 'AlarmTime')
def getFTPparms(self):
host = self.config.get('FTP', 'host')
port = self.config.getint('FTP', 'port')
return (host, port)
def getRS232parms(self):
host = self.config.get('RS-232', 'host')
baud = self.config.getint('RS-232', 'baudrate')
return (host, baud)
def getRS422Parms(self):
host = self.config.get('RS-422', 'host')
baud = self.config.getint('RS-422', 'baudrate')
return (host, baud)
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
self.root = parser.get("basic", "root")
self.svd_model = '%s/models/data/paper.svd.model/svd.model/svd.model' % self.root
self.sample_fraction = parser.getfloat('svd', 'sample_fraction')
self.n_components = parser.getint('svd', 'n_components')
self.sampled_doc = '%s/models/data/paper.svd.model/paper.topic.sampled' % self.root
self.topic_num = parser.getint('plda', 'topic_num')
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.svd_model = '%s/data/train/svd.model/svd.model' % root
self.sample_fraction = parser.getfloat('svd', 'sample_fraction')
self.n_components = parser.getint('svd', 'n_components')
self.sampled_doc = '%s/data/temp/paper.topic.sampled' % root
self.topic_num = parser.getint('plda+', 'topic_num')
def load_config(self, config_file):
cfg = SafeConfigParser()
cfg.read(config_file)
daq_config = Config()
daq_config.minV = cfg.getfloat('main', 'minV')
daq_config.maxV = cfg.getfloat('main', 'maxV')
daq_config.nsamp = cfg.getint('main', 'nsamp_per_chan_per_second')
daq_config.nchan = cfg.getint('main', 'nchan')
daq_config.nirq = self.freq = cfg.getint('main', 'nirq_per_second')
return daq_config
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.batch = parser.getint("rec", "batch")
self.threshold = parser.getfloat("rec", "threshold")
self.thread_num = parser.getint("rec", "cpu_core_num")
self.topk = parser.getint("rec", "topk")
self.rec = '%s/data/user/user.rec' % root
def get(name, rc_file='~/.odoorpcrc'):
"""Return the session configuration identified by `name`
from the `rc_file` file.
>>> import odoorpc
>>> from pprint import pprint as pp
>>> pp(odoorpc.session.get('foo')) # doctest: +SKIP
{'database': 'db_name',
'host': 'localhost',
'passwd': 'password',
'port': 8069,
'protocol': 'jsonrpc',
'timeout': 120,
'type': 'ODOO',
'user': '******'}
.. doctest::
:hide:
>>> import odoorpc
>>> session = '%s_session' % DB
>>> odoo.save(session)
>>> data = odoorpc.session.get(session)
>>> data['host'] == HOST
True
>>> data['protocol'] == PROTOCOL
True
>>> data['port'] == int(PORT)
True
>>> data['database'] == DB
True
>>> data['user'] == USER
True
>>> data['passwd'] == PWD
True
>>> data['type'] == 'ODOO'
True
:raise: `ValueError` (wrong session name)
"""
conf = ConfigParser()
conf.read([os.path.expanduser(rc_file)])
if not conf.has_section(name):
raise ValueError(
"'%s' session does not exist in %s" % (name, rc_file))
return {
'type': conf.get(name, 'type'),
'host': conf.get(name, 'host'),
'protocol': conf.get(name, 'protocol'),
'port': conf.getint(name, 'port'),
'timeout': conf.getfloat(name, 'timeout'),
'user': conf.get(name, 'user'),
'passwd': conf.get(name, 'passwd'),
'database': conf.get(name, 'database'),
}
def get(name, rc_file='~/.odoorpcrc'):
"""Return the session configuration identified by `name`
from the `rc_file` file.
>>> import odoorpc
>>> from pprint import pprint as pp
>>> pp(odoorpc.session.get('foo')) # doctest: +SKIP
{'database': 'db_name',
'host': 'localhost',
'passwd': 'password',
'port': 8069,
'protocol': 'jsonrpc',
'timeout': 120,
'type': 'ODOO',
'user': '******'}
.. doctest::
:hide:
>>> import odoorpc
>>> session = '%s_session' % DB
>>> odoo.save(session)
>>> data = odoorpc.session.get(session)
>>> data['host'] == HOST
True
>>> data['protocol'] == PROTOCOL
True
>>> data['port'] == int(PORT)
True
>>> data['database'] == DB
True
>>> data['user'] == USER
True
>>> data['passwd'] == PWD
True
>>> data['type'] == 'ODOO'
True
:raise: `ValueError` (wrong session name)
"""
conf = ConfigParser()
conf.read([os.path.expanduser(rc_file)])
if not conf.has_section(name):
raise ValueError("'{}' session does not exist in {}".format(
name, rc_file))
return {
'type': conf.get(name, 'type'),
'host': conf.get(name, 'host'),
'protocol': conf.get(name, 'protocol'),
'port': conf.getint(name, 'port'),
'timeout': conf.getfloat(name, 'timeout'),
'user': conf.get(name, 'user'),
'passwd': conf.get(name, 'passwd'),
'database': conf.get(name, 'database'),
}
def load_from_ini_file(filename):
cp = SafeConfigParser()
files_read = cp.read([filename, ])
if filename not in files_read:
raise ConfigurationError(filename)
account = Account(
cp.get('account', 'username'),
cp.get('account', 'password'))
misc = Misc(
os.path.expandvars(cp.get('misc', 'data_dir')),
cp.getboolean('misc', 'page_archiver'))
logging = Logging(
cp.get('logging', 'console_level'),
cp.get('logging', 'file_level'))
sniper = Sniper(
cp.getint('sniper', 'refresh_interval'),
cp.getint('sniper', 'auctions_to_analyze'),
cp.getint('sniper', 'bargain_threshold'),
cp.getint('sniper', 'profit_threshold'),
frozenset(cp.get('sniper', 'interesting_keywords').split(',')),
frozenset(cp.get('sniper', 'bad_keywords').split(',')),
cp.getint('sniper', 'minimum_np_for_playing'),
cp.getint('sniper', 'minimal_auction_number'),
cp.getint('sniper', 'item_samples'),
cp.getfloat('sniper', 'item_price_max_deviation'),
cp.getfloat('sniper', 'suspecious_yield_threshold'),
cp.getfloat('sniper', 'minimal_yield'),)
autopricer = AutoPricer(
cp.get('autopricer', 'strategy'))
application = Application(
cp.getboolean('application', 'dailies'),
cp.get('application', 'restockers').split(','),
cp.getint('application', 'restocker_refresh_interval'),
cp.getboolean('application', 'sniper'))
return Config(account, misc, logging, application, sniper, autopricer)
def initNet(self, config, opts=None):
print '\n\ninit net from scrach ... '
# config parser
parser = SafeConfigParser()
parser.read(config)
# setting learning hyperparameters
self.debug = parser.getboolean('learn', 'debug')
if self.debug:
print 'loading settings from config file ...'
self.seed = parser.getint('learn', 'random_seed')
self.lr_divide = parser.getint('learn', 'lr_divide')
self.lr = parser.getfloat('learn', 'lr')
self.lr_decay = parser.getfloat('learn', 'lr_decay')
self.beta = parser.getfloat('learn', 'beta')
self.min_impr = parser.getfloat('learn', 'min_impr')
self.llogp = parser.getfloat('learn', 'llogp')
# setting training mode
self.mode = parser.get('train_mode', 'mode')
self.obj = parser.get('train_mode', 'obj')
self.gamma = parser.getfloat('train_mode', 'gamma')
self.batch = parser.getint('train_mode', 'batch')
# setting file paths
if self.debug:
print 'loading file path from config file ...'
self.wvecfile = parser.get('data', 'wvec')
self.trainfile = parser.get('data', 'train')
self.validfile = parser.get('data', 'valid')
self.testfile = parser.get('data', 'test')
self.vocabfile = parser.get('data', 'vocab')
self.domain = parser.get('data', 'domain')
self.percentage = float(parser.getfloat('data', 'percentage')) / 100.0
# Setting generation specific parameters
self.topk = parser.getint('gen', 'topk')
self.overgen = parser.getint('gen', 'overgen')
self.beamwidth = parser.getint('gen', 'beamwidth')
self.detectpairs = parser.get('gen', 'detectpairs')
self.verbose = parser.getint('gen', 'verbose')
self.decode = parser.get('gen', 'decode')
# setting rnn configuration
self.gentype = parser.get('generator', 'type')
self.dh = parser.getint('generator', 'hidden')
# set random seed
np.random.seed(self.seed)
random.seed(self.seed)
np.set_printoptions(precision=4)
# setting data reader, processors, and lexicon
self.setupDelegates()
# network size
self.di = len(self.reader.vocab)
# logp for validation set
self.valid_logp = 0.0
# start setting networks
self.initModel()
self.model.config_theano()
def initNet(self,config,opts=None):
print '\n\ninit net from scrach ... '
# config parser
parser = SafeConfigParser()
parser.read(config)
# setting learning hyperparameters
self.debug = parser.getboolean('learn','debug')
if self.debug:
print 'loading settings from config file ...'
self.seed = parser.getint( 'learn','random_seed')
self.lr_divide = parser.getint( 'learn','lr_divide')
self.lr = parser.getfloat('learn','lr')
self.lr_decay = parser.getfloat('learn','lr_decay')
self.beta = parser.getfloat('learn','beta')
self.min_impr = parser.getfloat('learn','min_impr')
self.llogp = parser.getfloat('learn','llogp')
# setting training mode
self.mode = parser.get('train_mode','mode')
self.obj = parser.get('train_mode','obj')
self.gamma = parser.getfloat('train_mode','gamma')
self.batch = parser.getint('train_mode','batch')
# setting file paths
if self.debug:
print 'loading file path from config file ...'
self.wvecfile = parser.get('data','wvec')
self.trainfile = parser.get('data','train')
self.validfile = parser.get('data','valid')
self.testfile = parser.get('data','test')
self.vocabfile = parser.get('data','vocab')
self.domain = parser.get('data','domain')
self.percentage = float(parser.getfloat('data','percentage'))/100.0
# Setting generation specific parameters
self.topk = parser.getint('gen','topk')
self.overgen = parser.getint('gen','overgen')
self.beamwidth = parser.getint('gen','beamwidth')
self.detectpairs= parser.get('gen','detectpairs')
self.verbose = parser.getint('gen','verbose')
self.decode = parser.get('gen','decode')
# setting rnn configuration
self.gentype = parser.get('generator','type')
self.dh = parser.getint('generator','hidden')
# set random seed
np.random.seed(self.seed)
random.seed(self.seed)
np.set_printoptions(precision=4)
# setting data reader, processors, and lexicon
self.setupDelegates()
# network size
self.di = len(self.reader.vocab)
# logp for validation set
self.valid_logp = 0.0
# start setting networks
self.initModel()
self.model.config_theano()
def main():
usage = "usage: %prog [options]"
parser = OptionParser(usage)
parser.add_option("-c",
"--config",
action="store",
dest="config",
default=config_path)
(options, args) = parser.parse_args()
logfd = os.open(LOG_PATH, os.O_WRONLY | os.O_APPEND | os.O_CREAT, 0644)
if logfd < 0:
print sys.stderr, "ERROR: Failed to open log file (%s)" % LOG_PATH
exit(1)
# reinitialize python stdout/err
sys.stdout.flush()
sys.stderr.flush()
os.dup2(logfd, 1)
os.dup2(logfd, 2)
os.close(logfd)
devnull = os.open('/dev/null', os.O_RDONLY)
os.dup2(devnull, 0)
config = SafeConfigParser({
'vm-min-mem':
str(qmemman_algo.MIN_PREFMEM),
'dom0-mem-boost':
str(qmemman_algo.DOM0_MEM_BOOST),
'cache-margin-factor':
str(qmemman_algo.CACHE_FACTOR)
})
config.read(options.config)
if config.has_section('global'):
qmemman_algo.MIN_PREFMEM = parse_size(
config.get('global', 'vm-min-mem'))
qmemman_algo.DOM0_MEM_BOOST = parse_size(
config.get('global', 'dom0-mem-boost'))
qmemman_algo.CACHE_FACTOR = config.getfloat(
'global', 'cache-margin-factor')
print "values: %s, %s, %s" % (str(
qmemman_algo.MIN_PREFMEM), str(
qmemman_algo.DOM0_MEM_BOOST), str(qmemman_algo.CACHE_FACTOR))
try:
os.unlink(SOCK_PATH)
except:
pass
os.umask(0)
server = SocketServer.UnixStreamServer(SOCK_PATH, QMemmanReqHandler)
os.umask(077)
if os.fork() == 0:
thread.start_new_thread(start_server, tuple([server]))
XS_Watcher().watch_loop()
def getfloat(self, section, option, default=0.0):
""" Get a float option value for a given section
:param section: Section name
:param option: Option name
:param default: Default value to return if option is not present int
config file
"""
if notself.has_option(section, option):
return default
return SafeConfigParser.getfloat(self, section, option)
def __init__(self, *args, **kwargs):
luigi.Task.__init__(self, *args, **kwargs)
parser = SafeConfigParser()
parser.read(self.conf)
root = parser.get("basic", "root")
self.batch = parser.getint("rec", "batch")
self.threshold = parser.getfloat("rec", "threshold")
self.thread_num = parser.getint("rec", "cpu_core_num")
self.n_components = parser.getint('svd', 'n_components')
self.topk = parser.getint("rec", "topk")
self.rec = '%s/data/rec/userRecBooks.rec' % root
def get_all(rc_file='~/.odoorpcrc'):
"""Return all session configurations from the `rc_file` file.
>>> import odoorpc
>>> from pprint import pprint as pp
>>> pp(odoorpc.session.get_all()) # doctest: +SKIP
{'foo': {'database': 'db_name',
'host': 'localhost',
'passwd': 'password',
'port': 8069,
'protocol': 'jsonrpc',
'timeout': 120,
'type': 'ODOO',
'user': '******'},
...}
.. doctest::
:hide:
>>> import odoorpc
>>> session = '%s_session' % DB
>>> odoo.save(session)
>>> data = odoorpc.session.get_all()
>>> data[session]['host'] == HOST
True
>>> data[session]['protocol'] == PROTOCOL
True
>>> data[session]['port'] == int(PORT)
True
>>> data[session]['database'] == DB
True
>>> data[session]['user'] == USER
True
>>> data[session]['passwd'] == PWD
True
>>> data[session]['type'] == 'ODOO'
True
"""
conf = ConfigParser()
conf.read([os.path.expanduser(rc_file)])
sessions = {}
for name in conf.sections():
sessions[name] = {
'type': conf.get(name, 'type'),
'host': conf.get(name, 'host'),
'protocol': conf.get(name, 'protocol'),
'port': conf.getint(name, 'port'),
'timeout': conf.getfloat(name, 'timeout'),
'user': conf.get(name, 'user'),
'passwd': conf.get(name, 'passwd'),
'database': conf.get(name, 'database'),
}
return sessions
def testDatabaseContent(self):
script_output_file = os.path.abspath('script.out')
self.gnathub.run(script=Script.db2cfg(), output=script_output_file)
parser = SafeConfigParser()
parser.optionxform = str
parser.read(script_output_file)
self.assertListEqual(sorted(parser.sections()), ELEMENTS)
for metric, value in EXPECTED_METRICS.iteritems():
self.assertTrue(parser.has_option(SECTION, metric),
'missing entry for "%s"' % metric)
self.assertEqual(parser.getfloat(SECTION, metric), value,
'unexpected value for "%s"' % metric)
for emetric, value in EXPECTED_EMETRICS.iteritems():
self.assertTrue(parser.has_option(ESECTION, emetric),
'missing entry for "%s"' % metric)
self.assertEqual(parser.getfloat(ESECTION, emetric), value,
'unexpected value for "%s"' % emetric)
def get_all(rc_file='~/.odoorpcrc'):
"""Return all session configurations from the `rc_file` file.
>>> import odoorpc
>>> from pprint import pprint as pp
>>> pp(odoorpc.session.get_all()) # doctest: +SKIP
{'foo': {'database': 'db_name',
'host': 'localhost',
'passwd': 'password',
'port': 8069,
'protocol': 'jsonrpc',
'timeout': 120,
'type': 'ODOO',
'user': '******'},
...}
.. doctest::
:hide:
>>> import odoorpc
>>> session = '%s_session' % DB
>>> odoo.save(session)
>>> data = odoorpc.session.get_all()
>>> data[session]['host'] == HOST
True
>>> data[session]['protocol'] == PROTOCOL
True
>>> data[session]['port'] == int(PORT)
True
>>> data[session]['database'] == DB
True
>>> data[session]['user'] == USER
True
>>> data[session]['passwd'] == PWD
True
>>> data[session]['type'] == 'ODOO'
True
"""
conf = ConfigParser()
conf.read([os.path.expanduser(rc_file)])
sessions = {}
for name in conf.sections():
sessions[name] = {
'type': conf.get(name, 'type'),
'host': conf.get(name, 'host'),
'protocol': conf.get(name, 'protocol'),
'port': conf.getint(name, 'port'),
'timeout': conf.getfloat(name, 'timeout'),
'user': conf.get(name, 'user'),
'passwd': conf.get(name, 'passwd'),
'database': conf.get(name, 'database'),
}
return sessions
