def test_phva_rate_const_mat(self):
fixed_atoms = load_fixed_g03com(
pkg_resources.resource_filename(__name__, "../data/test/mat/Zp_p_react.14mei.com"))
mol_react = load_molecule_g03fchk(
pkg_resources.resource_filename(__name__, "../data/test/mat/Zp_p_react.28aug.fchk"),
pkg_resources.resource_filename(__name__, "../data/test/mat/Zp_p_react.14mei.fchk"))
mol_trans = load_molecule_g03fchk(
pkg_resources.resource_filename(__name__, "../data/test/mat/Zp_p_TS.28aug.fchk"),
pkg_resources.resource_filename(__name__, "../data/test/mat/5Tp_p_TS.oniom21apr_HF.fchk"))
pf_react = PartFun(NMA(mol_react, PHVA(fixed_atoms)))
pf_trans = PartFun(NMA(mol_trans, PHVA(fixed_atoms)))
km = KineticModel([pf_react], pf_trans)
# values taken from the fancy excel file...
temps = np.array([670,680,690,700,710,720,730,740,750,760,770])
expected_ks = np.array([
7.9473102E+05, 9.8300444E+05, 1.2085262E+06, 1.4771808E+06,
1.7955340E+06, 2.1708793E+06, 2.6112829E+06, 3.1256298E+06,
3.7236678E+06, 4.4160510E+06, 5.2143822E+06
])
for i in xrange(len(temps)):
k = km.rate_constant(temps[i])
self.assertAlmostEqual(np.log(k/(1/second)), np.log(expected_ks[i]),5)
log_k = km.rate_constant(temps[i], do_log=True)
self.assertAlmostEqual(np.log(k), log_k)
def setup(self):
'''scenario setup'''
self.tacker_script = pkg_resources.resource_filename(
'yardstick.benchmark.scenarios.networking',
Sfc.TACKER_SCRIPT)
self.server_script = pkg_resources.resource_filename(
'yardstick.benchmark.scenarios.networking',
Sfc.SERVER_SCRIPT)
''' calling Tacker to instantiate VNFs and Service Chains '''
cmd_tacker = "%s" % (self.tacker_script)
subprocess.call(cmd_tacker, shell=True)
target = self.context_cfg['target']
target_user = target.get('user', 'root')
target_pwd = target.get('password', 'octopus')
target_ip = target.get('ip', None)
''' webserver start automatically during the vm boot '''
LOG.info("user:%s, target:%s", target_user, target_ip)
self.server = ssh.SSH(target_user, target_ip, password=target_pwd)
self.server.wait(timeout=600)
self.server.run("cat > ~/server.sh",
stdin=open(self.server_script, "rb"))
cmd_server = "sudo bash server.sh"
LOG.debug("Executing command: %s", cmd_server)
status, stdout, stderr = self.server.execute(cmd_server)
LOG.debug("Output server command: %s", status)
self.setup_done = True
def main(args):
'''Module main function'''
global database
global genetic_algorithm
global joint_positions
global goal_positions
pygame.init()
random.seed()
database = utils.initialize_database(args, 'RobotTrainingData')
database.set_objective_names(['Tiempo', r'Error en $\theta_1$', r'Error en $\theta_2$', r'Error en $\theta_3$', 'Energía'])
problem = EV3Problem()
generation = database.properties['highest_population']
population_size = database.properties['population_size']
genetic_algorithm = evolution.NSGA(problem, population_size)
x_path = os.path.abspath(pkg_resources.resource_filename('resources.ev3', 'x_train.txt'))
y_path = os.path.abspath(pkg_resources.resource_filename('resources.ev3', 'y_train.txt'))
batch_start = (generation % 10) * N_GOALS
joint_positions = np.loadtxt(x_path)[batch_start : batch_start + N_GOALS, :]
goal_positions = np.loadtxt(y_path)[batch_start : batch_start + N_GOALS, :]
if generation > 0:
parents, children = utils.load_data(database)
genetic_algorithm.set_population(parents)
genetic_algorithm.set_children(children)
for _ in range(args.iterations):
generation += 1
print('Starting generation ' + str(generation))
genetic_algorithm.iterate()
database.create_population()
utils.save_data(genetic_algorithm, database)
print('=' * (SCREEN_WIDTH - 1))
def render_thumb(width, imgfile):
try:
imgpath=pkg_resources.resource_filename('vishwin_http.views', 'img/' + imgfile)
thumbfile=width + 'px-' + imgfile
thumbpath=pkg_resources.resource_filename('vishwin_http.views', 'generated/thumb/' + thumbfile)
# get file modified time for original; will throw exception if not found
mtime_orig=os.path.getmtime(imgpath)
if not (os.path.isfile(thumbpath)) or (os.path.getmtime(thumbpath) < mtime_orig):
img=open(imgpath, 'rb')
tags=exifread.process_file(img, details=False, stop_tag='Image_Orientation')
img.close()
# reopen using PIL
img=Image.open(imgpath)
# upon transpose, format attribute in object is cleared
format=img.format
if 'Image Orientation' in tags:
if tags['Image Orientation'].values[0]>=5:
# rotations in PIL(low) are anti-clockwise, would be easier if clockwise was default
img=img.transpose(Image.ROTATE_270)
if (tags['Image Orientation'].values[0]==(3 or 4)) or tags['Image Orientation'].values[0]>=7:
img=img.transpose(Image.ROTATE_180)
# flipped images
if tags['Image Orientation'].values[0]==(2 or 4 or 5 or 7):
img=img.transpose(Image.FLIP_LEFT_RIGHT)
img.thumbnail((int(width), int(width)/(img.size[0]/img.size[1])))
img.save(thumbpath, format)
img.close()
return send_file(thumbpath, mimetype=guess_type(imgpath)[0])
except OSError:
abort(404)
def create_app(config: dict = {}, mail_client=None):
app = Flask(__name__, static_folder='static')
if config:
app.config.update(config)
else:
app.config.from_envvar('ALSERVICE_CONFIG')
MakoTemplates(app)
app._mako_lookup = TemplateLookup(directories=[pkg_resources.resource_filename('alservice.service', 'templates')],
input_encoding='utf-8', output_encoding='utf-8',
imports=['from flask_babel import gettext as _'])
app.al = init_account_linking(app, mail_client)
babel = Babel(app)
babel.localeselector(get_locale)
app.config['BABEL_TRANSLATION_DIRECTORIES'] = pkg_resources.resource_filename('alservice.service',
'data/i18n/locales')
from .views import account_linking_views
app.register_blueprint(account_linking_views)
setup_logging(app.config.get('LOGGING_LEVEL', 'INFO'))
logger = logging.getLogger(__name__)
logger.info('Running ALservice version %s', pkg_resources.get_distribution('ALservice').version)
return app
def setup_blank_site(meta):
def safe_mkdir(name):
# Create the directory if it doesn't already exist
if not os.path.exists(name):
os.mkdir(name)
# Write meta.md
output = open("meta.md", "w")
for key in meta:
output.write(key + ": " + meta[key] + "\n")
output.close()
# Create folders
safe_mkdir(PagesDirectory)
safe_mkdir(PostsDirectory)
safe_mkdir(TemplatesDirectory)
safe_mkdir(ArchiveDirectory)
# Copy default templates
for name in Templates:
rsc_path = "templates/" + name + "-template.html"
src = pkg_resources.resource_filename(__name__, rsc_path)
shutil.copyfile(src, TemplatesDirectory + name + "-template.html")
# Copy style.css
src = pkg_resources.resource_filename(__name__, "style.css")
shutil.copyfile(src, "style.css")
# Generate the site
gen_site()
def test20_verification_filelist(self):
try:
db1 = facereclib.utils.resources.load_resource(pkg_resources.resource_filename('facereclib.tests', os.path.join('scripts', 'atnt_Test.py')), 'database')
except Exception as e:
raise SkipTest("This test is skipped since the atnt database is not available.")
try:
db2 = facereclib.utils.resources.load_resource(pkg_resources.resource_filename('facereclib.tests', os.path.join('databases', 'atnt_fl', 'atnt_fl_database.py')), 'database')
except Exception as e:
raise SkipTest("This test is skipped since the verification.filelist database is not available.")
# The test of the verification.filelist database is a bit different.
# here, we test the output of two different ways of querying the AT&T database
# where actually both ways are uncommon...
# assure that different kind of queries result in the same file lists
self.assertEqual(set([str(id) for id in db1.model_ids()]), set(db2.model_ids()))
self.assertEqual(set([str(id) for id in db1.t_model_ids()]), set(db2.t_model_ids()))
def check_files(f1, f2):
self.assertEqual(set([file.path for file in f1]), set([file.path for file in f2]))
check_files(db1.all_files(), db2.all_files())
check_files(db1.training_files('train_extractor'), db2.training_files('train_extractor'))
check_files(db1.enroll_files(model_id=22), db2.enroll_files(model_id='22'))
check_files(db1.probe_files(model_id=22), db2.probe_files(model_id='22'))
check_files(db1.t_enroll_files(model_id=22), db2.t_enroll_files(model_id='22'))
check_files(db1.z_probe_files(), db2.z_probe_files())
f1 = db1.all_files()[0]
f2 = db2.all_files()[0]
self.assertEqual(f1.make_path(directory='xx', extension='.yy'), f2.make_path(directory='xx', extension='.yy'))
m1 = sorted([str(id) for id in db1.model_ids()])[0]
m2 = sorted([str(id) for id in db2.model_ids()])[0]
self.assertEqual(str(db1.client_id_from_model_id(m1)), db2.client_id_from_model_id(m2))
def setUp(self):
if "NTA_DYNAMIC_CONF_DIR" in os.environ:
# Remove it to make sure our in-proc tests won't accidentally
# mess with actual files
oldNtaDynamicConfDir = os.environ["NTA_DYNAMIC_CONF_DIR"]
del os.environ["NTA_DYNAMIC_CONF_DIR"]
self.addCleanup(os.environ.update,
dict(NTA_DYNAMIC_CONF_DIR=oldNtaDynamicConfDir))
self.files = dict()
tmpDir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpDir)
with open(os.path.join(tmpDir, 'nupic-default.xml-unittest'), 'w') as fp:
with open(resource_filename(__name__, 'conf/nupic-default.xml')) as inp:
fp.write(inp.read())
self.files['nupic-default.xml'] = fp.name
with open(os.path.join(tmpDir, 'nupic-site.xml-unittest'), 'w') as fp:
with open(resource_filename(__name__, 'conf/nupic-site.xml')) as inp:
fp.write(inp.read())
self.files['nupic-site.xml'] = fp.name
with open(os.path.join(tmpDir, 'nupic-custom.xml'), 'w') as fp:
with open(resource_filename(__name__, 'conf/nupic-custom.xml')) as inp:
fp.write(inp.read())
self.files['nupic-custom.xml'] = fp.name
self.customParam = 'nupic.custom.hello'
self.customValue = 'world'
configuration.Configuration.clear()
def get_tiddler_locations(store_contents, package_name):
"""
returns instance_tiddlers structure using tiddler paths from within the
package if available
store_structure is a dictionary listing tiddler URIs per bag
packaged tiddlers must be listed in <package>/resources/tiddlers.index
"""
package_path = os.path.join(*package_name.split("."))
tiddler_index = os.path.join("resources", "tiddlers.index")
tiddler_index = resource_filename(package_name, tiddler_index)
instance_tiddlers = {}
try:
f = open(tiddler_index)
for line in f:
bag, filename = line.rstrip().split("/", 1)
filepath = os.path.join("resources", bag, filename)
filepath = resource_filename(package_name, filepath)
try: # convert Windows paths to URIs
sys.getwindowsversion() # XXX: safer detection than sys.platform or os.name?
uri = "file:///%s" % filepath.replace("\\", "/")
except AttributeError:
uri = "file://%s" % filepath
resource_filename(package_name, "%s.meta" % filepath)
try:
instance_tiddlers[bag].append(uri)
except KeyError:
instance_tiddlers[bag] = [uri]
f.close()
except IOError:
for bag, uris in store_contents.items():
instance_tiddlers[bag] = uris
return instance_tiddlers
def make_app(global_conf, full_stack=True, **app_conf):
"""
Set vigiboard up with the settings found in the PasteDeploy configuration
file used.
This is the PasteDeploy factory for the vigiboard application.
C{app_conf} contains all the application-specific settings (those defined
under ``[app:main]``).
@param global_conf: The global settings for vigiboard (those
defined under the ``[DEFAULT]`` section).
@type global_conf: C{dict}
@param full_stack: Should the whole TG2 stack be set up?
@type full_stack: C{str} or C{bool}
@return: The vigiboard application with all the relevant middleware
loaded.
"""
app = make_base_app(global_conf, full_stack=full_stack, **app_conf)
# Personalisation des fichiers statiques via /etc/vigilo/vigiboard/public/.
custom_static = StaticURLParser('/etc/vigilo/vigiboard/public/')
# On définit 2 middlewares pour fichiers statiques qui cherchent
# les fichiers dans le thème actuellement chargé.
# Le premier va les chercher dans le dossier des fichiers spécifiques
# à l'application, le second cherche dans les fichiers communs.
app_static = StaticURLParser(resource_filename(
'vigilo.themes.public', 'vigiboard'))
common_static = StaticURLParser(resource_filename(
'vigilo.themes.public', 'common'))
local_static = StaticURLParser(resource_filename(
'vigiboard', 'public'))
app = Cascade([custom_static, app_static, common_static, local_static, app])
return app
def resource_filename(name, pfx=None):
"""
Attempt to find and return the filename of the resource named by the first argument
in the first location of:
# as name in the current directory
# as name in the `pfx` subdirectory of the current directory if provided
# as name relative to the package
# as pfx/name relative to the package
The last two alternatives is used to locate resources distributed in the package.
This includes certain XSLT and XSD files.
:param name: The string name of a resource
:param pfx: An optional prefix to use in searching for name
"""
if os.path.exists(name):
with open(name) as fd:
return fd.read()
elif pfx and os.path.exists(os.path.join(pfx, name)):
with open(os.path.join(pfx, name)) as fd:
return fd.read()
elif pkg_resources.resource_exists(__name__, name):
return pkg_resources.resource_filename(__name__, name)
elif pfx and pkg_resources.resource_exists(__name__, "%s/%s" % (pfx, name)):
return pkg_resources.resource_filename(__name__, "%s/%s" % (pfx, name))
return None
def resolve_main_template():
# Plone 5
main_template = os.path.join(
'browser', 'templates', 'main_template.pt')
if pkg_resources.resource_exists('Products.CMFPlone', main_template):
filename = pkg_resources.resource_filename('Products.CMFPlone',
main_template)
return ViewPageTemplateFile(filename)
# Plone 4 with Sunburst
sunburst_main_template = os.path.join(
'skins', 'sunburst_templates', 'main_template.pt')
if pkg_resources.resource_exists('plonetheme.sunburst',
sunburst_main_template):
filename = pkg_resources.resource_filename('plonetheme.sunburst',
sunburst_main_template)
return ViewPageTemplateFile(filename)
# Fallback
skins_main_template = os.path.join(
'skins', 'plone_templates', 'main_template.pt')
if pkg_resources.resource_exists('Products.CMFPlone', skins_main_template):
filename = pkg_resources.resource_filename('Products.CMFPlone',
skins_main_template)
return ViewPageTemplateFile(filename)
def __init__(self):
examplesDir = resource_filename("nupic", os.path.join("..", "examples"))
_debugOut("examplesDir=<%s>" % (examplesDir,))
assert os.path.exists(examplesDir), \
"%s is not present in filesystem" % examplesDir
# This is where we find OPF binaries (e.g., run_opf_experiment.py, etc.)
# In the autobuild, it is a read-only directory
self.__opfBinDir = resource_filename("nupic", os.path.join("..", "scripts"))
assert os.path.exists(self.__opfBinDir), \
"%s is not present in filesystem" % self.__opfBinDir
_debugOut("self.__opfBinDir=<%s>" % self.__opfBinDir)
# Where this script is running from (our autotest counterpart may have
# copied it from its original location)
self.__testRunDir = os.path.abspath(os.path.dirname(__file__))
_debugOut("self.__testRunDir=<%s>" % self.__testRunDir)
# Parent directory of our private OPF experiments
self.__opfExperimentsParentDir = os.path.join(self.__testRunDir,
"experiments")
assert os.path.exists(self.__opfExperimentsParentDir), \
"%s is not present in filesystem" % self.__opfExperimentsParentDir
_debugOut("self.__opfExperimentsParentDir=<%s>"
% self.__opfExperimentsParentDir)
def copyConfig():
'''copyConfig()
Copies samples configuration if necessary to /etc/odinsys directory.'''
from pkg_resources import Requirement, resource_filename
# Get our file.
filename_odinsys = resource_filename(Requirement.parse("odinsys"),
"config/odinsys.sample.conf")
filename_odinsys_log = resource_filename(Requirement.parse("odinsys"),
"config/odinsyslogger.sample.conf")
try:
import shutil
# Create the directory.
if not os.path.exists("/opt/odinsys"):
os.mkdir("/opt/odinsys")
# Copy the configuration. Don't clobber existing files.
if not os.path.exists("/etc/odinsys/odinsys.conf"):
shutil.copyfile(filename_odinsys, "/etc/odinsys/odinsys.conf")
if not os.path.exists("/etc/odinsys/odinsyslogger.conf"):
shutil.copyfile(filename_odinsys_log, "/etc/odinsys/odinsyslogger.conf")
except IOError:
print "Unable to copy configuration file to /etc/odinsys directory."
def find_packaged_regressor(name):
""" Find location of a regression method packaged with YATSM
See :data:`packaged_regressions` for a list of
available pre-packaged regressors
Args:
name (str): name of packaged regression object
Returns:
str: path to packaged regression method
Raises:
KeyError: raise KeyError if user specifies unknown regressor
IOError: raise IOError if the packaged regressor cannot be found
"""
if name not in packaged_regressions:
raise KeyError('Cannot load unknown packaged regressor %s' % name)
path = pkg_resources.resource_filename(__name__, 'pickles')
logger.debug('Checking data files in %s for packaged regressors' % path)
if not pkg_resources.resource_exists(__name__, 'pickles'):
raise IOError('Cannot find packaged regressors in %s. Did you install '
'YATSM via setuptools?' % path)
resource = os.path.join('pickles', name + '.pkl')
if not pkg_resources.resource_exists(__name__, resource):
raise IOError('Cannot find packaged regression method %s, but package '
'directory exists. Check the contents of %s if possible'
% (resource, path))
return pkg_resources.resource_filename(__name__, resource)
def __init__(self):
configfile=resource_filename("portal","config_prod.ini")
self.config = safeConfigParser(configfile)
logging.info("Loaded portal config %s " % configfile)
self.control = Control(self.config)
logging.info("Control loaded")
handlers = [
(r"/lib/(.*)", StaticFileHandler, {"path": resource_filename("illiquids","www/lib")}),
(r"/local/(.*)", StaticFileHandler, {"path": resource_filename("illiquids","www/static")}),
(r"/accounts/(.*)/(.*)", AccountsHandler, {"control": self.control}),
(r"/accounts/(.*)", AccountsHandler, {"control": self.control}),
(r"/balances/(.*)/(.*)", BalancesHandler, {"control": self.control}),
(r"/balances/(.*)", BalancesHandler, {"control": self.control}),
(r"/", LayoutHandler, {"control": self.control}),
(r"/(.*)", StaticFileHandler, {"path": resource_filename("illiquids","www"),
"default_filename":"index.html"}),
]
settings = {
'cookie_secret' : "whare_are_the_bank_accounts",
'debug' : options.debug,
'enabled_protocols' : ['websocket', 'flashsocket', 'xhr-multipart', 'xhr-polling'],
'flash_policy_port' : 843,
'flash_policy_file' : resource_filename("illiquids",'flashpolicy.xml'),
'socket_io_port' : 8001,
}
tornado.web.Application.__init__(self, handlers, **settings)
def test_cli():
"""Test cds-dojson CLI."""
runner = CliRunner()
result = runner.invoke(
compile_schema,
[pkg_resources.resource_filename(
'cds_dojson.schemas', 'records/video_src-v1.0.0.json'), ]
)
assert 0 == result.exit_code
compiled_schema_result = json.loads(result.output)
with open(pkg_resources.resource_filename(
'cds_dojson.schemas', 'records/video-v1.0.0.json'), 'r') as f:
compile_schema_expected = json.load(f)
assert compile_schema_expected == compiled_schema_result
result = runner.invoke(
compile_schema,
[pkg_resources.resource_filename(
'cds_dojson.schemas', 'records/project_src-v1.0.0.json'), ]
)
assert 0 == result.exit_code
compiled_schema_result = json.loads(result.output)
with open(pkg_resources.resource_filename(
'cds_dojson.schemas', 'records/project-v1.0.0.json'), 'r') as f:
compile_schema_expected = json.load(f)
assert compile_schema_expected == compiled_schema_result
def _get_system_wiki_list(self):
"""Helper function that enumerates all 'system' wikis. The
list is combined of default wiki pages and pages that are
bundled with Bloodhound dashboard and search plugins"""
from bhdashboard import wiki
paths = [resource_filename('trac.wiki',
'default-pages')] + \
[resource_filename('bhdashboard',
'default-pages')] + \
[resource_filename('bhsearch',
'default-pages')]
pages = []
original_pages = []
for path in paths:
for page in os.listdir(path):
filename = os.path.join(path, page)
page = unicode_unquote(page.encode('utf-8'))
if os.path.isfile(filename):
original_pages.append(page)
for original_name in original_pages:
if original_name.startswith('Trac'):
new_name = wiki.new_name(original_name)
if not new_name:
continue
if new_name in original_pages:
continue
name = new_name
# original trac wikis should also be included in the list
pages.append(original_name)
else:
name = original_name
pages.append(name)
return pages
def test_generator_glycine_fixq():
system = get_system_glycine()
fn_pars = pkg_resources.resource_filename(__name__, '../../data/test/parameters_glycine_fixq.txt')
ff = ForceField.generate(system, fn_pars)
assert len(ff.parts) == 1 #Non-periodic, so only one part
part_pair_ei = ff.part_pair_ei
# check part settings
assert part_pair_ei.pair_pot.alpha == 0.0
# check charges and atomic radii
ac = {1:0.2, 6:0.5, 7:-1.0, 8:-0.5 } #Charges
ar = {1:1.2*angstrom, 6: 1.7*angstrom, 7: 1.55*angstrom, 8: 1.50*angstrom} #Radii
for i in range(system.natom):
assert abs(system.charges[i] - ac[system.numbers[i]]) < 1e-5
assert abs(system.radii[i] - ar[system.numbers[i]]) < 1e-5
system = get_system_glycine()
log.set_level(log.silent)
fn_pars = pkg_resources.resource_filename(__name__, '../../data/test/parameters_glycine_fixq.txt')
ff2 = ForceField.generate(system, fn_pars)
log.set_level(log.debug)
# check charges and atomic radii
ac = {1:0.2, 6:0.5, 7:-1.0, 8:-0.5 } #Charges
ar = {1:1.2*angstrom, 6: 1.7*angstrom, 7: 1.55*angstrom, 8: 1.50*angstrom} #Radii
for i in range(system.natom):
assert abs(system.charges[i] - ac[system.numbers[i]]) < 1e-5
assert abs(system.radii[i] - ar[system.numbers[i]]) < 1e-5
energy = ff.compute()
energy2 = ff2.compute()
assert abs(energy - energy2) < 1e-3
def add_panel(self, metric_list, dashboard_name="son-monitor", title=None, graph_type="lines"):
"""
add a graph panel to the son-monitor dashboard
:param:metric_list: list of dictionaries from the nsd [{"desc":"", "metric":""}, ...]
:return:
"""
url = self.construct_api_url('dashboards/db/{0}'.format(dashboard_name))
ret = self.session.get(url)
dashboard = ret.json()
dashboard = dashboard['dashboard']
# add a new row
src_path = os.path.join('grafana', 'grafana_row.json')
srcfile = pkg_resources.resource_filename(__name__, src_path)
dashboard['rows'].append(json.load(open(srcfile)))
row_index = len(dashboard['rows']) - 1
# add a new panel to the row
src_path = os.path.join('grafana', 'grafana_panel.json')
srcfile = pkg_resources.resource_filename(__name__, src_path)
new_panel = json.load(open(srcfile))
new_panel['id'] = row_index + 1
if graph_type == "lines":
new_panel['bars'] = False
new_panel['lines'] = True
elif graph_type == "bars":
new_panel['bars'] = True
new_panel['lines'] = False
dashboard['rows'][row_index]['panels'].append(new_panel)
panel_index = len(dashboard['rows'][row_index]['panels']) - 1
if title is None:
# set panel title (first word of metric description)
# need to make a copy of the list, because otherwise the original metric_list seems to get corrupted
new_list = list(copy.deepcopy(metric_list))
title = new_list[0]['desc'].split(' ')[0]
dashboard['rows'][row_index]['panels'][panel_index]['title'] = title
for metric in metric_list:
# add a new target(graph) to the panel
src_path = os.path.join('grafana', 'grafana_target.json')
srcfile = pkg_resources.resource_filename(__name__, src_path)
new_target = json.load(open(srcfile))
target_index = len(dashboard['rows'][row_index]['panels'][panel_index]['targets'])
new_target['refId'] = chr(ord('A') + target_index)
dashboard['rows'][row_index]['panels'][panel_index]['targets'].append(new_target)
query = metric['metric']
dashboard['rows'][row_index]['panels'][panel_index]['targets'][target_index]['expr'] = query.replace('"',
'\"')
legend = metric['desc']
dashboard['rows'][row_index]['panels'][panel_index]['targets'][target_index]['legendFormat'] = legend
logging.info('installed metric: {0} {1}'.format(legend, metric))
url = self.construct_api_url('dashboards/db')
ret = self.session.post(url, json={'dashboard': dashboard, 'overwrite': True})
logging.info('post new dashboard: {0}'.format(ret))
def TestExample(self):
"""
Sets all variables corresponding to --test in the methods script
"""
self.GPAentryVariable.set(str(os.path.join(resource_filename(__name__, 'exampledata'), 'Gene_presence_absence.csv')))
self.TraitsentryVariable.set(str(os.path.join(resource_filename(__name__, 'exampledata'), 'Tetracycline_resistance.csv')))
self.TreeentryVariable.set("")
self.RestrictVariable.set("")
self.Outputdir.set("./")
self.maxhitsvar.set("")
self.delimvar.set(",")
self.scvar.set("15")
self.notimevar.set(0)
self.writetreevar.set(0)
self.permvar.set("0")
self.pVar.set(1)
self.pBVar.set(0)
self.pBHVar.set(0)
self.pPWVar.set(0)
self.pEPWVar.set(1)
self.pNaive.set("0.05")
self.pBonf.set("1.0")
self.pBH.set("1.0")
self.pPW.set("1.0")
self.pEPW.set("0.05")
self.pPerm.set("1.0")
def stat_fastqc(workflow, conf): # collect raw reads quality and GC contents
"""
long: generate long pages or not
"""
sums = []
for raw, target in conf.sample_pairs:
if conf.pe:
sums.append(target[0] + "_100k_fastqc/fastqc_data.txt")
else:
sums.append(target + "_100k_fastqc/fastqc_data.txt")
attach_back(workflow,
PythonCommand(
json_fastqc,
input={"fastqc_summaries": sums},
output={"json": conf.json_prefix + "_fastqc.json"},
param={"ids": conf.sample_bases,
"id": conf.id},
name = "collect fastqc results"))
if conf.long: ## prepare long document images and tex
attach_back(workflow,
PythonCommand(fastqc_detailed_figure,
input = {"dbaccessor": resource_filename("chilin2.modules.dbaccessor", "ChiLinQC.db"),
"template": resource_filename("chilin2.modules.summary", "R_culmulative_plot.R"),
"json": conf.json_prefix + "_fastqc.json"},
output = {"R": conf.prefix + "_raw_sequence_qc.R",
"pdf": conf.prefix + "_raw_sequence_qc.pdf"},
param={"ids": conf.sample_bases}))
def config_obj(configfile=None, modulename=None):
defaults = config_defaults()
if modulename:
mod_globals = dict()
lastdot = modulename.rfind(".")
firstdot = modulename.find(".")
packagename = modulename[:lastdot]
top_level_package = modulename[:firstdot]
modname = modulename[lastdot + 1 :]
modfile = pkg_resources.resource_filename(packagename, modname + ".cfg")
if not os.path.exists(modfile):
modfile = pkg_resources.resource_filename(packagename, modname)
if os.path.isdir(modfile):
configfiles = glob.glob(os.path.join(modfile, "*.cfg"))
else:
configfiles = [modfile]
configdata = ConfigObj(unrepr=True)
top_level_dir = pkg_resources.resource_filename(top_level_package, "")[:-1].replace("\\", "/")
package_dir = pkg_resources.resource_filename(packagename, "")[:-1].replace("\\", "/")
defaults.update(dict(top_level_dir=top_level_dir, package_dir=package_dir))
configdata.merge(dict(DEFAULT=defaults))
for file in configfiles:
configdata2 = ConfigObj(file, unrepr=True)
configdata2.merge(dict(DEFAULT=defaults))
configdata.merge(configdata2)
if configfile:
if modulename:
configdata2 = ConfigObj(configfile, unrepr=True)
configdata2.merge(dict(DEFAULT=defaults))
configdata.merge(configdata2)
else:
configdata = ConfigObj(configfile, unrepr=True)
return configdata
def test_checkpoint(self):
molecule = load_molecule_cp2k(
pkg_resources.resource_filename(__name__, "../data/test/cp2k/pentane/sp.out"),
pkg_resources.resource_filename(__name__, "../data/test/cp2k/pentane/freq.out"))
nma1 = NMA(molecule)
with tmpdir(__name__, 'test_checkpoint') as dn:
fn_out = os.path.join(dn, 'test.chk')
nma1.write_to_file(fn_out)
nma2 = NMA.read_from_file(fn_out)
self.assertEqual(nma1.freqs.shape, nma2.freqs.shape)
self.assertEqual(nma1.modes.shape, nma2.modes.shape)
self.assertEqual(nma1.masses.shape, nma2.masses.shape)
self.assertEqual(nma1.numbers.shape, nma2.numbers.shape)
self.assertEqual(nma1.coordinates.shape, nma2.coordinates.shape)
self.assertEqual(nma1.inertia_tensor.shape, nma2.inertia_tensor.shape)
self.assert_(abs(nma1.freqs - nma2.freqs).max()/abs(nma1.freqs).max() < 1e-15)
self.assert_(abs(nma1.modes - nma2.modes).max()/abs(nma1.modes).max() < 1e-15)
self.assert_(abs(nma1.masses - nma2.masses).max()/abs(nma1.masses).max() < 1e-15)
self.assert_(abs(nma1.coordinates - nma2.coordinates).max()/abs(nma1.coordinates).max() < 1e-15)
self.assert_(abs(nma1.inertia_tensor - nma2.inertia_tensor).max()/abs(nma1.inertia_tensor).max() < 1e-15)
self.assert_((nma1.numbers==nma2.numbers).all())
self.assertAlmostEqual(nma1.mass, nma2.mass)
self.assertAlmostEqual(nma1.energy, nma2.energy)
self.assertEqual(nma1.multiplicity, nma2.multiplicity)
self.assertEqual(nma1.symmetry_number, nma2.symmetry_number)
def test_load_indices(self):
blocks = load_indices(pkg_resources.resource_filename(__name__, "../data/test/an/fixed.07.txt"), groups=True)
self.assertEqual(blocks, [[3,2,6]])
blocks = load_indices(pkg_resources.resource_filename(__name__, "../data/test/an/fixed.07.txt"))
self.assertEqual(blocks, [3,2,6])
blocks = load_indices(pkg_resources.resource_filename(__name__, "../data/test/an/fixed.08.txt"))
self.assertEqual(blocks, [5,4,8])
def test_load_molecule_vasp_53(self):
molecule = load_molecule_vasp(
pkg_resources.resource_filename(__name__, "../data/test/lucas/vasp_5_3_5_complex/CONTCAR_opt"),
pkg_resources.resource_filename(__name__, "../data/test/lucas/vasp_5_3_5_complex/OUTCAR_freq"))
# contcar
assert molecule.numbers[0] == 6
assert (molecule.numbers[1:] == 1).all()
assert molecule.size == 5
assert molecule.unit_cell.matrix[0,0] == 15.0*angstrom
assert molecule.unit_cell.matrix[1,2] == 0.0
self.assertAlmostEqual(molecule.coordinates[0,0]/angstrom, 7.15840, 3)
self.assertAlmostEqual(molecule.coordinates[1,2]/angstrom, 8.44640, 2) #?
self.assertAlmostEqual(molecule.coordinates[-1,-1]/angstrom, 6.95131, 2) #?
# outcar_freq
assert molecule.masses[0] == 12.011*amu
assert (molecule.masses[1:] == 1.000*amu).all()
hunit = electronvolt/angstrom**2
assert molecule.hessian[0,0] == 53.624756*hunit
assert molecule.hessian[-1,-1] == 31.299419*hunit
self.assertAlmostEqual(molecule.hessian[2,5], 0.5*(-7.551817 + 3.319877)*hunit)
assert molecule.energy == -24.11901936*electronvolt
gunit = electronvolt/angstrom
assert molecule.gradient[0, 0] == 0.096977*gunit
assert molecule.gradient[2, 1] == 0.100275*gunit
assert molecule.gradient[-1, -1] == -0.212810*gunit
def test_load_molecule_vasp_5_3_5_gamma(self):
molecule = load_molecule_vasp(
pkg_resources.resource_filename(__name__, "../data/test/julianna/vasp_5_3_5_gamma/CONTCAR_opt"),
pkg_resources.resource_filename(__name__, "../data/test/julianna/vasp_5_3_5_gamma/OUTCAR_freq"))
# contcar
assert molecule.numbers[0] == 6
assert (molecule.numbers[1:] == 1).all()
assert molecule.size == 5
assert molecule.unit_cell.matrix[0,0] == 15.0*angstrom
assert molecule.unit_cell.matrix[1,2] == 0.0
self.assertAlmostEqual(molecule.coordinates[0,0]/angstrom, 7.15782, 3)
self.assertAlmostEqual(molecule.coordinates[1,2]/angstrom, 8.44278, 1) #??
self.assertAlmostEqual(molecule.coordinates[-1,-1]/angstrom, 6.95393, 2) #?
# outcar_freq
assert molecule.masses[0] == 12.011*amu
assert (molecule.masses[1:] == 1.000*amu).all()
hunit = electronvolt/angstrom**2
assert molecule.hessian[0,0] == 47.756815*hunit
assert molecule.hessian[-1,-1] == 31.561376*hunit
self.assertAlmostEqual(molecule.hessian[2,5], 0.5*(-2.265871 + -3.645039)*hunit)
assert molecule.energy == -24.12364199*electronvolt
gunit = electronvolt/angstrom
assert molecule.gradient[0, 0] == -0.005459*gunit
assert molecule.gradient[2, 1] == -0.008215*gunit
assert molecule.gradient[-1, -1] == 0.003424*gunit
def installApache(self, document_root, ip=None, port=None):
if ip is None:
ip=self.getGlobalIPv6Address()
if port is None:
port = '9080'
apache_config = dict(
pid_file=os.path.join(self.run_directory, 'httpd.pid'),
lock_file=os.path.join(self.run_directory, 'httpd.lock'),
ip=ip,
port=port,
error_log=os.path.join(self.log_directory, 'httpd-error.log'),
access_log=os.path.join(self.log_directory, 'httpd-access.log'),
document_root=document_root,
php_ini_dir=self.etc_directory
)
config_file = self.createConfigurationFile('httpd.conf',
self.substituteTemplate(pkg_resources.resource_filename(__name__,
'template/apache.in'), apache_config))
self.path_list.append(config_file)
php_ini = pkg_resources.resource_filename(__name__, 'template/php.ini.in')
if self.options.has_key('php_ini'):
php_ini = os.path.join(self.options['php_ini'], 'php.ini.in')
self.path_list.append(self.createConfigurationFile('php.ini',
self.substituteTemplate(php_ini, dict(tmp_directory=self.tmp_directory))))
self.path_list.extend(zc.buildout.easy_install.scripts([(
'httpd',
__name__ + '.apache', 'runApache')], self.ws,
sys.executable, self.wrapper_directory, arguments=[
dict(
required_path_list=[],
binary=self.options['httpd_binary'],
config=config_file
)
]))
return 'http://[%s]:%s' % (ip, port)
def test_multi_proc(self):
json_conf = configurator.to_json(None)
json_conf["pick"]["run_options"]["procs"] = 2
json_conf["pick"]["files"]["input"] = pkg_resources.resource_filename("Mikado.tests",
"mikado_prepared.gtf")
json_conf["pick"]["files"]["output_dir"] = tempfile.gettempdir()
json_conf["pick"]["files"]["loci_out"] = "mikado.multiproc.loci.gff3"
json_conf["pick"]["files"]["subloci_out"] = "mikado.multiproc.subloci.gff3"
json_conf["pick"]["files"]["monoloci_out"] = "mikado.multiproc.monoloci.gff3"
json_conf["pick"]["files"]["log"] = "mikado.multiproc.log"
json_conf["db_settings"]["db"] = pkg_resources.resource_filename("Mikado.tests", "mikado.db")
json_conf["log_settings"]["log_level"] = "WARNING"
pick_caller = picker.Picker(json_conf=json_conf)
with self.assertRaises(SystemExit), self.assertLogs("main_logger", "INFO"):
pick_caller()
self.assertTrue(os.path.exists(os.path.join(tempfile.gettempdir(), "mikado.multiproc.loci.gff3")))
with to_gff(os.path.join(tempfile.gettempdir(), "mikado.multiproc.loci.gff3")) as inp_gff:
lines = [_ for _ in inp_gff if not _.header is True]
self.assertGreater(len(lines), 0)
self.assertGreater(len([_ for _ in lines if _.is_transcript is True]), 0)
self.assertGreater(len([_ for _ in lines if _.feature == "mRNA"]), 0)
self.assertGreater(len([_ for _ in lines if _.feature == "CDS"]), 0)
[os.remove(_) for _ in glob.glob(os.path.join(tempfile.gettempdir(), "mikado.multiproc.") + "*")]
def test_cross_reference(self):
modelfile = resource_filename('desidatamodel.test', 't/fits_file.rst')
f = DataModel(modelfile, os.path.dirname(modelfile))
line = "See :doc:`Other file <fits_file>`"
ref = f._cross_reference(line)
self.assertEqual(ref, resource_filename('desidatamodel.test',
't/fits_file.rst'))
from gradio.tunneling import create_tunnel
from gradio import encryptor
from gradio import queue
from functools import wraps
import io
INITIAL_PORT_VALUE = int(os.getenv(
'GRADIO_SERVER_PORT', "7860")) # The http server will try to open on port 7860. If not available, 7861, 7862, etc.
TRY_NUM_PORTS = int(os.getenv(
'GRADIO_NUM_PORTS', "100")) # Number of ports to try before giving up and throwing an exception.
LOCALHOST_NAME = os.getenv(
'GRADIO_SERVER_NAME', "127.0.0.1")
GRADIO_API_SERVER = "https://api.gradio.app/v1/tunnel-request"
GRADIO_FEATURE_ANALYTICS_URL = "https://api.gradio.app/gradio-feature-analytics/"
STATIC_TEMPLATE_LIB = pkg_resources.resource_filename("gradio", "frontend/")
STATIC_PATH_LIB = pkg_resources.resource_filename("gradio", "frontend/static")
VERSION_FILE = pkg_resources.resource_filename("gradio", "version.txt")
with open(VERSION_FILE) as version_file:
GRADIO_STATIC_ROOT = "https://gradio.s3-us-west-2.amazonaws.com/" + \
version_file.read().strip() + "/static/"
app = Flask(__name__,
template_folder=STATIC_TEMPLATE_LIB,
static_folder="",
static_url_path="/none/")
CORS(app)
cache_buster = CacheBuster(
config={'extensions': ['.js', '.css'], 'hash_size': 5})
cache_buster.init_app(app)
app.secret_key = os.getenv("GRADIO_KEY", "secret")
# -*- coding: utf-8 -*-
from typing import Dict
import os
import pkg_resources
from bag.design import Module
yaml_file = pkg_resources.resource_filename(
__name__, os.path.join('netlist_info', 'qdr_top.yaml'))
# noinspection PyPep8Naming
class bag_serdes_ec__qdr_top(Module):
"""Module for library bag_serdes_ec cell qdr_top.
Fill in high level description here.
"""
def __init__(self, bag_config, parent=None, prj=None, **kwargs):
Module.__init__(self,
bag_config,
yaml_file,
parent=parent,
prj=prj,
**kwargs)
@classmethod
def get_params_info(cls):
# type: () -> Dict[str, str]
return dict(
def __init__(self, *args):
QtGui.QMainWindow.__init__(*(self,) + args)
self.config = config.read()
self.resize(1000, 600)
self.setWindowTitle(NAME)
self.debug_dialog = None
self.debug_lines = []
self.about_dialog = None
self.connection_dialog = None
self.preferences_dialog = None
# network
self.network = Network()
self.network.statusChanged.connect(self._network_status_changed)
self.network.messageFromWeechat.connect(self._network_weechat_msg)
# list of buffers
self.list_buffers = BufferListWidget()
self.list_buffers.currentRowChanged.connect(self._buffer_switch)
# default buffer
self.buffers = [Buffer()]
self.stacked_buffers = QtGui.QStackedWidget()
self.stacked_buffers.addWidget(self.buffers[0].widget)
# splitter with buffers + chat/input
splitter = QtGui.QSplitter()
splitter.addWidget(self.list_buffers)
splitter.addWidget(self.stacked_buffers)
self.setCentralWidget(splitter)
if self.config.getboolean('look', 'statusbar'):
self.statusBar().visible = True
# actions for menu and toolbar
actions_def = {
'connect': [
'network-connect.png', 'Connect to WeeChat',
'Ctrl+O', self.open_connection_dialog],
'disconnect': [
'network-disconnect.png', 'Disconnect from WeeChat',
'Ctrl+D', self.network.disconnect_weechat],
'debug': [
'edit-find.png', 'Debug console window',
'Ctrl+B', self.open_debug_dialog],
'preferences': [
'preferences-other.png', 'Preferences',
'Ctrl+P', self.open_preferences_dialog],
'about': [
'help-about.png', 'About',
'Ctrl+H', self.open_about_dialog],
'save connection': [
'document-save.png', 'Save connection configuration',
'Ctrl+S', self.save_connection],
'quit': [
'application-exit.png', 'Quit application',
'Ctrl+Q', self.close],
}
self.actions = {}
for name, action in list(actions_def.items()):
self.actions[name] = QtGui.QAction(
QtGui.QIcon(
resource_filename(__name__, 'data/icons/%s' % action[0])),
name.capitalize(), self)
self.actions[name].setStatusTip(action[1])
self.actions[name].setShortcut(action[2])
self.actions[name].triggered.connect(action[3])
# menu
self.menu = self.menuBar()
menu_file = self.menu.addMenu('&File')
menu_file.addActions([self.actions['connect'],
self.actions['disconnect'],
self.actions['preferences'],
self.actions['save connection'],
self.actions['quit']])
menu_window = self.menu.addMenu('&Window')
menu_window.addAction(self.actions['debug'])
menu_help = self.menu.addMenu('&Help')
menu_help.addAction(self.actions['about'])
self.network_status = QtGui.QLabel()
self.network_status.setFixedHeight(20)
self.network_status.setFixedWidth(200)
self.network_status.setContentsMargins(0, 0, 10, 0)
self.network_status.setAlignment(QtCore.Qt.AlignRight)
if hasattr(self.menu, 'setCornerWidget'):
self.menu.setCornerWidget(self.network_status,
QtCore.Qt.TopRightCorner)
self.network_status_set(self.network.status_disconnected)
# toolbar
toolbar = self.addToolBar('toolBar')
toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
toolbar.addActions([self.actions['connect'],
self.actions['disconnect'],
self.actions['debug'],
self.actions['preferences'],
self.actions['about'],
self.actions['quit']])
self.buffers[0].widget.input.setFocus()
# open debug dialog
if self.config.getboolean('look', 'debug'):
self.open_debug_dialog()
# auto-connect to relay
if self.config.getboolean('relay', 'autoconnect'):
self.network.connect_weechat(self.config.get('relay', 'server'),
self.config.get('relay', 'port'),
self.config.getboolean('relay',
'ssl'),
self.config.get('relay', 'password'),
self.config.get('relay', 'lines'))
self.show()
"""Find position to insert a buffer in list."""
index = -1
if next_buffer == '0x0':
index = len(self.buffers)
else:
index = [i for i, b in enumerate(self.buffers)
if b.pointer() == next_buffer]
if index:
index = index[0]
if index < 0:
print('Warning: unable to find position for buffer, using end of '
'list by default')
index = len(self.buffers)
return index
def closeEvent(self, event):
"""Called when QWeeChat window is closed."""
self.network.disconnect_weechat()
if self.debug_dialog:
self.debug_dialog.close()
config.write(self.config)
QtGui.QMainWindow.closeEvent(self, event)
app = QtGui.QApplication(sys.argv)
app.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))
app.setWindowIcon(QtGui.QIcon(
resource_filename(__name__, 'data/icons/weechat.png')))
main = MainWindow()
sys.exit(app.exec_())
class TelegramChannel(EFBChannel):
"""
EFB Channel - Telegram (Master)
Based on python-telegram-bot, Telegram Bot API
Author: Eana Hufwe <https://github.com/blueset>
Configuration file example:
.. code-block:: yaml
token: "12345678:1a2b3c4d5e6g7h8i9j"
admins:
- 102938475
- 91827364
flags:
join_msg_threshold_secs: 10
multiple_slave_chats: false
"""
def get_chats(self) -> List[EFBChat]:
raise EFBOperationNotSupported()
def get_chat(self,
chat_uid: ChatID,
member_uid: Optional[ChatID] = None) -> EFBChat:
raise EFBOperationNotSupported()
def get_chat_picture(self, chat: EFBChat) -> IO[bytes]:
raise EFBOperationNotSupported()
# Meta Info
channel_name = "Telegram Master"
channel_emoji = "✈"
channel_id = ModuleID("blueset.telegram")
channel_type = ChannelType.Master
supported_message_types = {
MsgType.Text, MsgType.File, MsgType.Audio, MsgType.Image, MsgType.Link,
MsgType.Location, MsgType.Sticker, MsgType.Video, MsgType.Animation
}
__version__ = __version__
# Data
_stop_polling = False
timeout_count = 0
# Constants
config: dict
# Translator
translator: NullTranslations = translation("efb_telegram_master",
resource_filename(
'efb_telegram_master',
'locale'),
fallback=True)
locale: Optional[str] = None
# RPC server
rpc_server: SimpleXMLRPCServer = None
def __init__(self, instance_id: InstanceID = None):
"""
Initialization.
"""
super().__init__(instance_id)
# Check PIL support for WebP
Image.init()
if 'WEBP' not in Image.ID:
raise EFBException(
self._(
"WebP support of Pillow is required.\n"
"Please refer to Pillow Documentation for instructions.\n"
"https://pillow.readthedocs.io/"))
# Suppress debug logs from dependencies
logging.getLogger('requests').setLevel(logging.CRITICAL)
logging.getLogger('urllib3').setLevel(logging.CRITICAL)
logging.getLogger('telegram.bot').setLevel(logging.CRITICAL)
logging.getLogger(
'telegram.vendor.ptb_urllib3.urllib3.connectionpool').setLevel(
logging.CRITICAL)
# Set up logger
self.logger: logging.Logger = logging.getLogger(__name__)
# Load configs
self.load_config()
# Load predefined MIME types
mimetypes.init(files=["mimetypes"])
# Initialize managers
self.flag: ExperimentalFlagsManager = ExperimentalFlagsManager(self)
self.db: DatabaseManager = DatabaseManager(self)
self.chat_dest_cache: ChatDestinationCache = ChatDestinationCache(
self.flag("send_to_last_chat"))
self.bot_manager: TelegramBotManager = TelegramBotManager(self)
self.chat_binding: ChatBindingManager = ChatBindingManager(self)
self.commands: CommandsManager = CommandsManager(self)
self.master_messages: MasterMessageProcessor = MasterMessageProcessor(
self)
self.slave_messages: SlaveMessageProcessor = SlaveMessageProcessor(
self)
if not self.flag('auto_locale'):
self.translator = translation("efb_telegram_master",
resource_filename(
'efb_telegram_master', 'locale'),
fallback=True)
# Basic message handlers
non_edit_filter = Filters.update.message | Filters.update.channel_post
self.bot_manager.dispatcher.add_handler(
CommandHandler("start", self.start, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("help", self.help, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("info", self.info, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.void_callback_handler, pattern="void"))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.bot_manager.session_expired))
self.bot_manager.dispatcher.add_handler(
CommandHandler("react", self.react, filters=non_edit_filter))
self.bot_manager.dispatcher.add_error_handler(self.error)
self.rpc_utilities = RPCUtilities(self)
@property
def _(self):
return self.translator.gettext
@property
def ngettext(self):
return self.translator.ngettext
def load_config(self):
"""
Load configuration from path specified by the framework.
Configuration file is in YAML format.
"""
config_path = efb_utils.get_config_path(self.channel_id)
if not config_path.exists():
raise FileNotFoundError(
self._("Config File does not exist. ({path})").format(
path=config_path))
with config_path.open() as f:
data = YAML().load(f)
# Verify configuration
if not isinstance(data.get('token', None), str):
raise ValueError(self._('Telegram bot token must be a string'))
if isinstance(data.get('admins', None), int):
data['admins'] = [data['admins']]
if isinstance(data.get('admins', None),
str) and data['admins'].isdigit():
data['admins'] = [int(data['admins'])]
if not isinstance(data.get('admins', None),
list) or len(data['admins']) < 1:
raise ValueError(
self.
_("Admins' user IDs must be a list of one number or more."
))
for i in range(len(data['admins'])):
if isinstance(data['admins'][i],
str) and data['admins'][i].isdigit():
data['admins'][i] = int(data['admins'][i])
if not isinstance(data['admins'][i], int):
raise ValueError(
self.
_('Admin ID is expected to be an int, but {data} is found.'
).format(data=data['admins'][i]))
self.config = data.copy()
def info(self, update: Update, context: CallbackContext):
"""
Show info of the current telegram conversation.
Triggered by `/info`.
"""
if update.message.chat.type != telegram.Chat.PRIVATE: # Group message
msg = self.info_group(update)
elif update.effective_message.forward_from_chat and \
update.effective_message.forward_from_chat.type == 'channel': # Forwarded channel command.
msg = self.info_channel(update)
else: # Talking to the bot.
msg = self.info_general()
update.message.reply_text(msg)
def info_general(self):
"""Generate string for information of the current running EFB instance."""
msg = self.ngettext(
"This is EFB Telegram Master Channel {version}, running on EFB {fw_version}.\n"
"{count} slave channel activated:",
"This is EFB Telegram Master Channel {version}, running on EFB {fw_version}.\n"
"{count} slave channels activated:",
len(coordinator.slaves)).format(
version=self.__version__,
fw_version=ehforwarderbot.__version__,
count=len(coordinator.slaves))
for i in coordinator.slaves:
msg += "\n- %s %s (%s, %s)" % (coordinator.slaves[i].channel_emoji,
coordinator.slaves[i].channel_name,
i,
coordinator.slaves[i].__version__)
if coordinator.middlewares:
msg += self.ngettext("\n\n{count} middleware activated:",
"\n\n{count} middlewares activated:",
len(coordinator.middlewares)).format(
count=len(coordinator.middlewares))
for i in coordinator.middlewares:
msg += "\n- %s (%s, %s)" % (i.middleware_name, i.middleware_id,
i.__version__)
return msg
def info_channel(self, update):
"""Generate string for chat linking info of a channel."""
chat = update.effective_message.forward_from_chat
links = self.db.get_chat_assoc(
master_uid=etm_utils.chat_id_to_str(self.channel_id, chat.id))
if links: # Linked chat
msg = self._("The channel {group_name} ({group_id}) is linked to:") \
.format(group_name=chat.title,
group_id=chat.id)
for i in links:
channel_id, chat_id = etm_utils.chat_id_str_to_id(i)
d = self.chat_binding.get_chat_from_db(channel_id, chat_id)
if d:
msg += "\n- %s" % ETMChat(db=self.db, chat=d).full_name
else:
msg += self._(
"\n- {channel_emoji} {channel_name}: Unknown chat ({chat_id})"
).format(channel_emoji=coordinator.slaves[channel_id].
channel_emoji,
channel_name=coordinator.slaves[channel_id].
channel_name,
chat_id=chat_id)
else:
msg = self._("The channel {group_name} ({group_id}) is "
"not linked to any remote chat. ").format(
group_name=chat.title, group_id=chat.id)
return msg
def info_group(self, update):
"""Generate string for chat linking info of a group."""
links = self.db.get_chat_assoc(master_uid=etm_utils.chat_id_to_str(
self.channel_id, update.message.chat_id))
if links: # Linked chat
msg = self._(
"The group {group_name} ({group_id}) is linked to:").format(
group_name=update.message.chat.title,
group_id=update.message.chat_id)
for i in links:
channel_id, chat_id = etm_utils.chat_id_str_to_id(i)
d = self.chat_binding.get_chat_from_db(channel_id, chat_id)
if d:
msg += "\n- %s (%s:%s)" % (ETMChat(
db=self.db, chat=d).full_name, d.module_id, d.chat_uid)
else:
if channel_id not in coordinator.slaves:
msg += self._(
"\n- Unknown channel {channel_id}: {chat_id}"
).format(channel_id=channel_id, chat_id=chat_id)
else:
msg += self._(
"\n- {channel_emoji} {channel_name}: Unknown chat ({chat_id})"
).format(channel_emoji=coordinator.slaves[channel_id].
channel_emoji,
channel_name=coordinator.slaves[channel_id].
channel_name,
chat_id=chat_id)
else:
msg = self._(
"The group {group_name} ({group_id}) is not linked to any remote chat. "
"To link one, use /link.").format(
group_name=update.message.chat.title,
group_id=update.message.chat_id)
return msg
def start(self, update: Update, context: CallbackContext):
"""
Process bot command `/start`.
"""
if context.args: # Group binding command
if update.effective_message.chat.type != telegram.Chat.PRIVATE or \
(update.effective_message.forward_from_chat and
update.effective_message.forward_from_chat.type == telegram.Chat.CHANNEL):
self.chat_binding.link_chat(update, context.args)
else:
self.bot_manager.send_message(
update.effective_chat.id,
self.
_('You cannot link remote chats to here. Please try again.'
))
else:
txt = self._(
"This is EFB Telegram Master Channel.\n\n"
"To learn more, please visit https://github.com/blueset/efb-telegram-master ."
)
self.bot_manager.send_message(update.effective_chat.id, txt)
def react(self, update: Update, context: CallbackContext):
"""React to a message."""
message: Message = update.effective_message
reaction = None
args = message.text and message.text.split(' ', 1)
if args and len(args) > 1:
reaction = args[1]
if not message.reply_to_message:
message.reply_html(
self._("Reply to a message with this command and an emoji "
"to send a reaction. "
"Ex.: <code>/react �</code>.\n"
"Send <code>/react -</code> to remove your reaction "
"from a message."))
return
target: Message = update.message.reply_to_message
msg_log = self.db.get_msg_log(
master_msg_id=etm_utils.message_id_to_str(
chat_id=target.chat_id, message_id=target.message_id))
if msg_log is None:
message.reply_text(
self.
_("The message you replied to is not recorded in ETM database. "
"You cannot react to this message."))
return
if not reaction:
if msg_log.pickle is None:
message.reply_text(
self.
_("Reactors of this message are not recorded in database."
))
return
msg_log_obj: ETMMsg = ETMMsg.unpickle(msg_log.pickle, self.db)
reactors = msg_log_obj.reactions
if not reactors:
message.reply_html(
self._("This message has no reactions yet. "
"Reply to a message with this command and "
"an emoji to send a reaction. "
"Ex.: <code>/react �</code>."))
return
else:
text = ""
for key, values in reactors.items():
if not values:
continue
text += f"{key}:\n"
for j in values:
text += f" {j.display_name}\n"
text = text.strip()
message.reply_text(text)
return
message_id = msg_log.slave_message_id
channel_id, chat_uid = etm_utils.chat_id_str_to_id(
msg_log.slave_origin_uid)
if channel_id not in coordinator.slaves:
message.reply_text(
self.
_("The slave channel involved in this message ({}) is not available. "
"You cannot react to this message.").format(channel_id))
return
channel = coordinator.slaves[channel_id]
if channel.suggested_reactions is None:
message.reply_text(
self.
_("The channel involved in this message ({}) does not accept reactions. "
"You cannot react to this message.").format(channel_id))
return
try:
chat_obj = channel.get_chat(chat_uid)
except EFBChatNotFound:
message.reply_text(
self._("The chat involved in this message ({}) is not found. "
"You cannot react to this message.").format(chat_uid))
return
if reaction == "-":
reaction = None
try:
coordinator.send_status(
EFBReactToMessage(chat=chat_obj,
msg_id=message_id,
reaction=reaction))
except EFBOperationNotSupported:
message.reply_text(
self._("You cannot react anything to this message."))
return
except EFBMessageReactionNotPossible:
prompt = self._("{} is not accepted as a reaction to this message."
).format(reaction)
if channel.suggested_reactions:
prompt += "\n" + self._("You may want to try: {}").format(
", ".join(channel.suggested_reactions[:10]))
message.reply_text(prompt)
return
def help(self, update: Update, context: CallbackContext):
txt = self._(
"EFB Telegram Master Channel\n"
"/link\n"
" Link a remote chat to an empty Telegram group.\n"
" Followed by a regular expression to filter results.\n"
"/chat\n"
" Generate a chat head to start a conversation.\n"
" Followed by a regular expression to filter results.\n"
"/extra\n"
" List all additional features from slave channels.\n"
"/unlink_all\n"
" Unlink all remote chats in this chat.\n"
"/info\n"
" Show information of the current Telegram chat.\n"
"/react [emoji]\n"
" React to a message with an emoji, or show a list of members reacted.\n"
"/update_info\n"
" Update name and profile picture a linked Telegram group.\n"
" Only works in singly linked group where the bot is an admin.\n"
"/help\n"
" Print this command list.")
self.bot_manager.send_message(update.message.from_user.id, txt)
def poll(self):
"""
Message polling process.
"""
self.bot_manager.polling()
def error(self, update: Update, context: CallbackContext):
"""
Print error to console, and send error message to first admin.
Triggered by python-telegram-bot error callback.
"""
error = context.error
if "(409)" in str(error):
msg = self._(
'Conflicted polling detected. If this error persists, '
'please ensure you are running only one instance of this Telegram bot.'
)
self.logger.critical(msg)
self.bot_manager.send_message(self.config['admins'][0], msg)
return
if "Invalid server response" in str(error) and not update:
self.logger.error(
"Boom! Telegram API is no good. (Invalid server response.)")
return
# noinspection PyBroadException
try:
raise error
except telegram.error.Unauthorized:
self.logger.error(
"The bot is not authorised to send update:\n%s\n%s",
str(update), str(error))
except telegram.error.BadRequest as e:
if e.message == "Message is not modified" and update.callback_query:
self.logger.error("Chill bro, don't click that fast.")
else:
self.logger.error("Message request is invalid.\n%s\n%s",
str(update), str(error))
self.bot_manager.send_message(
self.config['admins'][0],
self._("Message request is invalid.\n{error}\n"
"<code>{update}</code>").format(
error=html.escape(str(error)),
update=html.escape(str(update))),
parse_mode="HTML")
except (telegram.error.TimedOut, telegram.error.NetworkError):
self.timeout_count += 1
self.logger.error(
"Poor internet connection detected.\n"
"Number of network error occurred since last startup: %s\n%s\nUpdate: %s",
self.timeout_count, str(error), str(update))
if update is not None and isinstance(
getattr(update, "message", None), telegram.Message):
update.message.reply_text(self._(
"This message is not processed due to poor internet environment "
"of the server.\n"
"<code>{code}</code>").format(
code=html.escape(str(error))),
quote=True,
parse_mode="HTML")
timeout_interval = self.flag('network_error_prompt_interval')
if timeout_interval > 0 and self.timeout_count % timeout_interval == 0:
self.bot_manager.send_message(
self.config['admins'][0],
self.ngettext(
"<b>EFB Telegram Master channel</b>\n"
"You may have a poor internet connection on your server. "
"Currently {count} network error is detected.\n"
"For more details, please refer to the log.",
"<b>EFB Telegram Master channel</b>\n"
"You may have a poor internet connection on your server. "
"Currently {count} network errors are detected.\n"
"For more details, please refer to the log.",
self.timeout_count).format(count=self.timeout_count),
parse_mode="HTML")
except telegram.error.ChatMigrated as e:
new_id = e.new_chat_id
old_id = update.message.chat_id
count = 0
for i in self.db.get_chat_assoc(
master_uid=etm_utils.chat_id_to_str(
self.channel_id, old_id)):
self.logger.debug(
'Migrating slave chat %s from Telegram chat %s to %s.', i,
old_id, new_id)
self.db.remove_chat_assoc(slave_uid=i)
self.db.add_chat_assoc(master_uid=etm_utils.chat_id_to_str(
self.channel_id, new_id),
slave_uid=i)
count += 1
self.bot_manager.send_message(
new_id,
self.ngettext(
"Chat migration detected.\n"
"All {count} remote chat are now linked to this new group.",
"Chat migration detected.\n"
"All {count} remote chats are now linked to this new group.",
count).format(count=count))
except Exception:
try:
self.bot_manager.send_message(
self.config['admins'][0],
self.
_("EFB Telegram Master channel encountered error <code>{error}</code> "
"caused by update <code>{update}</code>.").format(
error=html.escape(str(error)),
update=html.escape(str(update))),
parse_mode="HTML")
except Exception as ex:
self.logger.exception(
"Failed to send error message through Telegram: %s", ex)
finally:
self.logger.exception(
'Unhandled telegram bot error!\n'
'Update %s caused error %s. Exception', update, error)
def send_message(self, msg: EFBMsg) -> EFBMsg:
return self.slave_messages.send_message(msg)
def send_status(self, status: EFBStatus):
return self.slave_messages.send_status(status)
def get_message_by_id(self, chat: EFBChat,
msg_id: MessageID) -> Optional['EFBMsg']:
origin_uid = etm_utils.chat_id_to_str(chat=chat)
msg_log = self.db.get_msg_log(slave_origin_uid=origin_uid,
slave_msg_id=msg_id)
if msg_log is not None:
if msg_log.pickle:
return ETMMsg.unpickle(msg_log.pickle, self.db)
else:
# Pickled data is not recorded.
raise EFBOperationNotSupported(
self._("Message is not possible to be retrieved."))
else:
# Message is not found.
return None
def void_callback_handler(self, update: Update, context: CallbackContext):
self.bot_manager.answer_callback_query(
update.callback_query.id,
text=self._("This button does nothing."),
cache_time=180)
def stop_polling(self):
self.logger.debug("Gracefully stopping %s (%s).", self.channel_name,
self.channel_id)
self.rpc_utilities.shutdown()
self.bot_manager.graceful_stop()
self.master_messages.stop_worker()
self.db.stop_worker()
self.logger.debug("%s (%s) gracefully stopped.", self.channel_name,
self.channel_id)
def __init__(self, instance_id: InstanceID = None):
"""
Initialization.
"""
super().__init__(instance_id)
# Check PIL support for WebP
Image.init()
if 'WEBP' not in Image.ID:
raise EFBException(
self._(
"WebP support of Pillow is required.\n"
"Please refer to Pillow Documentation for instructions.\n"
"https://pillow.readthedocs.io/"))
# Suppress debug logs from dependencies
logging.getLogger('requests').setLevel(logging.CRITICAL)
logging.getLogger('urllib3').setLevel(logging.CRITICAL)
logging.getLogger('telegram.bot').setLevel(logging.CRITICAL)
logging.getLogger(
'telegram.vendor.ptb_urllib3.urllib3.connectionpool').setLevel(
logging.CRITICAL)
# Set up logger
self.logger: logging.Logger = logging.getLogger(__name__)
# Load configs
self.load_config()
# Load predefined MIME types
mimetypes.init(files=["mimetypes"])
# Initialize managers
self.flag: ExperimentalFlagsManager = ExperimentalFlagsManager(self)
self.db: DatabaseManager = DatabaseManager(self)
self.chat_dest_cache: ChatDestinationCache = ChatDestinationCache(
self.flag("send_to_last_chat"))
self.bot_manager: TelegramBotManager = TelegramBotManager(self)
self.chat_binding: ChatBindingManager = ChatBindingManager(self)
self.commands: CommandsManager = CommandsManager(self)
self.master_messages: MasterMessageProcessor = MasterMessageProcessor(
self)
self.slave_messages: SlaveMessageProcessor = SlaveMessageProcessor(
self)
if not self.flag('auto_locale'):
self.translator = translation("efb_telegram_master",
resource_filename(
'efb_telegram_master', 'locale'),
fallback=True)
# Basic message handlers
non_edit_filter = Filters.update.message | Filters.update.channel_post
self.bot_manager.dispatcher.add_handler(
CommandHandler("start", self.start, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("help", self.help, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("info", self.info, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.void_callback_handler, pattern="void"))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.bot_manager.session_expired))
self.bot_manager.dispatcher.add_handler(
CommandHandler("react", self.react, filters=non_edit_filter))
self.bot_manager.dispatcher.add_error_handler(self.error)
self.rpc_utilities = RPCUtilities(self)
# encoding: utf-8
import os
import pkg_resources
import re
import subprocess
import tempfile
import unittest
import pdf_redactor
FIXTURE_PATH = pkg_resources.resource_filename(__name__, "test-ssns.pdf")
class RedactFixture(object):
def __init__(self, input_path, options):
self.input_path = input_path
self.options = options
def __enter__(self):
self.input_file = open(self.input_path, "rb")
self.options.input_stream = self.input_file
fd, self.redacted_path = tempfile.mkstemp(".pdf")
self.redacted_file = os.fdopen(fd, "wb")
self.options.output_stream = self.redacted_file
pdf_redactor.redactor(self.options)
self.redacted_file.close()
return self.redacted_path
def __init__(self):
"""Summary
"""
lib = to_shared_lib("numpy_weld_convertor")
lib_file = pkg_resources.resource_filename(__name__, lib)
self.utils = ctypes.PyDLL(lib_file)
def test_resource_executor(yaml_path, name, expected):
a = BaseExecutor.load_config(
resource_filename('jina', '/'.join(('resources', yaml_path))))
assert a.name == name
assert len(a._drivers) == expected
def _test_component_to_complex_workflow(browser):
project_dict, workspace_page = startup(browser)
# Add paraboloid and vehicle_threesim files
file1_path = pkg_resources.resource_filename('openmdao.examples.simple',
'paraboloid.py')
file2_path = pkg_resources.resource_filename(
'openmdao.examples.enginedesign', 'vehicle_threesim.py')
workspace_page.add_file(file1_path)
workspace_page.add_file(file2_path)
# create an instance of VehicleSim2
sim_name = workspace_page.put_element_on_grid("VehicleSim2")
# Drag paraboloid element into sim dataflow figure
sim = workspace_page.get_dataflow_figure(sim_name)
paraboloid = workspace_page.find_library_button('Paraboloid')
chain = workspace_page.drag_element_to(paraboloid,
sim('content_area').element, False)
workspace_page.release(chain)
paraboloid_name = NameInstanceDialog(workspace_page).create_and_dismiss()
paraboloid_pathname = sim_name + "." + paraboloid_name
# Switch to Workflow pane and show the sim workflow
workspace_page('workflow_tab').click()
workspace_page.show_workflow(sim_name)
# See how many workflow component figures there are before we add to it
eq(len(workspace_page.get_workflow_component_figures()), 16)
############################################################################
# Drop paraboloid component onto the top level workflow for sim
############################################################################
workspace_page('dataflow_tab').click()
workspace_page.expand_object(sim_name)
workspace_page.add_object_to_workflow(paraboloid_pathname, sim_name)
# Confirm that there is one more workflow component figure
workspace_page('workflow_tab').click()
eq(len(workspace_page.get_workflow_component_figures()), 17)
# Confirm that the paraboloid has been added to the sim workflow by trying
# to access it.
workspace_page.find_object_button(sim_name + "." + paraboloid_name)
############################################################################
# Drop paraboloid component onto the sim_acc workflow under sim
############################################################################
workspace_page('dataflow_tab').click()
simsim_name = sim_name + '.sim_acc'
workspace_page.add_object_to_workflow(paraboloid_pathname, simsim_name)
# Confirm that there is one more workflow component figure
workspace_page('workflow_tab').click()
eq(len(workspace_page.get_workflow_component_figures()), 18)
# Confirm that the paraboloid has been added to the sim workflow by trying
# to access it.
workspace_page.find_object_button(sim_name + "." + paraboloid_name)
############################################################################
# Drop paraboloid component onto the vehicle workflow under sim_acc
# This should NOT work since the paraboloid is not in the vehicle assembly
############################################################################
# These error messages are tested in SequentialFlow, though we may want
# to have one test that makes sure that the error dialog makes it through.
#workspace_page('dataflow_tab').click()
#workspace_page.expand_object(simsim_name)
#simsimsim_name = simsim_name + '.vehicle'
#workspace_page.add_object_to_workflow(paraboloid_pathname, simsimsim_name)
#message = NotifierPage.wait(workspace_page)
#eq(message, "x")
# Confirm that there is NOT a new workflow component figure
#workspace_page('workflow_tab').click()
#eq(len(workspace_page.get_workflow_component_figures()), 18)
# Clean up.
closeout(project_dict, workspace_page)
def get_resource(path: str) -> Path:
return Path(resource_filename('bldr', str(Path('data', path))))
from argparse import ArgumentParser, Namespace
from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
import jsonschema
import pkg_resources
from runrestic import __version__
from runrestic.runrestic.tools import deep_update
logger = logging.getLogger(__name__)
CONFIG_DEFAULTS = {
"execution": {"parallel": False, "exit_on_error": True, "retry_count": 0}
}
SCHEMA = json.load(
open(pkg_resources.resource_filename("runrestic", "runrestic/schema.json"), "r")
)
def cli_arguments(args: Union[List[str], None] = None) -> Tuple[Namespace, List[str]]:
parser = ArgumentParser(
prog="runrestic",
description="""
A wrapper for restic. It runs restic based on config files and also outputs metrics.
To initialize the repos, run `runrestic init`.
If you don't define any actions, it will default to `backup prune check`, and `stats` if metrics are set.
""",
)
parser.add_argument(
"actions",
type=str,
def __bootstrap__():
global __bootstrap__, __loader__, __file__
import sys, pkg_resources, imp
__file__ = pkg_resources.resource_filename(__name__, '_max_len_seq.so')
__loader__ = None; del __bootstrap__, __loader__
imp.load_dynamic(__name__,__file__)
def start(
targets, module_name, logging_level, config_file="api.yaml", schema_file="api.schema.yaml"
):
"""Start the API.
Keyword arguments:
targets -- shared target list
module_name -- module name set by the main code to separate targets
logging_level -- level logging set in the global config file
config_file -- name of the config file for the API
schema_file -- schema of the config file for the API
"""
global shared_targets_list
global global_module_name
global token
global max_targets
global target_lifetime
global max_target_lifetime
# initiate list in dict from Manager (shared variable with main code)
targets[module_name] = []
# transform config file to absolute path
entry_path = os.path.dirname(os.path.abspath(sys.argv[0]))
config_file_abs = os.path.join(entry_path, config_file)
# load inventory configuration
if not os.path.exists(config_file_abs):
log_api.info("No configuration file for api module")
return
# getting a reference of this list and module name
shared_targets_list = targets
global_module_name = module_name
# validate yaml config with the schema
schema = pkg_resources.resource_filename(__name__, schema_file)
yaml_validator = Core(source_file=config_file_abs, schema_files=[schema])
yaml_validator.validate(raise_exception=True)
# if config file exists, we load it and parse it
with open(config_file_abs, "r") as conf_file:
try:
conf = yaml.safe_load(conf_file)
log_api.debug("network_devices configuration loaded")
except Exception as error:
log_api.error("Unable to load config file: {0}".format(error))
listen_address = conf.get("listen_address", "0.0.0.0")
listen_port = conf.get("listen_port", 8009)
groups.extend(conf.get("groups", []))
token = conf.get("token")
max_targets = conf.get("max_targets", 10)
target_lifetime = common.explode_datetime(conf.get("target_lifetime", "1d"))
max_target_lifetime = common.explode_datetime(conf.get("max_target_lifetime", "30d"))
# starting the API
log_api.logging_level = "WARNING"
app = connexion.FlaskApp(__name__, server="tornado", debug=False)
app.add_api("api.swagger.yml")
app.run(host=listen_address, port=listen_port, debug=False)
def get_redshift_efficiency(simtype,
targets,
truth,
targets_in_tile,
obsconditions=None):
"""
Simple model to get the redshift effiency from the observational conditions or observed magnitudes+redshuft
Args:
simtype: ELG, LRG, QSO, MWS, BGS
targets: target catalog table; currently used only for TARGETID
truth: truth table with OIIFLUX, TRUEZ
targets_in_tile: dictionary. Keys correspond to tileids, its values are the
arrays of targetids observed in that tile.
obsconditions: table observing conditions with columns
'TILEID': array of tile IDs
'AIRMASS': array of airmass values on a tile
'EBMV': array of E(B-V) values on a tile
'LINTRANS': array of atmospheric transparency during spectro obs; floats [0-1]
'MOONFRAC': array of moonfraction values on a tile.
'SEEING': array of FWHM seeing during spectroscopic observation on a tile.
Returns:
tuple of arrays (observed, p) both with same length as targets
observed: boolean array of whether the target was observed in these tiles
p: probability to get this redshift right
"""
targetid = targets['TARGETID']
n = len(targetid)
try:
if 'DECAM_FLUX' in targets.colnames:
true_gflux = targets['DECAM_FLUX'][:, 1]
true_rflux = targets['DECAM_FLUX'][:, 2]
else:
true_gflux = targets['FLUX_G']
true_rflux = targets['FLUX_R']
except:
raise Exception(
'Missing photometry needed to estimate redshift efficiency!')
if (obsconditions is None) and (truth['OIIFLUX'] not in truth.colnames):
raise Exception(
'Missing obsconditions and flux information to estimate redshift efficiency'
)
if (simtype == 'ELG'):
# Read the model OII flux threshold (FDR fig 7.12 modified to fit redmonster efficiency on OAK)
filename = resource_filename(
'desisim', 'data/quickcat_elg_oii_flux_threshold.txt')
fdr_z, modified_fdr_oii_flux_threshold = np.loadtxt(filename,
unpack=True)
# Get OIIflux from truth
true_oii_flux = truth['OIIFLUX']
# Compute OII flux thresholds for truez
oii_flux_threshold = np.interp(truth['TRUEZ'], fdr_z,
modified_fdr_oii_flux_threshold)
assert (
oii_flux_threshold.size == true_oii_flux.size
), "oii_flux_threshold and true_oii_flux should have the same size"
# efficiency is modeled as a function of flux_OII/f_OII_threshold(z) and an arbitrary sigma_fudge
sigma_fudge = 1.0
max_efficiency = 1.0
simulated_eff = eff_model(true_oii_flux / oii_flux_threshold,
sigma_fudge, max_efficiency)
elif (simtype == 'LRG'):
# Read the model rmag efficiency
filename = resource_filename('desisim',
'data/quickcat_lrg_rmag_eff.txt')
magr, magr_eff = np.loadtxt(filename, unpack=True)
# Get Rflux from truth
r_mag = 22.5 - 2.5 * np.log10(true_rflux)
mean_eff_mag = np.interp(r_mag, magr, magr_eff)
fudge = 0.002
max_efficiency = 0.98
simulated_eff = max_efficiency * mean_eff_mag * (
1. + fudge * np.random.normal(size=mean_eff_mag.size))
simulated_eff[np.where(
simulated_eff > max_efficiency)] = max_efficiency
elif (simtype == 'QSO'):
# Read the model gmag threshold
filename = resource_filename('desisim',
'data/quickcat_qso_gmag_threshold.txt')
zc, qso_gmag_threshold_vs_z = np.loadtxt(filename, unpack=True)
# Get Gflux from truth
true_gmag = 22.5 - 2.5 * np.log10(true_gflux)
# Computes QSO mag thresholds for truez
qso_gmag_threshold = np.interp(truth['TRUEZ'], zc,
qso_gmag_threshold_vs_z)
assert (qso_gmag_threshold.size == true_gmag.size
), "qso_gmag_threshold and true_gmag should have the same size"
# Computes G flux
qso_true_normed_flux = 10**(-0.4 * (true_gmag - qso_gmag_threshold))
#model effificieny for QSO:
sigma_fudge = 0.5
max_efficiency = 0.95
simulated_eff = eff_model(qso_true_normed_flux, sigma_fudge,
max_efficiency)
elif simtype == 'BGS':
simulated_eff = 0.98 * np.ones(n)
elif simtype == 'MWS':
simulated_eff = 0.98 * np.ones(n)
else:
default_zeff = 0.98
log.warning('using default redshift efficiency of {} for {}'.format(
default_zeff, simtype))
simulated_eff = default_zeff * np.ones(n)
#- Get the corrections for observing conditions per tile, then
#- correct targets on those tiles. Parameterize in terms of failure
#- rate instead of success rate to handle bookkeeping of targets that
#- are observed on more than one tile.
#- NOTE: this still isn't quite right since multiple observations will
#- be simultaneously fit instead of just taking whichever individual one
#- succeeds.
zeff_obs = get_zeff_obs(simtype, obsconditions)
pfail = np.ones(n)
observed = np.zeros(n, dtype=bool)
# More efficient alternative for large numbers of tiles + large target
# list, but requires pre-computing the sort order of targetids.
# Assume targets['TARGETID'] is unique, so not checking this.
sort_targetid = np.argsort(targetid)
# Extract the targets-per-tile lists into one huge list.
concat_targets_in_tile = np.concatenate(
[targets_in_tile[tileid] for tileid in obsconditions['TILEID']])
ntargets_per_tile = np.array(
[len(targets_in_tile[tileid]) for tileid in obsconditions['TILEID']])
# Match entries in each tile list against sorted target list.
target_idx = targetid[sort_targetid].searchsorted(concat_targets_in_tile,
side='left')
target_idx_r = targetid[sort_targetid].searchsorted(concat_targets_in_tile,
side='right')
del (concat_targets_in_tile)
# Flag targets in tiles that do not appear in the target list (sky,
# standards).
not_matched = target_idx_r - target_idx == 0
target_idx[not_matched] = -1
del (target_idx_r, not_matched)
# Not every tile has 5000 targets, so use individual counts to
# construct offset of each tile in target_idx.
offset = np.concatenate([[0], np.cumsum(ntargets_per_tile[:-1])])
# For each tile, process targets.
for i, tileid in enumerate(obsconditions['TILEID']):
if ntargets_per_tile[i] > 0:
# Quickly get all the matched targets on this tile.
targets_this_tile = target_idx[offset[i]:offset[i] +
ntargets_per_tile[i]]
targets_this_tile = targets_this_tile[targets_this_tile > 0]
# List of indices into sorted target list for each observed
# source.
ii = sort_targetid[targets_this_tile]
tmp = (simulated_eff[ii] * zeff_obs[i]).clip(0, 1)
pfail[ii] *= (1 - tmp)
observed[ii] = True
simulated_eff = (1 - pfail)
return observed, simulated_eff
def res_filename(file):
return pkg_resources.resource_filename('bigml', "../../../%s" % file)
def install(self):
"""Installer"""
# Utility function to interpreted boolean option value
getBool = lambda s: s.strip().lower() in ['true', 'yes']
# Utility function to parse a multi-line/multi-value parameter
def cleanMultiParams(v):
params = [
s.split('|') for s in [l.strip() for l in v.split('\n')]
if len(s) > 0
]
cleaned_params = []
for line in params:
cleaned_params.append([row.strip() for row in line])
return cleaned_params
# Utility function to transform any string to an ID
getId = lambda s: ''.join([c for c in s if c.isalnum()]).lower()
options = self.options
# Add command line scripts trac-admin and tracd into bin
entry_points = [('trac-admin', 'trac.admin.console', 'run'),
('tracd', 'trac.web.standalone', 'main')]
zc.buildout.easy_install.scripts(entry_points,
pkg_resources.working_set,
options['executable'],
options['bin-directory'])
####################
# Init Trac instance
####################
# Generate the trac instance, if required
location = options['location']
project_name = options.get('project-name', 'My project')
project_url = options.get('project-url', 'http://example.com')
db = 'sqlite:%s' % os.path.join('db', 'trac.db')
if not os.path.exists(location):
os.mkdir(location)
trac = TracAdmin(location)
if not trac.env_check():
trac.do_initenv('"%s" %s' % (project_name, db))
env = trac.env
# Remove Trac default example data
clean_up = getBool(options.get('remove-examples', 'True'))
if clean_up:
# Remove default milestones
for mil in Milestone.select(env):
if mil.name in [
'milestone1', 'milestone2', 'milestone3', 'milestone4'
]:
mil.delete()
# Remove default components
for comp in Component.select(env):
if comp.name in ['component1', 'component2']:
comp.delete()
# Add custom milestones
for mil_data in cleanMultiParams(options.get('milestones', '')):
mil_name = mil_data[0]
try:
mil = Milestone(env, name=mil_name)
except ResourceNotFound:
mil = Milestone(env)
mil.name = mil_name
mil.insert()
# Add custom components
for comp_data in cleanMultiParams(options.get('components', '')):
comp_name = comp_data[0]
try:
comp = Component(env, name=comp_name)
except ResourceNotFound:
comp = Component(env)
comp.name = comp_name
if len(comp_data) == 2 and comp_data[1] not in [None, '']:
comp.owner = comp_data[1]
comp.insert()
#######################
# Generate the trac.ini
#######################
# Read the trac.ini config file
trac_ini = os.path.join(location, 'conf', 'trac.ini')
parser = ConfigParser.ConfigParser()
parser.read([trac_ini])
# Clean-up trac.ini: add missing stuff
if 'components' not in parser.sections():
parser.add_section('components')
# Force upgrade of informations used during initialization
parser.set('project', 'name', project_name)
# Set all repositories
repos = cleanMultiParams(options.get('repos', None))
repo_names = [getId(r[0]) for r in repos]
repo_types = {}.fromkeys([r[1].lower() for r in repos]).keys()
if 'repositories' not in parser.sections():
parser.add_section('repositories')
for repo in repos:
repo_name = getId(repo[0])
repo_type = repo[1]
repo_dir = repo[2]
repo_url = repo[3]
parser.set('repositories', '%s.type' % repo_name, repo_type)
parser.set('repositories', '%s.dir' % repo_name, repo_dir)
if repo_url not in ['', None]:
parser.set('repositories', '%s.url' % repo_name, repo_url)
# Set default repository
default_repo = getId(options.get('default-repo', None))
if default_repo and default_repo in repo_names:
parser.set('repositories', '.alias', default_repo)
parser.set('repositories', '.hidden', 'true')
# Set repository sync method
sync_method = options.get('repos-sync', 'request').strip().lower()
svn_repos = [getId(r[0]) for r in repos if r[1] == 'svn']
if sync_method == 'request':
parser.set('trac', 'repository_sync_per_request',
', '.join(svn_repos))
# TODO
# elif sync_method == 'hook':
# do stuff...
# Set project description
project_descr = options.get('project-description', None)
if project_descr:
parser.set('project', 'descr', project_descr)
parser.set('header_logo', 'alt', project_descr)
# Setup logo
header_logo = options.get('header-logo', '')
header_logo = os.path.realpath(header_logo)
if os.path.exists(header_logo):
shutil.copyfile(header_logo,
os.path.join(location, 'htdocs', 'logo'))
parser.set('header_logo', 'src', 'site/logo')
parser.set('header_logo', 'link', project_url)
# Set footer message
parser.set(
'project', 'footer',
options.get(
'footer-message',
'This Trac instance was generated by <a href="http://pypi.python.org/pypi/pbp.recipe.trac">pbp.recipe.trac</a>.'
))
# SMTP parameters
for name in ('always-bcc', 'always-cc', 'default-domain', 'enabled',
'from', 'from-name', 'password', 'port', 'replyto',
'server', 'subject-prefix', 'user'):
param_name = "smtp-%s" % name
default_value = None
if param_name == "smtp-from-name":
default_value = project_name
value = options.get(param_name, default_value)
if value is not None:
parser.set('notification', param_name.replace('-', '_'), value)
###############
# Plugins setup
###############
# If one repository use Mercurial, hook its plugin
if 'hg' in repo_types:
parser.set('components', 'tracext.hg.*', 'enabled')
# Configure the NavAdd plugin
menu_items = cleanMultiParams(options.get('additional-menu-items', ''))
item_list = []
for item in menu_items:
item_title = item[0]
item_url = item[1]
item_id = getId(item_title)
item_list.append((item_id, item_title, item_url))
if item_list > 0:
parser.set('components', 'navadd.*', 'enabled')
if 'navadd' not in parser.sections():
parser.add_section('navadd')
parser.set('navadd', 'add_items',
','.join([i[0] for i in item_list]))
for (uid, title, url) in item_list:
parser.set('navadd', '%s.target' % uid, 'mainnav')
parser.set('navadd', '%s.title' % uid, title)
parser.set('navadd', '%s.url' % uid, url)
# Enable and setup time tracking
time_tracking = options.get('time-tracking-plugin',
'disabled').strip().lower() == 'enabled'
if time_tracking:
parser.set('components', 'timingandestimationplugin.*', 'enabled')
# Enable and setup the stat plugin
stats = options.get('stats-plugin',
'disabled').strip().lower() == 'enabled'
if stats:
parser.set('components', 'tracstats.*', 'enabled')
#######################
# Final upgrades & sync
#######################
# Apply custom parameters defined by the user
custom_params = cleanMultiParams(options.get('trac-ini-additional',
''))
for param in custom_params:
if len(param) == 3:
section = param[0]
if section not in parser.sections():
parser.add_section(section)
parser.set(section, param[1], param[2])
# Write the final trac.ini
parser.write(open(trac_ini, 'w'))
# Reload the environment
env.shutdown()
trac = TracAdmin(location)
env = trac.env
# Set custom permissions
perm_sys = PermissionSystem(env)
for cperm in cleanMultiParams(options.get('permissions', '')):
if len(cperm) == 2:
user = cperm[0]
current_user_perms = perm_sys.get_user_permissions(user)
perm_list = [p.upper() for p in cperm[1].split(' ') if len(p)]
for perm in perm_list:
if perm not in current_user_perms:
perm_sys.grant_permission(user, perm)
# Upgrade Trac instance to keep it fresh
needs_upgrade = env.needs_upgrade()
force_upgrade = getBool(options.get('force-instance-upgrade', 'False'))
if needs_upgrade or force_upgrade:
env.upgrade(backup=True)
# Force repository resync
repo_resync = getBool(options.get('force-repos-resync', 'False'))
if repo_resync:
rm = RepositoryManager(env)
repositories = rm.get_real_repositories()
for repos in sorted(repositories, key=lambda r: r.reponame):
repos.sync(clean=True)
# Upgrade default wiki pages embedded in Trac instance
wiki_upgrade = getBool(options.get('wiki-doc-upgrade', 'False'))
if wiki_upgrade:
# Got the command below from trac/admin/console.py
pages_dir = pkg_resources.resource_filename(
'trac.wiki', 'default-pages')
WikiAdmin(env).load_pages(pages_dir,
ignore=['WikiStart', 'checkwiki.py'],
create_only=['InterMapTxt'])
# Return files that were created by the recipe. The buildout
# will remove all returned files upon reinstall.
return tuple()
def get_observed_redshifts(targets, truth, targets_in_tile, obsconditions):
"""
Returns observed z, zerr, zwarn arrays given true object types and redshifts
Args:
targets: target catalog table; currently used only for target mask bits
truth: truth table with OIIFLUX, TRUEZ
targets_in_tile: dictionary. Keys correspond to tileids, its values are the
arrays of targetids observed in that tile.
obsconditions: table observing conditions with columns
'TILEID': array of tile IDs
'AIRMASS': array of airmass values on a tile
'EBMV': array of E(B-V) values on a tile
'LINTRANS': array of atmospheric transparency during spectro obs; floats [0-1]
'MOONFRAC': array of moonfraction values on a tile.
'SEEING': array of FWHM seeing during spectroscopic observation on a tile.
Returns:
tuple of (zout, zerr, zwarn)
"""
simtype = get_simtype(np.char.strip(truth['TRUESPECTYPE']),
targets['DESI_TARGET'], targets['BGS_TARGET'],
targets['MWS_TARGET'])
truez = truth['TRUEZ']
targetid = truth['TARGETID']
try:
if 'DECAM_FLUX' in targets.colnames:
true_gflux = targets['DECAM_FLUX'][:, 1]
true_rflux = targets['DECAM_FLUX'][:, 2]
else:
true_gflux = targets['FLUX_G']
true_rflux = targets['FLUX_R']
except:
raise Exception(
'Missing photometry needed to estimate redshift efficiency!')
zout = truez.copy()
zerr = np.zeros(len(truez), dtype=np.float32)
zwarn = np.zeros(len(truez), dtype=np.int32)
objtypes = list(set(simtype))
n_tiles = len(np.unique(obsconditions['TILEID']))
if (n_tiles != len(targets_in_tile)):
raise ValueError(
'Number of obsconditions {} != len(targets_in_tile) {}'.format(
n_tiles, len(targets_in_tile)))
for objtype in objtypes:
if objtype in _sigma_v.keys():
ii = (simtype == objtype)
n = np.count_nonzero(ii)
# Error model for ELGs
if (objtype == 'ELG'):
filename = resource_filename('desisim',
'data/quickcat_elg_oii_errz.txt')
oii, errz_oii = np.loadtxt(filename, unpack=True)
try:
true_oii_flux = truth['OIIFLUX'][ii]
except:
raise Exception(
'Missing OII flux information to estimate redshift error for ELGs'
)
mean_err_oii = np.interp(true_oii_flux, oii, errz_oii)
zerr[ii] = mean_err_oii * (1. + truez[ii])
zout[ii] += np.random.normal(scale=zerr[ii])
# Error model for LRGs
elif (objtype == 'LRG'):
redbins = np.linspace(0.55, 1.1, 5)
mag = np.linspace(20.5, 23., 50)
true_magr = 22.5 - 2.5 * np.log10(true_rflux)
coefs = [[9.46882282e-05,-1.87022383e-03],[6.14601021e-05,-1.17406643e-03],\
[8.85342362e-05,-1.76079966e-03],[6.96202042e-05,-1.38632104e-03]]
'''
Coefs of linear fit of LRG zdc1 redmonster error as a function of Rmag in 4 bins of redshift: (z_low,coef0,coef1)
0.55 9.4688228224e-05 -0.00187022382514
0.6875 6.14601021052e-05 -0.00117406643273
0.825 8.85342361594e-05 -0.00176079966322
0.9625 6.96202042482e-05 -0.00138632103551
'''
# for each redshift bin, select the corresponding coefs
zerr_tmp = np.zeros(len(truez[ii]))
for i in range(redbins.size - 1):
index0, = np.where((truez[ii] >= redbins[i])
& (truez[ii] < redbins[i + 1]))
if (i == 0):
index1, = np.where(truez[ii] < redbins[0])
index = np.concatenate((index0, index1))
elif (i == (redbins.size - 2)):
index1, = np.where(truez[ii] >= redbins[-1])
index = np.concatenate((index0, index1))
else:
index = index0
# Find mean error at true mag
pol = np.poly1d(coefs[i])
mean_err_mag = np.interp(true_magr[index], mag, pol(mag))
# Computes output error and redshift
zerr_tmp[index] = mean_err_mag
zerr[ii] = zerr_tmp * (1. + truez[ii])
zout[ii] += np.random.normal(scale=zerr[ii])
# Error model for QSOs
elif (objtype == 'QSO'):
redbins = np.linspace(0.5, 3.5, 7)
mag = np.linspace(21., 23., 50)
true_magg = 22.5 - 2.5 * np.log10(true_gflux)
coefs = [[0.000156950059747,-0.00320719603886],[0.000461779391179,-0.00924485142818],\
[0.000458672517009,-0.0091254038977],[0.000461427968475,-0.00923812594293],\
[0.000312919487343,-0.00618137905849],[0.000219438845624,-0.00423782927109]]
'''
Coefs of linear fit of QSO zdc1 redmonster error as a function of Gmag in 6 bins of redshift: (z_low,coef0,coef1)
0.5 0.000156950059747 -0.00320719603886
1.0 0.000461779391179 -0.00924485142818
1.5 0.000458672517009 -0.0091254038977
2.0 0.000461427968475 -0.00923812594293
2.5 0.000312919487343 -0.00618137905849
3.0 0.000219438845624 -0.00423782927109
'''
# for each redshift bin, select the corresponding coefs
zerr_tmp = np.zeros(len(truez[ii]))
for i in range(redbins.size - 1):
index0, = np.where((truez[ii] >= redbins[i])
& (truez[ii] < redbins[i + 1]))
if (i == 0):
index1, = np.where(truez[ii] < redbins[0])
index = np.concatenate((index0, index1))
elif (i == (redbins.size - 2)):
index1, = np.where(truez[ii] >= redbins[-1])
index = np.concatenate((index0, index1))
else:
index = index0
# Find mean error at true mag
pol = np.poly1d(coefs[i])
mean_err_mag = np.interp(true_magg[index], mag, pol(mag))
# Computes output error and redshift
zerr_tmp[index] = mean_err_mag
zerr[ii] = zerr_tmp * (1. + truez[ii])
zout[ii] += np.random.normal(scale=zerr[ii])
else:
zerr[ii] = _sigma_v[objtype] * (1 + truez[ii]) / c
zout[ii] += np.random.normal(scale=zerr[ii])
# Set ZWARN flags for some targets
# the redshift efficiency only sets warning, but does not impact
# the redshift value and its error.
was_observed, goodz_prob = get_redshift_efficiency(
objtype,
targets[ii],
truth[ii],
targets_in_tile,
obsconditions=obsconditions)
assert len(was_observed) == n
assert len(goodz_prob) == n
r = np.random.random(len(was_observed))
zwarn[ii] = 4 * (r > goodz_prob) * was_observed
# Add fraction of catastrophic failures (zwarn=0 but wrong z)
nzwarnzero = np.count_nonzero(zwarn[ii][was_observed] == 0)
num_cata = np.random.poisson(_cata_fail_fraction[objtype] *
nzwarnzero)
if (objtype == 'ELG'): zlim = [0.6, 1.7]
elif (objtype == 'LRG'): zlim = [0.5, 1.1]
elif (objtype == 'QSO'): zlim = [0.5, 3.5]
if num_cata > 0:
#- tmp = boolean array for all targets, flagging only those
#- that are of this simtype and were observed this epoch
tmp = np.zeros(len(ii), dtype=bool)
tmp[ii] = was_observed
kk, = np.where((zwarn == 0) & tmp)
index = np.random.choice(kk, size=num_cata, replace=False)
assert np.all(np.in1d(index, np.where(ii)[0]))
assert np.all(zwarn[index] == 0)
zout[index] = np.random.uniform(zlim[0], zlim[1], len(index))
else:
msg = 'No redshift efficiency model for {}; using true z\n'.format(objtype) + \
'Known types are {}'.format(list(_sigma_v.keys()))
log.warning(msg)
return zout, zerr, zwarn
import pybullet_data
import glob
import pybullet
import pybullet_utils.bullet_client as bc
import time
import numpy as np
from gym.utils import seeding
import gym
import os
import inspect
from myGym.envs.camera import Camera
import pkg_resources
currentdir = pkg_resources.resource_filename("myGym", "envs")
repodir = pkg_resources.resource_filename("myGym", "./")
class BaseEnv(gym.Env):
"""
The base class for environments without rendering
Parameters:
:param gui_on: (bool) Whether or not to use PyBullet built-in GUI
:param objects_dir_path: (str) Path to directory with URDF files for objects
:param max_steps: (int) The maximum number of actions per episode
:param show_bounding_boxes_gui: (bool) Whether or not to show bounding boxes in GUI
:param changing_light_gui: (bool) Whether or not to change light in GUI
:param shadows_on_gui: (bool) Whether or not to show shadows in GUI
"""
metadata = {
'render.modes': ['human', 'rgb_array'],
'video.frames_per_second': 50
# Initiate Config
# if modules are not available from central python install try the ones in the same directory
from Nagstamon.Config import Config
conf = Config()
# check for old settings when upgrading from a nagstamon version < 0.8 and convert them
conf.Convert_Conf_to_Multiple_Servers()
# convert settings for actions to custom actions for Nagstamon < 0.9.9
conf.Convert_Conf_to_Custom_Actions()
# try to get resources path if nagstamon got be installed by setup.py
Resources = ""
try:
import pkg_resources
Resources = pkg_resources.resource_filename("Nagstamon", "resources")
except Exception, err:
# get resources directory from current directory - only if not being set before by pkg_resources
# try-excepts necessary for platforms like Windows .EXE
join = os.path.join
normcase = os.path.normcase
paths_to_check = [
normcase(join(os.getcwd(), "Nagstamon", "resources")),
normcase(join(os.getcwd(), "resources"))
]
try:
# if resources dir is not available in CWD, try the
# libs dir (site-packages) for the current Python
from distutils.sysconfig import get_python_lib
paths_to_check.append(
normcase(join(get_python_lib(), "Nagstamon", "resources")))
import os
import pkg_resources
from alembic.config import Config
from alembic.environment import EnvironmentContext
from alembic.script import ScriptDirectory
from alembic.util import load_python_file
from zope.sqlalchemy import mark_changed
from kotti import conf_defaults
from kotti import get_settings
from kotti import DBSession
from kotti.util import command
KOTTI_SCRIPT_DIR = pkg_resources.resource_filename('kotti', 'alembic')
DEFAULT_LOCATION = 'kotti:alembic'
class ScriptDirectoryWithDefaultEnvPy(ScriptDirectory):
@property
def env_py_location(self):
loc = super(ScriptDirectoryWithDefaultEnvPy, self).env_py_location
if not os.path.exists(loc):
loc = os.path.join(KOTTI_SCRIPT_DIR, 'env.py')
return loc
def run_env(self):
dir_, filename = self.env_py_location.rsplit(os.path.sep, 1)
load_python_file(dir_, filename)
def pkg_filename(relative_path):
return pkg_resources.resource_filename(__name__, relative_path)
def __init__(self, logger=None):
self.agent_swagger = pkg_resources.resource_filename('symphonybinding', 'data/agent-api-public-deprecated.yaml')
self.pod_swagger = pkg_resources.resource_filename('symphonybinding', 'data/pod-api-public-deprecated.yaml')
self.logger = logger or logging.getLogger(__name__)
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
########################################################################################################################
from __future__ import (absolute_import, division, print_function,
unicode_literals)
# noinspection PyUnresolvedReferences,PyCompatibility
from builtins import *
import os
import pkg_resources
from bag.design import Module
yaml_file = pkg_resources.resource_filename(
__name__, os.path.join('netlist_info', 'capdac_8b_2.yaml'))
# noinspection PyPep8Naming
class adc_sar_templates__capdac_8b_2(Module):
"""Module for library adc_sar_templates cell capdac_8b_2.
Fill in high level description here.
"""
def __init__(self, bag_config, parent=None, prj=None, **kwargs):
Module.__init__(self,
bag_config,
yaml_file,
parent=parent,
prj=prj,
**kwargs)
# -*- coding: utf-8 -*-
import os
import pkg_resources
import subprocess
domain = "collective.symlink"
os.chdir(pkg_resources.resource_filename(domain, ""))
os.chdir("../../../")
target_path = "src/collective/symlink/"
locale_path = target_path + "locales/"
i18ndude = "./bin/i18ndude"
def locale_folder_setup():
os.chdir(locale_path)
languages = [d for d in os.listdir(".") if os.path.isdir(d)]
for lang in languages:
folder = os.listdir(lang)
if "LC_MESSAGES" in folder:
continue
else:
lc_messages_path = lang + "/LC_MESSAGES/"
os.mkdir(lc_messages_path)
cmd = "msginit --locale={0} --input={1}.pot --output={2}/LC_MESSAGES/{3}.po".format( # NOQA: E501
lang, domain, lang, domain)
subprocess.call(cmd, shell=True)
os.chdir("../../../../")
def __init__(self, parameters: Dict[str, Any]) -> None:
assert self.template is not None
self.template_path = pkg_resources.resource_filename(
constants.misc.TEMPLATE_PATH, self.template)
self.parameters = parameters
from pkg_resources import resource_filename
DATA_ROOT = resource_filename('langcodes', 'data')
import os
def data_filename(filename):
return os.path.join(DATA_ROOT, filename)
def icon_path(basename):
return pkg_resources.resource_filename(__name__, "icons/" + basename)
def save(self,
parent=None,
current_name="graph",
size="auto",
num_specimens=1,
offset=0.75):
"""
Displays a save dialog to export an image from the current plot.
"""
# Parse arguments:
width, height = 0, 0
if size == "auto":
descr, width, height, dpi = settings.OUTPUT_PRESETS[0]
else:
width, height, dpi = map(float, size.replace("@", "x").split("x"))
# Load gui:
builder = gtk.Builder()
builder.add_from_file(
resource_filename("pyxrd.specimen", "glade/save_graph_size.glade")
) # FIXME move this to this namespace!!
size_expander = builder.get_object("size_expander")
cmb_presets = builder.get_object("cmb_presets")
# Setup combo with presets:
cmb_store = gtk.ListStore(str, int, int, float)
for row in settings.OUTPUT_PRESETS:
cmb_store.append(row)
cmb_presets.clear()
cmb_presets.set_model(cmb_store)
cell = gtk.CellRendererText()
cmb_presets.pack_start(cell, True)
cmb_presets.add_attribute(cell, 'text', 0)
def on_cmb_changed(cmb, *args):
itr = cmb_presets.get_active_iter()
w, h, d = cmb_store.get(itr, 1, 2, 3)
entry_w.set_text(str(w))
entry_h.set_text(str(h))
entry_dpi.set_text(str(d))
cmb_presets.connect('changed', on_cmb_changed)
# Setup input boxes:
entry_w = builder.get_object("entry_width")
entry_h = builder.get_object("entry_height")
entry_dpi = builder.get_object("entry_dpi")
entry_w.set_text(str(width))
entry_h.set_text(str(height))
entry_dpi.set_text(str(dpi))
# What to do when the user wants to save this:
def on_accept(dialog):
# Get the width, height & dpi
width = float(entry_w.get_text())
height = float(entry_h.get_text())
dpi = float(entry_dpi.get_text())
i_width, i_height = width / dpi, height / dpi
# Save it all right!
self.save_figure(dialog.filename, dpi, i_width, i_height)
# Ask the user where, how and if he wants to save:
DialogFactory.get_save_dialog(
"Save Graph",
parent=parent,
filters=self.file_filters,
current_name=current_name,
extra_widget=size_expander).run(on_accept)
standard_library.install_aliases()
# Standard library
from argparse import ArgumentParser
from builtins import str
import os
import urllib.parse
# Third-party
import pkg_resources
# Local/library specific
from .support import *
RDF_DIR = pkg_resources.resource_filename('cc.licenserdf', 'licenses')
# *
# *******************************************************************
def _printer(string):
"""
A simple wrapper for the print statement so we can do testing on
the info method
"""
print(string)
def license_rdf_filename(license_uri, rdf_dir=RDF_DIR):
"""Map a license URI to the filesystem filename containing the RDF."""
