def test_get(self):
registry = Registry()
registry.load({'a': {'aa': 'aaa'}})
self.assertEqual(registry.get(), {'a': {'aa': 'aaa'}})
self.assertEqual(registry.get('a'), {'aa': 'aaa'})
self.assertEqual(registry.get('a.aa'), 'aaa')
self.assertEqual(registry.get('b', ['b']), ['b'])
def test_default(self):
registry = Registry()
registry.set('a', 'aaa')
self.assertEqual(registry.default('a', 'bbb'), 'aaa')
self.assertEqual(registry.get('a'), 'aaa')
self.assertEqual(registry.default('c', 'ccc'), 'ccc')
self.assertEqual(registry.get('c', 'ccc'), 'ccc')
def test_default(self):
"""测试设置默认值"""
registry = Registry({'a': 'aaa'})
self.assertEqual(registry.default('a', 'bbb'), 'aaa')
self.assertEqual(registry.get('a'), 'aaa')
self.assertEqual(registry.default('c', 'ccc'), 'ccc')
self.assertEqual(registry.get('c', 'ccc'), 'ccc')
def test_get(self):
"""测试获取配置项"""
registry = Registry({'a': {'aa': 'aaa'}})
self.assertEqual(registry.get(), {'a': {'aa': 'aaa'}})
self.assertEqual(registry.get('a'), {'aa': 'aaa'})
self.assertEqual(registry.get('a.aa'), 'aaa')
self.assertEqual(registry.get('b', ['b']), ['b'])
def test_hook(self):
"""测试钩子"""
registry = Registry()
def callback():
registry.set('a', 'aaa')
return True
registry.set_hook('hook', 3, callback)
time.sleep(1)
registry.refresh_hook('hook')
self.assertEqual(registry.get('a'), None)
time.sleep(3)
registry.refresh_hook('hook')
self.assertEqual(registry.get('a'), 'aaa')
def from_options(options):
if options.data_format in Registry.keys('data'):
cls = Registry.get('data', options.data_format)
return cls(options)
else:
raise RegistryError(
f'missing value {options.data_format} for namespace `data`')
def from_options(options, discriminator):
if options.loss in Registry.keys('loss'):
cls = Registry.get('loss', options.loss)
return cls(options, discriminator)
else:
raise RegistryError(
f'missing value {options.loss} for namespace `loss`')
def from_options(options):
if options.log in Registry.keys('log'):
cls = Registry.get('log', options.log)
return cls(options)
else:
raise RegistryError(
f'missing value {options.log} for namespace `log`')
def main():
"""Main function."""
registry = Registry()
registry.register(FloodImpactFunction)
registry.list()
function = registry.get('FloodImpactFunction')
function.extent = [10, 10, 20, 20]
function.extent_crs = [4326]
function_parameters = function.parameters()
for x in function_parameters:
print '--', x.name, x.value
print 'Change value of target field to FLOODED:'
function_parameters[0].value = 'FLOODED'
function_parameters = function.parameters()
for x in function_parameters:
print '--', x.name, x.value
function.run()
hazard_keywords = {
'subcategory': hazard_tsunami,
'units': unit_wetdry,
'layer_constraints': layer_vector_polygon
}
exposure_keywords = {
'subcategory': exposure_structure,
'units': unit_building_type_type,
'layer_constraints': layer_vector_polygon
}
impact_functions = registry.filter(hazard_keywords, exposure_keywords)
print len(impact_functions)
print [x.metadata()['name'] for x in impact_functions]
def from_options(options):
if options.noise in Registry.keys('noise'):
cls = Registry.get('noise', options.noise)
return cls(options)
else:
raise RegistryError(
f'missing value {options.noise} for namespace `noise`')
def from_options(options, generator, discriminator, loss, hooks):
if options.game in Registry.keys('game'):
cls = Registry.get('game', options.game)
return cls(options, generator, discriminator, loss, hooks)
else:
raise RegistryError(
f'missing value {options.game} for namespace `game`')
def from_options(options):
if options.evaluation_criterion in Registry.keys('evaluation'):
cls = Registry.get('evaluation', options.evaluation_criterion)
return cls(options)
else:
raise RegistryError(
f'missing value {options.evaluation_criterion} for namespace `evaluation`'
)
def from_options(options):
if options.save_images_as in Registry.keys('snapshot'):
cls = Registry.get('snapshot', options.save_images_as)
return cls(options)
else:
raise RegistryError(
f'missing value {options.save_images_as} for namespace `snapshot`'
)
def test_create_entity_instance(registry: Registry):
h = Hello()
h.id = 1
h.value = 'Hello'
new_h = registry.insert(h)
assert len(registry.list(Hello)) == 1
assert registry.get(Hello, h.id)
class Aria2Local(object):
process: subprocess.Popen or None
def __init__(self, program='aria2c', **kwargs):
self.program = program
self.process = None
self.args = Registry(kwargs.get('args'))
self.args.default('rpc-listen-port', '6800')
self.args.default('enable-rpc', 'true')
self.args.default('rpc-allow-origin-all', 'true')
self.args.default('rpc-listen-all', 'true')
def set_arg(self, key, value):
self.args.set(key, value)
def get_args_string(self):
return ' '.join([
'--%s=%s' % (key, value) for key, value in self.args.get().items()
])
def start(self):
"""启动服务"""
cmd = '%s %s' % (self.program, self.get_args_string())
self.process = subprocess.Popen(cmd,
shell=False,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
return self.process.pid
def stop(self):
"""停止服务"""
if self.process is not None:
parent = psutil.Process(self.process.pid)
for child in parent.children(recursive=True):
child.terminate()
parent.terminate()
return self.process.wait()
else:
return None
def is_install(self):
"""是否安装"""
cmd = '%s --version' % self.program
process = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stderr_line = process.stderr.readline()
if stderr_line == b'':
return True
else:
return False
def is_running(self):
"""是否运行"""
return self.process is not None and self.process.poll() is None
def test_set(self):
registry = Registry()
registry.set('a', 'a')
registry.set('b', [1, 2])
registry.set('c.h', 'h')
self.assertEqual(registry.get(), {
'a': 'a',
'b': [1, 2],
'c': {
'h': 'h'
}
})
class MySQL(object):
def __init__(self, *args, **kwargs):
self.options = Registry(kwargs.get('options', {}))
self.pool = None
self.server = None
self.state = kwargs.get('state', True)
self.options.default('host', '127.0.0.1')
self.options.default('user', 'root')
self.options.default('password', '')
self.options.default('charset', 'utf8')
def set_option(self, key, value):
self.options.set(key, value)
def get_pool(self) -> PooledDB:
if self.pool is None:
self.pool = PooledDB(creator=pymysql, cursorclass=DictCursor, **self.options.get())
return self.pool
def reconnect(self):
self.pool = None
self.server = self.get_pool().connection()
def get_tmp_server(self) -> Connection:
return self.get_pool().connection()
def get_server(self) -> Connection:
if self.server is None:
self.server = self.get_pool().connection()
return self.server
def check_state(self) -> bool:
try:
self.server.ping()
self.state = True
except:
self.state = False
return self.state
def check_wait(self, interval_time=60):
while self.check_state() is False:
time.sleep(interval_time)
def __new__(cls, *args, **kwargs):
instance = kwargs.get('instance', 0)
if not hasattr(cls, '_instances'):
cls._instances = {}
if instance not in cls._instances:
cls._instances[instance] = object.__new__(cls)
return cls._instances[instance]
def test_unset(self):
"""测试删除配置项"""
registry = Registry()
registry.set('a', 'a')
registry.set('b', [1, 2])
registry.set('c.i.h', 'h')
registry.set('c.i.j', 'j')
registry.unset('c.i.h')
self.assertEqual(registry.get(), {
'a': 'a',
'b': [1, 2],
'c': {
'i': {
'j': 'j'
}
}
})
registry.unset('c.i.j', clear=True)
self.assertEqual(registry.get(), {
'a': 'a',
'b': [1, 2]
})
def test_merge(self):
registry = Registry()
registry.load({'a': {
'h': 'h',
'i': 'i',
}})
registry.merge('a', {
'g': 'g',
})
self.assertEqual(registry.get(),
{'a': {
'h': 'h',
'i': 'i',
'g': 'g',
}})
def test_load(self):
"""测试加载配置项"""
d = {
'a': 'a',
'b': 1,
'c': {
'h': 'h',
},
'd': [1, 2],
'e': True,
'f': 1.1,
}
registry = Registry()
registry.load(d)
self.assertEqual(registry.get(), d)
def from_options(options):
if options.generator in Registry.keys('generator'):
cls = Registry.get('generator', options.generator)
generator = cls(options)
else:
raise RegistryError(
f'missing value {options.generator} for namespace `generator`')
if options.restore:
state_dict = torch.load(
os.path.join(options.model_dir, options.experiment,
'generator.pt'))
generator.load_state_dict(state_dict)
generator = generator.to(options.device)
if options.parallel:
generator = nn.DataParallel(generator)
return generator
def test_merge(self):
"""测试合并配置"""
registry = Registry({
'a': {
'h': 'h',
'i': 'i',
}
})
registry.merge({
'a': {
'g': 'g',
}
})
self.assertEqual(registry.get(), {
'a': {
'h': 'h',
'i': 'i',
'g': 'g',
}
})
class RegistryClient(object, IRegistryClient):
def __init__(self, update_period=10, refresh_callback=None, server_uri=None):
if server_uri:
self.server_uri = server_uri
else:
self.server_uri = SERVER_URI
self.__refresh_callback = refresh_callback
self.__update_period = update_period
self.__socket = Socket(self.server_uri)
self.__registry = Registry()
self.refresh()
self.__update_thread = UpdateThread(self, update_period)
self.__update_thread.daemon = True
self.__update_thread.start()
def get(self, key):
return self.__registry.get(key)
def set(self, key, value):
return self.__registry.set(key, value)
def remove(self, key):
return self.__registry.remove(key)
def refresh(self):
current_version = self.__socket.send('get_version')
if self.__registry.get_version() != current_version:
self._load()
if self.__refresh_callback:
self.__refresh_callback(self)
def _load(self):
try:
(version, values) = self.__socket.send('get_values')
self.__registry.set_values(values, version)
except Exception, err:
print "Ops:", err
pass
class Redis(object):
def __init__(self, **kwargs):
self.options = Registry(kwargs)
self.pool = None
self.server = None
self.state = kwargs.get('state', False)
self.options.default('host', '127.0.0.1')
self.options.default('port', 6379)
self.options.default('db', 0)
self.options.default('decode_responses', True)
def set_option(self, key, value):
self.options.set(key, value)
def reconnect(self):
self.pool = redis.ConnectionPool(**self.options.get())
self.server = redis.Redis(connection_pool=self.pool)
def get_server(self) -> redis.Redis:
if self.server is None:
self.reconnect()
return self.server
def check_state(self):
try:
self.server.ping()
self.state = True
except:
self.state = False
return self.state
def check_wait(self, interval_time=60):
while self.check_state() is False:
time.sleep(interval_time)
def test_lookup(self):
registry = Registry()
registry.register('a', 1)
self.assertEqual(1, registry.get('a'))
import logging
from registry import Registry
from libs.excepts import ExceptionService
from libs.server import get_mysql_server, get_redis_server, \
get_mqtt_server, get_mysql_url
from . import GlobalConfigFile, app_options
logger = logging.getLogger()
"""获取服务配置"""
server_options = Registry(GlobalConfigFile.load_app('server'))
"""初始化 MySQL 服务"""
mysql_enable = app_options.get('server.mysql_enable', False)
mysql_options = server_options.get('mysql_server')
if mysql_enable is True:
if mysql_options is None:
raise ExceptionService('MySQL 配置为 None')
mysql_pool, mysql_server = get_mysql_server(mysql_options)
mysql_db_url = get_mysql_url(mysql_options)
mysql_server.ping()
"""初始化 Redis 服务"""
redis_enable = app_options.get('server.redis_enable', False)
redis_options = server_options.get('redis_server')
if redis_enable is True:
if redis_options is None:
raise ExceptionService('Redis 配置为 None')
redis_server = get_redis_server(redis_options)
redis_server.ping()
"""初始化 MQTT 服务"""
def test_unknown_entry(self):
registry = Registry()
with self.assertRaises(NoSuchMachineException):
registry.get('b')
def test_alias(self):
registry = Registry()
registry.register('a', 1)
registry.add_alias('b', 'a')
self.assertEqual(registry.resolve_alias('b'), 'a')
self.assertEqual(1, registry.get('b'))
def test_lookup(self):
registry = Registry()
registry.register('a', 1)
self.assertEqual(1, registry.get('a'))
def test_init(self):
registry = Registry({'a': {'aa': 'aaa'}})
self.assertEqual(registry.get(), {'a': {'aa': 'aaa'}})
self.assertEqual(registry.get('a.aa'), 'aaa')
def test_append(self):
"""测试列表追加值"""
registry = Registry({'a': {'b': ['c', 'd']}})
registry.append('a.b', 'e')
self.assertEqual(registry.get(), {'a': {'b': ['c', 'd', 'e']}})
def test_alias(self):
registry = Registry()
registry.register('a', 1)
registry.add_alias('b', 'a')
self.assertEqual(registry.resolve_alias('b'), 'a')
self.assertEqual(1, registry.get('b'))
class App(object):
def __init__(self, args):
self.args = args
self.options = Registry()
self.init_options()
self.init_env()
self.client = self.mysql_server()
def init_options(self):
self.options.load(dict(args=self.args))
self.options.default('args.<hostname>', 'localhost')
self.options.default('args.<password>', '')
def dispose(self):
args = self.options.get('args')
if args.get('adduser'):
self.adduser()
elif args.get('passwd'):
self.passwd()
elif args.get('create'):
if args.get('database'):
self.create_database()
else:
pass
else:
pass
def mysql_server(self):
options = self.options.get('server')
[
logging.debug('MySQL Server: %s=%s' % (key, value))
for key, value in options.items()
]
try:
return pymysql.connect(cursorclass=pymysql.cursors.DictCursor,
**options)
except pymysql.err.MySQLError as ex:
logging.error(ex)
exit(ex.args[0])
def init_env(self):
"""加载环境变量"""
self.options.set(
'server',
dict(
host=os.getenv('MYSQL_HOST', self.options.get('args.--host')),
port=int(
os.getenv('MYSQL_PORT', self.options.get('args.--port'))),
user=os.getenv('MYSQL_USER', self.options.get('args.--user')),
password=os.getenv('MYSQL_PASSWORD',
self.options.get('args.--password')),
charset=os.getenv('MYSQL_CHARSET',
self.options.get('args.--charset')),
))
def execute(self, sql):
sql_list = [i for i in sql.split('\n') if i != '']
with self.client.cursor() as cursor:
for sql in sql_list:
logging.debug('Execute Sql: %s' % sql)
cursor.execute(sql)
self.client.commit()
def adduser(self):
self.execute(__SQL_ADDUSER__ % dict(
hostname=self.options.get('args.<hostname>'),
username=self.options.get('args.<username>'),
password=self.options.get('args.<password>'),
))
def passwd(self):
self.execute(__SQL_PASSWD__ % dict(
hostname=self.options.get('args.<hostname>'),
username=self.options.get('args.<username>'),
password=self.options.get('args.<password>'),
))
def create_database(self):
self.execute(__SQL_CREATE_DATABASE__ %
dict(database=self.options.get('args.<database>'), ))
def test_unknown_entry(self):
registry = Registry()
with self.assertRaises(NoSuchMachineException):
registry.get('b')
