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_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']}})
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>'), ))