def try_import_on_name_error():
try:
method()
except NameError as e:
importable = ["os"]
name = name_error(e)
if name and name in importable:
from importlib import __import__
__import__(name)
method()
def import_from_dir(dirpath, module_name):
"""
Import a module from a specified_directory.
"""
if dirpath in sys.path:
module = importlib.__import__(module_name)
else:
sys.path.insert(0, dirpath)
try:
module = importlib.__import__(module_name)
finally:
del sys.path[0]
return module
def get_app(self, context):
app_name = context['app_name']
assert app_name, (
"Did you make sure to set the context_instance "
"to and instance of RequestContext"
)
return importlib.__import__(app_name)
def worker(*args):
while True:
libraryOrFn = q.get()
start = time.time()
if libraryOrFn == False:
q.task_done()
break # Die
elif type(libraryOrFn) is str:
try:
part = importlib.__import__(libraryOrFn)
log = part.main(*args)
with lock:
print("> %7.5f for %s: %s" % (time.time() - start, libraryOrFn, log))
except Exception as e:
with lock:
print("Error for "+str(libraryOrFn)+": "+str(e))
traceback.print_exc()
finally:
q.task_done()
else:
try:
log = libraryOrFn()
with lock:
print("~ %7.5f for %s" % (time.time() - start, log))
except Exception as e:
with lock:
print("Error for "+str(libraryOrFn)+": "+str(e))
traceback.print_exc()
finally:
q.task_done()
def __add__(self, other):
"""Addition operation."""
module = importlib.__import__(self.__class__.__module__)
termsum = getattr(module, self._termsum_type)()
termsum._add(self)
termsum._add(other)
return termsum
def load_outputs(self):
# print("Loading slicers...")
for output in self.outputs_list:
if not output.startswith('_'):
modulepath = "on.plugins.output." + output
module = importlib.__import__(modulepath, fromlist=['OutputPlugin'])
self.outputs[output] = module
def _connect_db(config):
''' Return a DB connection. '''
if config.type == 'postgres':
try:
psycopg2 = importlib.__import__('psycopg2')
except ImportError as e:
msg = 'psycopg2 module is required for Postgres.'
raise click.ClickException(msg) from e
try:
return psycopg2.connect(
host=config.host,
port=config.port,
user=config.user,
password=config.password,
database=config.schema
)
except Exception as e:
if config.debug:
raise
else:
err = 'Unable to connect to database: %s'
raise click.ClickException(err % str(e)) from e
else:
raise ValueError('Database type "%s" not supported.' % config.type)
def load_slicers(self):
# print("Loading slicers...")
for slicer in self.slicers_list:
if not slicer.startswith("_"):
modulepath = "on.plugins.slicers." + slicer
# print("\t" + modulepath)
self.slicers[slicer] = importlib.__import__(modulepath, fromlist=["SlicerPlugin"])
def load_jauges(self):
self.jauges = {}
for jauge_name in self.jauge_names:
mod, cls = jauge_name.split('.')
_mod = importlib.__import__('jauges.' + mod,
fromlist=(jauge_name,))
self.jauges[jauge_name] = getattr(_mod, cls)(
self.config[cls.upper()])
def search(root):
nonlocal touched_paths, found_subclasses, here_path
root = os.path.realpath(root)
if root in touched_paths: return
touched_paths.add(root)
relpath = os.path.relpath(root, here_path)
#print(' relpath: %s' % relpath)
for path in glob.glob(os.path.join(root, '*')):
if os.path.isdir(path):
if not path.endswith('__pycache__'):
search(path)
continue
pyfile,ext = os.path.splitext(os.path.basename(path))
if ext != '.py': continue
if pyfile == '__init__': continue
try:
# a hack to turn a file path into a python import
# TODO: find a better way!
pyfile = os.path.join(relpath, pyfile)
pyfile = re.sub(r'\\', '/', pyfile)
if pyfile.startswith('./'): pyfile = pyfile[2:]
level = pyfile.count('..')
pyfile = re.sub(r'^(\.\./)*', '', pyfile)
pyfile = re.sub('/', '.', pyfile)
#print(' Searching: %s (%d, %s)' % (pyfile, level, path))
try:
tmp = importlib.__import__(pyfile, globals(), locals(), [], level=level+1)
except Exception as e:
se = str(e)
# pass over ignorable exceptions
if se == 'attempted relative import beyond top-level package':
# if symlink to another folder, this exception can get thrown
continue
print('Caught exception while attempting to search for classes')
print(' cls: %s' % str(cls))
print(' pyfile: %s' % pyfile)
print(' %s' % str(e))
continue
for tk in dir(tmp):
m = getattr(tmp, tk)
if not inspect.ismodule(m): continue
for k in dir(m):
v = getattr(m, k)
if not inspect.isclass(v): continue
if v is cls: continue
if not issubclass(v, cls): continue
# v is a subclass of cls, so add it to the global namespace
#print(' Found %s in %s' % (str(v), pyfile))
globals()[k] = v
found_subclasses.add(v)
except Exception as e:
print('Exception occurred while searching %s' % path)
debugger.print_exception()
def email_tool(self,args):
addon = False
if os.path.exists('tools_functions\\address_book.py'):
address_book = importlib.__import__('address_book')
addon = True
message = input('Enter message body: ')
msg = MIMEText(message)
msg['Subject'] = 'Sent from %s' % sys.argv[0]
if args[0] == 'contact' and addon:
if len(args) > 2:
while len(args) > 2:
args[1] = args[1] + ' ' + args.pop(2)
name = args[1]
info = address_book.export(name,'email')
if info == -1:
print('Error: contact not found')
return;
else:
msg['To'] = info
elif args[0] == 'contact' and not addon:
print('Error: address_book module not found')
return;
else:
msg['To'] = args[0]
msg['From'] = input('\'From\' address: ')
mailHost = msg['From']
mailHost = mailHost[mailHost.index('@')+1:]
try:
s = smtplib.SMTP(serverDict[mailHost][0],serverDict[mailHost][1])
except KeyError:
print('Error: could not find server for ' + mailHost)
s.ehlo()
s.starttls()
if self.simpleDecrypt(self.settingsList['password'][0]) is '':
try:
s.login(msg['From'], getpass.getpass('password:'******'Invalid password: '******'quit':
try:
s.login(msg['From'], password)
password = '******'
except smtplib.SMTPAuthenticationError:
password = getpass.getpass('Invalid password: '******'From'], self.simpleDecrypt(self.settingsList['password'][0]))
except smtplib.SMTPAuthenticationError:
password = getpass.getpass('Error: unrecognized password in "settings.tool". Password: '******'quit':
try:
s.login(msg['From'], password)
s.send_message(msg)
password = '******'
except smtplib.SMTPAuthenticationError:
password = getpass.getpass('Invalid password: ')
s.quit()
def _load_plugins(self, config, script_path, reload=False):
# all_script = os.listdir(script_path)
if reload or not os.path.isdir(cfg.EXEC_TMP):
shutil.rmtree(cfg.EXEC_TMP, ignore_errors=True)
def ignore(src, names):
return [name for name in names if "pyc" in name]
shutil.copytree(script_path, cfg.EXEC_TMP, ignore=ignore)
#subprocess.call(["/usr/bin/env", "2to3-3.4", "-w", cfg.EXEC_TMP])
subprocess.call(["/usr/bin/env", "2to3", "-w", cfg.EXEC_TMP]) #DEBUG
modules = pkgutil.iter_modules([cfg.EXEC_TMP])
sys.path.insert(0, "{}/../".format(cfg.EXEC_TMP))
sys.path.insert(0, "{}/".format(cfg.EXEC_TMP))
importlib.__import__(cfg.SCT_TMP_PKG, globals(), locals(), [], 0)
sct_tools = []
for loader, mod_name, ispkg in modules:
module = importlib.import_module('.'+mod_name, package=cfg.SCT_TMP_PKG)
get_parser = getattr(module, cfg.GET_PARSER, None)
if get_parser:
parser = get_parser()
options = {}
for i, o in enumerate(parser.options.values()):
if not getattr(o, cfg.OPTION_DEPRECATED, None):
options.update({o.name: {k: v for k, v in o.__dict__.items()
if k in cfg.OPTION_TRANSMIT}})
#add a value key for user parameters
options[o.name]['value']=None
#add section handling
parser.usage.section[1] = "Main Config"
x = parser.usage.section
sorted_x = sorted(x.items(), key=operator.itemgetter(0))
for i in sorted_x:
if options[o.name]['order'] >= i[0]:
options[o.name]['section'] = i[1]
# options.sort(key=lambda e: e[cfg.OPTION_ORDER])
sct_tools.append(models.RegisteredTool(name=mod_name,
help_str=parser.usage.description,
options=options))
return sct_tools
def set_repo(mode='repo_mysql'):
global importlib
if importlib is None:
import importlib
global default_storage
try:
default_storage=getattr(importlib.__import__(mode),mode)
print("default repo changed to {}".format(mode))
except AttributeError:
print("class name in the module should be: {}".format(mode))
except ImportError:
print("module name '{}' not found".format(mode))
def destroydb(_ENGINE_NAME):
global ENGINE_NAME
global Session
assert ENGINE_NAME is None
assert Session is None
assert 'test' in _ENGINE_NAME
engine = create_engine(_ENGINE_NAME, echo=False, pool_recycle=300)
tables = walk_mods( importlib.__import__('n6wells').__path__ )
Base.metadata.drop_all(bind=engine)
def set_configuration_file(config_file):
""" Extract a config based on the contents of a python file. The file should contain a dict named
parsimony_configuration with keys from this module.
:param config_file: path to the config file
"""
module_name, extension = os.path.splitext(config_file)
module_path,module_name = os.path.split(module_name)
sys.path.append(module_path)
config_module = importlib.__import__(module_name)
update_configuration(**config_module.parsimony_configuration)
def isDynamicBlock(path):
""" Check if the file refers to a dynamic block
It returns the module if it is a dynamic block
"""
if os.path.splitext(path)[1] == ".py":
name = os.path.splitext(os.path.split(path)[1])[0]
mod = importlib.__import__(name)
try:
if mod.__isBlock__:
return mod
except:
return False
return False
def __init__(self, **kwargs):
for key, value in kwargs.items():
if key in System._attributes:
setattr(self, key, value)
else:
raise AttributeError("Unexpected kwarg {}.".format(key))
self._module = importlib.__import__(self.__class__.__module__)
if "hamiltonian" not in self.__dict__:
self.hamiltonian = 0
if "dynamics" not in self.__dict__:
self.dynamics = 0
self.drive_number = 0
def load(name): try: obj = __import__(name) reload(obj) return obj except: pass try: import importlib obj = importlib.__import__(name) importlib.reload(obj) return obj except: pass
def import_name_errors(*args, **kwargs):
try:
method(*args, **kwargs)
except NameError as e:
name = name_error(e)
if not name:
return False
if name in sys.modules:
return False
from importlib import __import__
module = __import__(name)
globals()[name] = module
method(*args, **kwargs)
if name not in importable:
importable[name] = module
def reload(cls):
cls.verboseLog(cls._tr("Reloading plugins"),
"pyTSon.PluginHost.reload")
# stop all running modules
for key, p in cls.active.items():
try:
p.stop()
except:
logprint(cls._tr("Error stopping python plugin {name}: "
"{trace}").format(name=key,
trace=traceback.
format_exc()),
ts3defines.LogLevel.LogLevel_ERROR,
"pyTSon.PluginHost.reload")
cls.active = {}
cls.plugins = {}
# import all modules
spath = pytson.getPluginPath("scripts")
for d in glob.glob(os.path.join(spath, "*/")):
if not os.path.isdir(d):
continue
base = os.path.relpath(d, spath)
try:
if base in cls.modules:
cls.modules[base] = importlib.reload(cls.modules[base])
else:
cls.modules[base] = importlib.__import__(base)
except:
logprint(cls._tr(
"Error loading python plugin from {path}: {trace}").
format(path=d, trace=traceback.format_exc()),
ts3defines.LogLevel.LogLevel_ERROR,
"pyTSon.PluginHost.reload")
# save local menu ids
for globid, (p, locid) in cls.menus.items():
# previously reloaded?
if not type(p) is str:
cls.menus[globid] = (p.name, locid)
# save local hotkeys
for keyword, (p, lockey) in cls.hotkeys.items():
if not type(p) is str:
cls.hotkeys[keyword] = (p.name, lockey)
def import_or_die(module_name, entrypoint_names):
'''
Import user code; return reference to usercode function.
(str) -> function reference
'''
log_debug("Importing {}".format(module_name))
module_name = os.path.abspath(module_name)
if module_name.endswith('.py'):
module_name,ext = os.path.splitext(module_name)
modname = os.path.basename(module_name)
dirname = os.path.dirname(module_name)
if dirname and dirname not in sys.path:
sys.path.append(dirname)
# first, try to reload code
if modname in sys.modules:
user_module = sys.modules.get(modname)
user_module = importlib.reload(user_module)
# if it isn't in sys.modules, load it for the first time, or
# try to.
else:
try:
mypaths = [ x for x in sys.path if ("Cellar" not in x and "packages" not in x)]
# print("Loading {} from {} ({})".format(modname, dirname, mypaths))
# user_module = importlib.import_module(modname)
user_module = importlib.__import__(modname)
except ImportError as e:
log_failure("Fatal error: couldn't import module (error: {}) while executing {}".format(str(e), modname))
raise ImportError(e)
# if there aren't any functions to call into, then the caller
# just wanted the module/code to be imported, and that's it.
if not entrypoint_names:
return
existing_names = dir(user_module)
for method in entrypoint_names:
if method in existing_names:
return getattr(user_module, method)
if len(entrypoint_names) > 1:
entrypoints = "one of {}".format(', '.join(entrypoint_names))
else:
entrypoints = entrypoint_names[0]
raise ImportError("Required entrypoint function or symbol ({}) not found in your code".format(entrypoints))
def emailToSMS(self, args):
addon = False
if os.path.exists('tools_functions\\address_book.py'):
address_book = importlib.__import__('address_book')
addon = True
carrierCodes = {
'sprint': '@messaging.sprintpcs.com',
'verizon': '@vtext.com',
't-mobile': '@tmomail.net',
'at&t': '@txt.att.net',
'virgin mobile': '@vmobl.com',
'us cellular': '@email.uscc.net',
'nextel': '@messaging.nextel.com',
'boost': '@myboostmobile.com',
'alltel': '@message.alltel.com'}
if args[0] == 'contact' and addon:
if len(args) > 2:
while len(args) > 2:
args[1] = args[1] + ' ' + args.pop(2)
name = args[1]
info = address_book.export(name,'phone')
if info == -1:
print('Error: contact not found')
return;
else:
number, carrier = info
elif args[0] == 'contact' and not addon:
print('Error: address_book module not found')
return;
else:
number = args[0]
carrier = args[1]
couldFindCarrier = True
if carrier not in carrierCodes:
couldFindCarrier = False
print('Error: unrecognized carrier.')
else:
toAddress = number + carrierCodes[carrier]
fromAddress = input('\'From\' address: ')
password = getpass.getpass()
messages = parseTXT(input('Message: '))
for segment in messages:
send(self, segment, fromAddress, password, toAddress)
def register_tables( engine ):
"""
simply walk the package hierarchy, thus ensuring that declarative
classes are registered
currently, recursion is disabled, as it winds up walking everything
thats ever imported, so make sure your models are exposed in the root
package namespace (ie, n6wells.foo)
"""
tables = walk_mods( importlib.__import__('n6wells').__path__ )
for tname, t in Base.metadata.tables.items():
for fk in t.foreign_keys:
fk.use_alter=True
fk.constraint.use_alter=True
Base.metadata.create_all(bind=engine)
for tablename, cls in tables.items():
print('@@ tablename=%s, cls=%s' % (tablename, cls))
globals()[tablename] = cls
__all__.append( tablename )
def init_functions(self):
if not os.path.isdir(self.toolsRoute):
print('tools_functions directory not found. Empty directory will be created.\n')
os.mkdir(self.toolsRoute)
return;
sys.path.insert(0,self.toolsRoute)
importList = os.listdir(self.toolsRoute)
for imp in importList:
if (imp[-3:]) == '.py':
module = imp[:-3]
obj = importlib.__import__(module) #this line causes mac specific problems
#possibilities include a difference in filenames (I'm pulling out '.py'), directory structure (I don't think so)
#or the fact that I'm explicitly doing an importlib.__import__ but thsi also shouldn't matter
#also, possibly a redundant import of the address book, although I'm not sure
try:
self.functions[getattr(obj, 'func_alias')] = getattr(obj, 'func_info')
settings = getattr(obj, 'settings', False)
if settings:
for key in settings:
self.settingsList[key] = settings[key]
except AttributeError:
print('Failed to load ' + imp + ' because it is not a properly formatted tools\nmodule. Please ensure it is written to template (check the readme).')
def parse(site):
rabbrs = {v: k for k, v in ABBRS.items()}
abbr = rabbrs[site]
parser = importlib.__import__('ybk.parsers.{}'.format(site),
fromlist=['Parser']).Parser()
log.info('解析交易所 {}'.format(abbr))
num_parsed = 0
num_failed = 0
for a in Announcement.query({'exchange': abbr,
'parsed': {'$ne': True}}):
log.info('parsing {}'.format(a.url))
try:
for c in parser.parse(a.type_, a.html):
c['from_url'] = a.url
Collection(c).upsert()
a.update({'$set': {'parsed': True}})
num_parsed += 1
except Exception as e:
num_failed += 1
if not isinstance(e, NotImplementedError):
log.exception('解析错误')
continue
log.info('解析完毕, {}个成功, {}个失败'.format(num_parsed, num_failed))
def check_qudi_modules(filelist):
from core.base import Base
from core.util.interfaces import InterfaceMetaclass
from gui.guibase import GUIBase
from logic.generic_logic import GenericLogic
from logic.generic_task import InterruptableTask, PrePostTask
othererror = []
importerror = []
importsuccess = []
modules = {
'hardware': {},
'logic': {},
'gui': {},
'interface': {},
'itask': {},
'pptask':{}
}
for f in filelist:
try:
mod = importlib.__import__(f, fromlist=['*'])
importsuccess.append(f)
thinglist = dir(mod)
for thingname in thinglist:
path = '{}.{}'.format(f, thingname)
thing = getattr(mod, thingname)
try:
if not inspect.isclass(thing):
continue
if issubclass(thing, GenericLogic) and thingname != 'GenericLogic':
modules['logic'][path] = Module(
path,
thingname,
thing,
[(i,v) for i, v in thing._connectors.items()],
[thingname]
)
elif issubclass(thing, GUIBase) and thingname != 'GUIBase':
modules['gui'][path] = Module(
path,
thingname,
thing,
[(i,v) for i, v in thing._connectors.items()],
[thingname]
)
elif issubclass(thing, InterruptableTask) and thingname != 'InterruptableTask' :
modules['itask'][path] = {'pause': [i for i in thing.pauseTasks]}
elif issubclass(thing, PrePostTask) and thingname != 'PerPostTask':
modules['pptask'][path] = {}
elif (issubclass(thing, Base)
and thingname != 'Base'
and thingname != 'GenericLogic'
and thingname != 'GUIBase'
):
modules['hardware'][path] = Module(
path,
thingname,
thing,
[(i,v) for i, v in thing._connectors.items()],
[thingname]
)
elif (f.startswith('interface')
and not issubclass(thing, Base)
and issubclass(thing.__class__, InterfaceMetaclass)
):
modules['interface'][path] = thing
else:
pass
except Exception as e:
pass
except ImportError as e:
importerror.append([f, e])
except Exception as e:
othererror.append([f, e])
for base in ['hardware', 'logic', 'gui']:
for modpath, module in modules[base].items():
for ifname, interface in modules['interface'].items():
n = ifname.split('.')[-1]
if issubclass(module.reference, interface):
module.interfaces.append(n)
return modules, importsuccess, importerror, othererror
def mock__import__(name, globals_=None, locals_=None, fromlist=(), level=0):
if level == 0 and name.partition('.')[0] == 'kubernetes':
raise ImportError("No module named 'kubernetes'")
return importlib.__import__(name, globals=globals_, locals=locals_, fromlist=fromlist, level=level)
import sys
import importlib
import boto3
from boto3.session import Session
try:
a=sys.argv[1]
props=importlib.__import__(a)
ofile=open(props.OUTPUT_FILE_PATH, "w+")
aws_access=props.ACCESS_KEY
aws_secret=props.SECRET_KEY
reg_name=props.REGION
node_count = props.NODES_COUNT
ins_type=props.NODES_TYPE
key_name=props.KEY_PAIR_NAME
#Starting session
session = Session(aws_access_key_id=aws_access,
aws_secret_access_key=aws_secret,
region_name=reg_name)
print("Session Started")
ec2 = session.resource('ec2')
ec2client=session.client('ec2')
if(ins_type=='ubuntu'):
image_id='ami-9abea4fb'
elif(ins_type=='redhat'):
image_id='ami-775e4f16'
elif(ins_type=='windows'):
image_id='ami-83a5bce2'
elif(ins_type=='suse'):
image_id='ami-d2627db3'
def __call__(self, *args, **kwargs):
if args[0] == 'threading':
raise ImportError
else:
return importlib.__import__(*args, **kwargs)
def runfsm(module_name, running_modules=dict()):
"""runfsm('modname') reloads that module and expects it to contain
a class of the same name. It calls that class's constructor and then
calls the instance's start() method."""
global running_fsm
robot = NewFSM.robot
if running_fsm:
stopAllMotors()
running_fsm.stop()
r_py = re.compile('.*\.py$')
if r_py.match(module_name):
print("\n'%s' is not a module name. Trying '%s' instead.\n" %
(module_name, module_name[0:-3]))
module_name = module_name[0:-3]
found = False
try:
reload(running_modules[module_name])
found = True
except KeyError:
pass
except:
raise
if not found:
try:
running_modules[module_name] = __import__(module_name)
except ImportError as e:
print("Error loading %s: %s. Check your search path.\n" %
(module_name, e))
return
except Exception as e:
print('\n===> Error loading %s:' % module_name)
raise
py_filepath = running_modules[module_name].__file__
fsm_filepath = py_filepath[0:-2] + 'fsm'
try:
py_time = datetime.datetime.fromtimestamp(
os.path.getmtime(py_filepath))
fsm_time = datetime.datetime.fromtimestamp(
os.path.getmtime(fsm_filepath))
if py_time < fsm_time:
cprint(
'Warning: %s.py is older than %s.fsm. Should you run genfsm?' %
(module_name, module_name),
color="yellow")
except:
pass
# The parent node class's constructor must match the module name.
the_module = running_modules[module_name]
the_class = the_module.__getattribute__(module_name) \
if module_name in dir(the_module) else None
# if not isinstance(the_class,type) or not issubclass(the_class,StateNode):
# cprint("Module %s does not contain a StateNode class named %s.\n" %
# (module_name, module_name), color="red")
# return
# print("StateMachineProgram robot in runfsm: {}".format(StateMachineProgram.robot))
running_fsm = the_class()
the_module.robot = robot
the_module.world = the_module.robot.world
the_module.charger = the_module.robot.world.charger
the_module.cube = the_module.robot.world.connected_light_cube
# StateMachineProgram.robot = robot
# Class's __init__ method will call setup, which can reference the above variables.
running_fsm.robot = robot
cli_globals = globals()
cli_globals['running_fsm'] = running_fsm
robot.conn.loop.call_soon(running_fsm.start)
return running_fsm
import sys
import logging
import importlib
import discord
from discord.ext import commands
from Framework import general_check
var_config = importlib.__import__("Config.var_config_" + sys.argv[1],
fromlist=("var_config_" + sys.argv[1]))
class Excuse(commands.Cog):
def __init__(self, client):
self.client = client
@commands.command(aliases=['excuse', 'ex'])
async def _excuse(self, ctx, *args: commands.Greedy[discord.Member]):
await excuse(ctx, args)
@commands.command(aliases=['unexcuse', 'unex', 'ux'])
async def _unexcuse(self, ctx, *args: commands.Greedy[discord.Member]):
await unexcuse(ctx, args)
async def excuse(ctx: discord.ext.commands.Context, args):
ismod = ctx.author.guild_permissions.administrator or ctx.author.guild_permissions.manage_roles or ctx.author.guild_permissions.manage_guild
if not await general_check.voice_channel_command_check(ctx):
return
# check if a user is practicing in the voice channel and if the user that executed the command is currently the one practicing in this voice channel, or a moderator
import importlib
a = importlib.import_module('os')
b = importlib.import_module('pickle')
c = importlib.__import__('sys')
d = importlib.__import__('subprocess')
predict_parser.add_argument('--show-plot',
action='store_true',
dest='show_plot')
predict_parser.add_argument('--save-plot',
action='store_true',
dest='save_plot')
args = parser.parse_args()
print(args)
if args.log_filter:
log.addFilter(CMDFilter(args.log_filter))
ROOT_DIR = initialize_task(args.hpconfig)
sys.path.append('.')
print(sys.path)
HPCONFIG = importlib.__import__(args.hpconfig.replace('.py', ''))
config.HPCONFIG = HPCONFIG.CONFIG
config.ROOT_DIR = ROOT_DIR
config.NAME = SELF_NAME
print('====================================')
print(ROOT_DIR)
print('====================================')
if config.CONFIG.flush:
log.info('flushing...')
dataset = load_data(config, filename=config.HPCONFIG.dataset_path)
pickle.dump(dataset,
open('{}/{}__cache.pkl'.format(ROOT_DIR, SELF_NAME), 'wb'))
else:
dataset = pickle.load(
open('{}/{}__cache.pkl'.format(ROOT_DIR, SELF_NAME), 'rb'))
# ToDo not yet ready for prime time
acq_e_h = None
#if args.delete:
# wm=pyinotify.WatchManager()
# wm.add_watch(args.base_path,pyinotify.ALL_EVENTS, rec=True)
# acq_e_h=EventHandler(lg=logger,fn=args.acquired_positions)
# nt=pyinotify.ThreadedNotifier(wm,acq_e_h)
# nt.start()
# ToD revisit dynamical loding
# now load meteo class ...
mt = importlib.import_module('meteo.' + args.meteo_class)
meteo = mt.Meteo(lg=logger)
# ... and device, ToDo revisit
mod = importlib.__import__('u_point.devices', fromlist=[args.device_class])
Device = getattr(mod, args.device_class)
quick_analysis = None
if args.do_quick_analysis:
quick_analysis = QuickAnalysis(
lg=logger,
ds9_display=args.ds9_display,
background_max=args.background_max,
peak_max=args.peak_max,
objects_min=args.objects_min,
exposure_interval=args.exposure_interval,
ratio_interval=args.ratio_interval)
px_scale = args.pixel_scale / 3600. / 180. * np.pi # arcsec, radian
obs = EarthLocation(lon=float(args.obs_lng) * u.degree,
if 'aug_mixup_alpha' not in conf:
conf.aug_mixup_alpha = 1.0
if 'samples_per_file' not in conf:
conf.samples_per_file = 1
if 'eval_ensemble' not in conf:
conf.eval_ensemble = True # Set False if samples_per_file > 1 but ensemble is not available
if 'what_is_sample' not in conf:
conf.what_is_sample = 'log mel-spectrogram'
if 'use_audio_training_model' not in conf:
conf.use_audio_training_model = True
#module dynamic import from variable 'moduleName' from config.py
import importlib
from config import *
module = importlib.__import__(moduleName, fromlist=['conf'])
conf = getattr(module, 'conf')
auto_complete_conf(conf)
print(conf)
# # Data utilities
def load_labels(conf):
conf.labels = load_npy(conf, 'labels.npy')
auto_complete_conf(conf)
print('Labels are', conf.labels)
def datapath(conf, filename):
return conf.folder / filename
import unittest
import sys
import os
# Stampa un'intestazione che descrive l'esercizio
lista_delle_funzioni = "\n".join(" - " + f for f in ex_functions)
print(__doc__.format(ex_name, lista_delle_funzioni))
errori_preliminari = False # il file ha la giusta struttura?
# Importa le soluzioni degli esercizi
print("CONTROLLO PRELIMINARE DEL FILE {0}.py:".format(ex_name))
lab = None
try:
lab = importlib.__import__(ex_name)
except Exception:
msg = """
Problema a importare il file {0}.py:
-- il file potrebbe non essere presente in questa cartella,
-- oppure potrebbe contenere errori che lo rendono non eseguibile.
Provate ad eseguire il comando 'python3 {0}.py' da terminale per
avere più informazioni. """.format(ex_name)
print(msg)
errori_preliminari = True
else:
#Carica nel namespace le funzioni definite
f_objects = {}
for f_name in ex_functions:
try:
def import_(*args, **kwargs):
"""Delegate to allow for injecting different implementations of import."""
if using___import__:
return __import__(*args, **kwargs)
else:
return importlib.__import__(*args, **kwargs)
from __future__ import print_function # makes this work for python2 and 3
import gvar as gv
import corrfitter as cf
def main():
data, basis = make_data('etab.h5')
s = gv.dataset.svd_diagnosis((data, 113), models=make_models())
print('svdcut =', s.svdcut)
s.plot_ratio(show=True)
import importlib
import sys
if sys.version_info > (2, ):
etab_alt = importlib.import_module('etab-alt')
else:
etab_alt = importlib.__import__('etab-alt')
make_models = etab_alt.make_models
make_data = etab_alt.make_data
if __name__ == '__main__':
main()
