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 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 test_rate_db(self):
dao = DAO(self.dsn)
registry = Registry('test')
registry.save_data("% BTG 1", dao)
self.assertEqual(dao.get_member('test'), [('test', 600, None, None)])
self.assertEqual(dao.get_conditions(), [('test', 1, 'BTG', '%', 1.0)])
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 add_options(parser, train):
group = parser.add_argument_group('result snapshotting')
group.add_argument('--save-images-as',
choices=Registry.keys('snapshot'),
default=Registry.default('snapshot'),
help='how to save the output images')
group.add_argument(
'--output-dir',
default='output',
help='directory where to store the generated images')
group.add_argument(
'--snapshot-size',
type=int,
default=16,
help=
'how many images to generate for each sample (must be <= batch-size)'
)
group.add_argument('--sample-every',
type=int,
default=10,
help='how often to sample images (in epochs)')
group.add_argument(
'--sample-from-fixed-noise',
action=YesNoAction,
help='always use the same input noise when sampling')
group.add_argument(
'--snapshot-translate',
action=YesNoAction,
help='generate snapshots for an image translation task')
def add_options(parser, train):
if train:
group = parser.add_argument_group('training options')
group.add_argument('--game',
choices=Registry.keys('game'),
default=Registry.default('game'),
help='type of game')
group.add_argument('--generator-iterations',
type=int,
default=1,
help='number of iterations for the generator')
group.add_argument(
'--discriminator-iterations',
type=int,
default=1,
help='number of iterations for the discriminator')
group.add_argument('--generator-lr',
type=float,
default=1e-4,
help='learning rate for the generator')
group.add_argument('--discriminator-lr',
type=float,
default=1e-4,
help='learning rate for the discriminator')
group.add_argument('--beta1',
type=float,
default=0,
help='first beta')
group.add_argument('--beta2',
type=float,
default=0.9,
help='second beta')
group.add_argument('--max-batches-per-epoch',
type=int,
help='maximum number of minibatches per epoch')
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.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 add_options(parser, train):
if train:
group = parser.add_argument_group('loss computation')
group.add_argument('--loss',
choices=Registry.keys('loss'),
default=Registry.default('loss'),
help='GAN loss')
group.add_argument(
'--gradient-penalty-factor',
type=float,
default=10,
help='gradient penalty factor (lambda in WGAN-GP)')
group.add_argument('--soft-labels',
action=YesNoAction,
help='use soft labels in GAN loss')
group.add_argument('--noisy-labels',
action=YesNoAction,
help='use noisy labels in GAN loss')
group.add_argument(
'--noisy-labels-frequency',
type=float,
default=0.1,
help='how often to use noisy labels in GAN loss')
group.add_argument(
'--l1-weight',
type=float,
default=1,
help='weight of the L1 distance contribution to the GAN loss')
def certificates_page():
registry_contract = Registry()
certificates = registry_contract.get_all_certificates()
return render_template(
"certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"])
class TestDeleteTagsByAge(unittest.TestCase):
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.get_tag_config_mock = MagicMock(return_value={'mediaType': 'application/vnd.docker.container.image.v1+json', 'size': 12953,
'digest': 'sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8'})
self.registry.get_tag_config = self.get_tag_config_mock
self.get_image_age_mock = MagicMock(
return_value="2017-12-27T12:47:33.511765448Z")
self.registry.get_image_age = self.get_image_age_mock
self.list_tags_mock = MagicMock(return_value=["image"])
self.registry.list_tags = self.list_tags_mock
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200, "MOCK_DIGEST")
@patch('registry.Registry.get_delete_digests')
@patch('registry.Registry.get_keep_digests')
def test_find_digests_to_delete_tags_by_age_no_keep(self, get_keep_digests_patched, get_delete_digests_patched):
get_keep_digests_patched.return_value = []
all_tags_list = self.registry.list_tags("imagename")
tags_to_keep = get_newer_tags(self.registry, "imagename", 24, all_tags_list)
find_digests_to_delete(registry=self.registry, image_name="imagename",
tags_to_delete=all_tags_list, tags_to_keep=tags_to_keep)
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
get_keep_digests_patched.assert_called_with(image_name="imagename", tags_to_keep=[])
get_delete_digests_patched.assert_called_with(image_name="imagename", tags_to_delete=['image'], digests_to_keep=[])
@patch('registry.Registry.get_delete_digests')
@patch('registry.Registry.get_keep_digests')
def test_find_digests_to_delete_by_age_no_keep_with_non_utc_value(self, get_keep_digests_patched, get_delete_digests_patched):
get_keep_digests_patched.return_value = []
self.registry.get_image_age.return_value = "2017-12-27T12:47:33.511765448+02:00"
all_tags_list = self.registry.list_tags("imagename")
tags_to_keep = get_newer_tags(self.registry, "imagename", 24, all_tags_list)
find_digests_to_delete(registry=self.registry, image_name="imagename",
tags_to_delete=all_tags_list, tags_to_keep=tags_to_keep)
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
get_keep_digests_patched.assert_called_with(image_name="imagename", tags_to_keep=[])
get_delete_digests_patched.assert_called_with(image_name="imagename", tags_to_delete=['image'], digests_to_keep=[])
@patch('registry.Registry.get_delete_digests')
@patch('registry.Registry.get_keep_digests')
def test_find_digests_to_delete_by_age_keep_tags_by_age(self, get_keep_digests_patched, get_delete_digests_patched):
get_keep_digests_patched.return_value = ["MOCK_DIGEST"]
all_tags_list = self.registry.list_tags("imagename")
self.registry.get_image_age.return_value = str(datetime.now(tz=tzutc()))
tags_to_keep = get_newer_tags(self.registry, "imagename", 24, all_tags_list)
find_digests_to_delete(registry=self.registry, image_name="imagename",
tags_to_delete=all_tags_list, tags_to_keep=tags_to_keep)
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
get_keep_digests_patched.assert_called_with(image_name="imagename", tags_to_keep=['image'])
get_delete_digests_patched.assert_called_with(image_name="imagename", tags_to_delete=['image'], digests_to_keep=["MOCK_DIGEST"])
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 add_options(parser, train):
if train:
group = parser.add_argument_group('logging')
group.add_argument('--log',
choices=Registry.keys('log'),
default=Registry.default('log'),
help='logging format')
group.add_argument('--log-file', help='file to log statistics')
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 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 add_options(parser, train):
if train:
group = parser.add_argument_group('model evaluation')
group.add_argument(
'--evaluation-criterion',
choices=Registry.keys('evaluation'),
default=Registry.default('evaluation'),
help='the criterion to evaluate model improvement')
def test_registry_insert (self):
reg = Registry ()
for i in range (10):
request = Request ()
request._value = "foo" + str (i)
print request._value
request_id = reg.register (request)
self.assertEqual (request._value, reg[request_id]._value)
class TestListTags(unittest.TestCase):
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200)
def test_list_one_tag_ok(self):
self.registry.http.reset_return_value(
status_code=200, text=u'{"name":"image1","tags":["0.1.306"]}')
response = self.registry.list_tags('image1')
self.assertEqual(response, ["0.1.306"])
self.assertEqual(self.registry.last_error, None)
def test_list_tags_invalid_http_response(self):
self.registry.http.reset_return_value(status_code=400, text="")
response = self.registry.list_tags('image1')
self.assertEqual(response, [])
self.assertEqual(self.registry.last_error, 400)
def test_list_tags_invalid_json(self):
self.registry.http.reset_return_value(status_code=200,
text="invalid_json")
response = self.registry.list_tags('image1')
self.assertEqual(response, [])
self.assertEqual(self.registry.last_error,
"list_tags: invalid json response")
def test_list_one_tag_sorted(self):
self.registry.http.reset_return_value(
status_code=200,
text=u'{"name":"image1","tags":["0.1.306", "0.1.300", "0.1.290"]}')
response = self.registry.list_tags('image1')
self.assertEqual(response, ["0.1.290", "0.1.300", "0.1.306"])
self.assertEqual(self.registry.last_error, None)
def test_list_tags_like_various(self):
tags_list = set(
['FINAL_0.1', 'SNAPSHOT_0.1', "0.1.SNAP", "1.0.0_FINAL"])
self.assertEqual(get_tags(tags_list, "", set(["FINAL"])),
set(["FINAL_0.1", "1.0.0_FINAL"]))
self.assertEqual(get_tags(tags_list, "", set(["SNAPSHOT"])),
set(['SNAPSHOT_0.1']))
self.assertEqual(
get_tags(tags_list, "", set()),
set(['FINAL_0.1', 'SNAPSHOT_0.1', "0.1.SNAP", "1.0.0_FINAL"]))
self.assertEqual(get_tags(tags_list, "", set(["ABSENT"])), set())
self.assertEqual(get_tags(tags_list, "IMAGE:TAG00", ""),
set(["TAG00"]))
self.assertEqual(
get_tags(tags_list, "IMAGE:TAG00",
set(["WILL_NOT_BE_CONSIDERED"])), set(["TAG00"]))
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 CoapClass(ProtocolClient):
def __init__(self):
self.port = 5683
self.reg = Registry()
self.send = Sender()
#self.coapSensors = self.reg.getCoapSensors()
def dataProcessing(self, receivedData):
if (receivedData["registred"] != True):
print(receivedData['regInfos'])
dbIds = self.reg.registerResourceIC(receivedData['localId'],
receivedData['regInfos'])
dbIds = True
if (dbIds != False):
print(' ')
print('call reg')
dbIds = self.reg.consultRegister(receivedData['localId'])
if (dbIds != False):
dbIds = self.reg.registerResourceIC(
receivedData['localId'], receivedData['regInfos'])
#print(self.coapSensors)
else:
print('erro no cadastro')
else:
print('Sensor without status identified')
#if is a sensor without state
dbIds = self.reg.registerResourceIC(receivedData['localId'],
receivedData['regInfos'])
if (dbIds != False):
#send data to IC
self.send.sendDataIC(dbIds, receivedData['data'])
def startListening(self):
print("\033[33mSTART LISTENING COAP INITIALIZED\033[m")
server = CoAPServer("0.0.0.0", 5683)
try:
server.listen(10)
except KeyboardInterrupt:
print("Server Shutdown")
server.close()
print("Exiting...")
def requestSensorData(self):
print("\033[35mREQUEST SENSOR DATA INITIALIZED\033[m")
path = 'data'
#for sensor in self.coapSensors:
client = HelperClient(server=(self.coapSensors["sensor"]["address"],
5683))
self.response = client.get(path)
self.data = json.loads(self.response.payload)
print(self.data)
#dbIds = self.reg.consultRegister(self.data['localId'])
#self.send.sendDataIC(dbIds,self.data)
print('Sended')
class TestImageAge(unittest.TestCase):
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200)
def test_image_age_ok(self):
self.registry.http.reset_return_value(
200,
'''
{
"architecture": "amd64",
"author": "Test",
"config": {},
"container": "c467822c5981cd446068eebafd81cb5cde60d4341a945f3fbf67e456dde5af51",
"container_config": {},
"created": "2017-12-27T12:47:33.511765448Z",
"docker_version": "1.11.2",
"history": []
}
'''
)
json_payload = {'mediaType': 'application/vnd.docker.container.image.v1+json', 'size': 12953,
'digest': 'sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8'}
header = {"Accept": "{0}".format(json_payload['mediaType'])}
response = self.registry.get_image_age('image1', json_payload)
self.registry.http.request.assert_called_with(
"GET",
"http://testdomain.com/v2/image1/blobs/sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8",
auth=(None, None),
headers=header,
verify=True)
self.assertEqual(
response, "2017-12-27T12:47:33.511765448Z")
self.assertEqual(self.registry.last_error, None)
def test_image_age_nok(self):
self.registry.http.reset_return_value(400, "err")
json_payload = {'mediaType': 'application/vnd.docker.container.image.v1+json', 'size': 12953,
'digest': 'sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8'}
header = {"Accept": "{0}".format(json_payload['mediaType'])}
response = self.registry.get_image_age('image1', json_payload)
self.registry.http.request.assert_called_with(
"GET",
"http://testdomain.com/v2/image1/blobs/sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8",
auth=(None, None),
headers=header,
verify=True)
self.assertEqual(response, [])
self.assertEqual(self.registry.last_error, 400)
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 setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200, "MOCK_DIGEST")
self.registry.http.return_value.headers = {
'Content-Length': '4935',
'Docker-Content-Digest': 'MOCK_DIGEST_HEADER',
'X-Content-Type-Options': 'nosniff'
}
def add_options(parser, train):
group = parser.add_argument_group('noise generation')
group.add_argument('--noise',
choices=Registry.keys('noise'),
default=Registry.default('noise'),
help='type of noise')
group.add_argument('--state-size',
type=int,
default=128,
help='state size')
def test_rate(self):
registry = Registry('test')
user_json, cond_json = registry.proc_cmd("% BTG 1")
user_dic = {'userid': 'test', 'gap': 600}
self.assertEqual(user_json, user_dic)
self.assertEqual(cond_json, {
'userid': 'test',
'%': 1,
'currency': 'BTG'
})
def __init__(self, args):
self.args = args
Data.__init__(self, self.args.input_file)
self.population = []
for _ in range(self.args.population_size):
self.population.append(Individual(self.items, self.args))
self.elite = Elite(self.args, list(self.items.keys()), self.population)
self.registry = Registry(self.elite)
self.runEvolutive()
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 my_certificates_page():
owner = request.form.get("owner") or None
private_key = request.form.get("private_key") or None
registry_contract = Registry(owner)
certificates = registry_contract.get_my_certificates()
return render_template(
"my_certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def test_flat(self):
"""测试扁平处理"""
registry = Registry({
'a': {
'h': 'h',
'i': 'i',
}
})
self.assertEqual(registry.flat(), {
'a.h': 'h',
'a.i': 'i',
})
def redeem_certificate_request():
owner = request.form.get("owner")
private_key = request.form.get("private_key")
certificate_id = int(request.form.get("certificate_id"))
registry_contract = Registry(owner, private_key)
registry_contract.redeem_certificate(certificate_id)
certificates = registry_contract.get_my_certificates()
return render_template(
"my_certificates.html",
certificates=certificates,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def verify_certificate_request():
owner = request.form.get("owner")
private_key = request.form.get("private_key")
certificate_index = request.form.get("certificate_index")
certificate_data = certificates_for_verifying[int(certificate_index)]
registry_contract = Registry(owner, private_key)
registry_contract.verify_certificate(certificate_data)
del certificates_for_verifying[int(certificate_index)]
return render_template(
"agent.html",
certificates=certificates_for_verifying,
smart_contract_address=ETHEREUM_SETTINGS["REGISTRY_CONTRACT_ADDRESS"],
owner=owner,
private_key=private_key)
def checkDatatype(self, field_id, value, data):
""" Check data type of value. Lists (multiple) is also ok. """
# check only if field is relevant
# generic business rule!
relevant = self.isRelevant(field_id, data)
if not relevant:
return True
valid = True
for props in self.getFieldProperties(field_id):
datatype = props.getDatatype()
if datatype:
try:
validator = Registry.get_validator(datatype)
if validator:
valid = validator(value)
if not valid:
break
except:
valid = False
break
return valid
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 __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 convert(self, field_id, value):
""" Convert field tp type given in constraint """
for props in self.getFieldProperties(field_id):
datatype = props.getDatatype()
if datatype:
converter = Registry.get_converter(datatype)
if converter:
value = converter(value)
return value
def __init__(self, target, name = None):
self.target = target
self.name = name if name else utils.randStr()
self.health = logic.getSystemVitality(self.target)
self.next_question = time.time() + 5
self.start_time = self.next_question
self.defenders = {}
self.offenders = {}
self.cooldowns = {}
self.questions = logic.getQuestions(self.target)
self.question = None
self.registry = Registry()
def __init__(self, target, name = None):
self.target = target
self.name = name if name else utils.randStr()
self.health = logic.getSystemVitality(self.target)
self.next_question = None
self.start_time = None
self.defenders = {}
self.offenders = {}
# self.cooldowns = {}
self.questions = logic.getQuestions(self.target)
self.question = None
self.registry = Registry()
self.print_queue = Queue()
self.defeated_commands = None
self.defeated_timeout = None
self.reward_person = None
self.reward_timeout = None
self.saved_message = None
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
<input type="hidden" name="type" value="snippet"/>
<input type="hidden" name="mode" value="${data.get('mode', 'add')}"/>
ID: <input type="text" name="id" value="${data.get('id', '')}"/><br/>
<textarea name="snippet" rows="10" cols="80">${data.get('snippet', '')}</textarea><br/>
<input type="submit" value="Save"/>
<input type="button" name="cancel" value="Cancel"/>
</form>
"""
class SnippetBlock(Block):
add_form = edit_form = FORM
def __init__(self, block_id, **props):
Block.__init__(self, block_id, **props)
self.type = "snippet"
class SnippetBlockView(BlockView):
@property
def snippet(self):
return self.context.get('snippet', '')
Registry.register_type("snippet", SnippetBlock)
class Conf(object):
__slots__ = [
"target",
"name",
"health",
"next_question",
"defenders",
"offenders",
"question",
"start_time",
"registry",
"cooldowns",
"questions",
"print_queue",
"defeated_commands",
"reward_person",
"reward_timeout",
"defeated_timeout",
"cmd_request_sent",
"reward_cmd",
"reward_args",
"police_notify_sent",
"stat_cooldown",
]
def __init__(self, target, name=None):
self.target = target
self.name = name if name else utils.randStr()
self.health = logic.getSystemVitality(self.target)
self.next_question = None
self.start_time = None
self.defenders = {}
self.offenders = {}
# self.cooldowns = {}
self.questions = logic.getQuestions(self.target)
self.question = None
self.registry = Registry()
self.print_queue = Queue()
self.defeated_commands = None
self.defeated_timeout = None
self.reward_person = None
self.reward_timeout = None
self.reward_cmd = None
self.reward_args = None
# self.saved_message = None
self.cmd_request_sent = None
self.police_notify_sent = False
self.stat_cooldown = None
def sendPoliceNotify(self, target):
if not self.police_notify_sent:
msg = (
u"From: %s\nTo: %s\nContent-type: text/plain;charset=utf-8\nSubject: WARNING! Target is under attack\n\nTarget: %s\nAttack time: %s"
% (config.fromEmail, config.policeEmail, target, time.ctime())
)
msg = unicode(msg).encode("utf-8")
s = smtplib.SMTP()
s.connect(config.mailHost, config.mailPort)
res = s.sendmail(config.fromEmail, config.policeEmail, msg)
logging.info("police notify sent %s", res)
self.police_notify_sent = True
# def onExit(self, person):
# self.cooldowns[person] = time.time() + logic.getCooldownOnExit(person, self.target)
# def onEnter(self, conn, person, nickname):
# if self.cooldowns.get(person, 0) > time.time():
# utils.sendKick(conn, self.name, [nickname], u"Отдохни!")
@utils.protect
def onPresence(self, conn, person, nickname, alive):
if alive:
logging.info(u"%s comes to %s", person, self.target)
if not self.registry.onPresence(person, nickname, alive) and self.findPerson(person):
self.findPerson(person).onExit(False)
self.dropPerson(person)
# self.onExit(person)
# else:
# self.onEnter(conn, person, nickname)
def revive(self):
self.health = logic.getSystemVitality(self.target)
[person.revive(logic.getVitality(person.name.getStripped())) for name, person in self.defenders.items()]
self.police_notify_sent = False
self.stat_cooldown = None
def __str__(self):
return u"Conference(target = %s, name = %s, health = %s, defenders = [%s], offenders = [%s])" % (
self.target,
self.name,
self.health,
", ".join("(%s: %s)" % (k, v) for k, v in self.defenders.iteritems()),
", ".join("(%s: %s)" % (k, v) for k, v in self.offenders.iteritems()),
)
def newOffender(self, p):
if p not in self.offenders:
if logic.policeNotifyOnAttack(p):
self.sendPoliceNotify(self.target)
self.offenders[p] = Person(p, cooldown.getVitality(p))
def newDefender(self, p):
if p not in self.defenders:
self.defenders[p] = Person(p, cooldown.getVitality(p))
def idle(self, conn):
while not self.print_queue.empty():
res = self.print_queue.get()
logging.info(u"receive result: %s", unicode(res))
# if timeout <= time.time():
utils.sendConf(conn, self.name, res[:MAX_RESULT])
if self.cmd_request_sent:
utils.sendConf(
conn, self.name, u"Time left: %d sec. Type command." % (int(self.defeated_timeout - time.time()))
)
self.cmd_request_sent = None
# else:
# self.saved_message = (timeout, res)
# if self.defeated_timeout:
# utils.sendConf(conn, self.name, u"Time left: %d sec" % (int(self.defeated_timeout - time.time())))
if self.defeated():
# if self.saved_message and self.saved_message[0] <= time.time():
# utils.sendConf(conn, self.name, self.saved_message[1])
# self.saved_message = None
if not self.defeated_commands:
background.getUrlBackground(
"hack_done.php?",
{"hackers": ",".join(x.getNode() for x in self.offenders.keys()), "target": self.target},
)
rewards, score = logic.getRewardAndScore(self.target, time.time() - self.start_time)
self.defeated_timeout = time.time() + score
self.defeated_commands = rewards
self.reward_person = None
self.reward_timeout = None
self.cmd_request_sent = None
self.kickDefenders(conn)
utils.sendConf(conn, self.name, u"Hacking done. Time left: %d sec. Type command." % (score))
logging.info(u"%s Hacking done. Time left: %d sec. Type command.", self.target, score)
else:
if time.time() > self.defeated_timeout:
utils.sendConf(
conn,
self.name,
u"Hacking finished. Connection terminated.",
lambda sess, s: utils.leaveConf(conn, self.name),
)
logging.info(u"%s Finish", self.target)
return True
if self.reward_timeout and time.time() > self.reward_timeout and not self.cmd_request_sent:
self.cmd_request_sent = True
background.getUrlBackground(
"hack_cmd.php?",
{"target": self.target, "cmd": self.reward_cmd, "args": " ".join(self.reward_args)},
self,
)
if not self.offenders:
self.revive()
self.next_question = None
self.start_time = None
for l in [self.defenders, self.offenders]:
[p.idle(conn, self) for p in l.values()]
self.kickDeads(conn)
if len(self.offenders) == 0 and len(self.defenders) == 0:
return True
if not self.defeated():
currentTime = time.time()
if not self.next_question:
if self.offenders:
self.start_time = currentTime
self.next_question = currentTime + random.randint(1, config.nextQuestionMaxTimeout)
else:
if currentTime > self.next_question:
if self.question and self.offenders:
person = random.choice(self.offenders.values())
person.damage(
conn,
Person(config.nickname, 0),
logic.getSystemDamage(person, self.target, self.question),
self,
)
if logic.policeNotifyOnDamage(person.name):
self.sendPoliceNotify(self.target)
self.question = self.nextQuestion()
logging.info("%s: new question: %s", self.target, self.question.text)
self.next_question = currentTime + self.question.timeout
utils.sendConf(conn, self.name, self.question.text)
return False
def nextQuestion(self):
return random.choice(self.questions)
def defeated(self):
return self.health <= 0
def kickDefenders(self, conn):
for jid, d in self.defenders.iteritems():
d.revive(0)
self.kickDeads(conn)
def kickDeads(self, conn):
toKick = []
for l in [self.offenders, self.defenders]:
toDelete = []
for name, person in [x for x in l.iteritems() if x[1].isDead()]:
toKick.append(self.registry.getNick(person.name))
person.onExit(True)
toDelete.append(name)
if logic.policeNotifyOnKill(name):
self.sendPoliceNotify(self.target)
for x in toDelete:
del l[x]
utils.sendKick(conn, self.name, toKick, u"Terminated!")
def findPerson(self, person):
for l in [self.offenders, self.defenders]:
if person in l:
return l[person]
return None
def dropPerson(self, person):
for l in [self.offenders, self.defenders]:
if person in l:
del l[person]
return
def findRandomDefender(self, person, me):
l = []
exclude = unicode(me.name) if me else ""
for n, v in self.defenders.iteritems():
name = unicode(v.name)
if name[: len(person)] == person and name[: len(exclude)] != exclude:
l.append(v)
return random.choice(l) if len(l) > 0 else None
def findRandomOffender(self, person, me):
l = []
exclude = unicode(me.name) if me else ""
for n, v in self.offenders.iteritems():
name = unicode(v.name)
if name[: len(person)] == person and name[: len(exclude)] != exclude:
l.append(v)
return random.choice(l) if len(l) > 0 else None
def onMessage(self, conn, msg):
res = msg.getFrom().getResource()
if not res:
return
if msg.getType() != "groupchat" or not msg.getBody():
return
person = self.registry[res]
if not self.findPerson(person):
return
logging.info(u"%s message from %s: %s", self.target, person, msg.getBody())
if not self.defeated_commands and self.question and utils.sEq(msg.getBody(), self.question.answer):
if person in self.offenders:
damage = logic.getDamage(person, self.target, self.question)
self.health -= damage
if not self.defeated():
utils.answerConf(conn, msg, u"System damaged: %d, left: %d" % (damage, self.health))
logging.info(u"%s System damaged: %d, left: %d", self.target, damage, self.health)
else:
cooldown.systemBroken(self.target)
else:
return
self.question = None
self.next_question = time.time() + random.randint(1, config.nextQuestionMaxTimeout)
else:
if not msg.getBody():
return
parts = [utils.normalize(x) for x in msg.getBody().strip().split(" ")]
if parts:
if self.defeated_commands and parts[0] in logic.availableRewards():
if parts[0] in self.defeated_commands:
if not self.reward_person:
self.rewardCommand(conn, person, parts[0], parts[1:])
else:
utils.answerConf(
conn,
msg,
u"Command %s is unsupported by target. Time left: %d"
% (parts[0], int(self.defeated_timeout - time.time())),
)
else:
{"stat": self.printStats, "attack": self.scheduleAttack, "defend": self.doDefend}.get(
parts[0], lambda x, y, z: None
)(conn, person, parts[1:])
def printStats(self, conn, person, args):
now = time.time()
if self.stat_cooldown == None or now > self.stat_cooldown:
userlist = []
for d in self.defenders.itervalues():
userlist.append("defender\t%s\t%s" % (d.name, d.health))
for o in self.offenders.itervalues():
userlist.append("offender\t%s\t%s" % (o.name, o.health))
msg = u"Conference info:\ntarget\t%s\nhealth\t%s\n\n%s" % (self.target, self.health, "\n".join(userlist))
utils.sendConf(conn, self.name, unicode(msg))
self.stat_cooldown = now + config.statCommandCooldown
def scheduleAttack(self, conn, person, args):
attackPerson = self.findPerson(person)
if not attackPerson or not attackPerson.canAttack():
return
if len(args) < 2:
return
try:
code, target = args[0], args[1]
if len(code) == config.codeLength and int(code) >= 0:
if person in self.offenders:
targetPerson = self.findRandomDefender(target, attackPerson)
if not targetPerson:
targetPerson = self.findRandomOffender(target, attackPerson)
elif person in self.defenders:
targetPerson = self.findRandomOffender(target, attackPerson)
else:
return
if targetPerson:
targetPerson.scheduleAttack(attackPerson, code, person in self.defenders)
except:
logging.exception("e")
def doDefend(self, conn, person, args):
defenderPerson = self.findPerson(person)
if not defenderPerson:
return
if len(args) < 1:
return
try:
code = args[0]
if len(args) == 2:
target = args[1]
if person in self.offenders:
targetPerson = self.findRandomDefender(target, "")
if not targetPerson:
targetPerson = self.findRandomOffender(target, "")
elif person in self.defenders:
targetPerson = self.findRandomOffender(target, "")
if not targetPerson:
targetPerson = self.findRandomDefender(target, "")
else:
return
else:
targetPerson = defenderPerson
targetPerson.doDefend(code)
except:
logging.exception("e")
def rewardCommand(self, conn, person, cmd, args):
rewardPerson = self.findPerson(person)
if not rewardPerson:
return
self.reward_person = rewardPerson
self.reward_timeout = time.time() + logic.getCommandTime(cmd)
self.reward_cmd = cmd
self.reward_args = args
def backgroundDone(self, res):
res = res.decode("utf-8")
self.print_queue.put((res))
if self.reward_person and time.time() > self.reward_timeout:
self.reward_person = None
self.reward_timeout = None
def __new__(self, name, bases, dict):
for n, skills in filter(lambda d: d[0].startswith("skill_def_"),
dict.items()):
SkillSet.add_skill_def(skills)
del dict[n]
return Registry.__new__(self, name, bases, dict)
class Conf(object):
__slots__ = ["target", "name", "health", "next_question", "defenders", "offenders", "question", "start_time", "registry", "cooldowns",
"questions", "print_queue", "defeated_commands", "reward_person", "reward_timeout", "defeated_timeout", "saved_message"]
def __init__(self, target, name = None):
self.target = target
self.name = name if name else utils.randStr()
self.health = logic.getSystemVitality(self.target)
self.next_question = None
self.start_time = None
self.defenders = {}
self.offenders = {}
# self.cooldowns = {}
self.questions = logic.getQuestions(self.target)
self.question = None
self.registry = Registry()
self.print_queue = Queue()
self.defeated_commands = None
self.defeated_timeout = None
self.reward_person = None
self.reward_timeout = None
self.saved_message = None
# def onExit(self, person):
# self.cooldowns[person] = time.time() + logic.getCooldownOnExit(person, self.target)
# def onEnter(self, conn, person, nickname):
# if self.cooldowns.get(person, 0) > time.time():
# utils.sendKick(conn, self.name, [nickname], u"Отдохни!")
@utils.protect
def onPresence(self, conn, person, nickname, alive):
if not self.registry.onPresence(person, nickname, alive) and self.findPerson(person):
self.findPerson(person).onExit(False)
# self.onExit(person)
# else:
# self.onEnter(conn, person, nickname)
def revive(self):
self.health = logic.getSystemVitality(self.target)
[person.revive(logic.getVitalityDefend(name, self.target)) for name, person in self.defenders.items()]
def __str__(self):
return u"Conference(target = %s, name = %s, health = %s, defenders = [%s], offenders = [%s])" % (self.target, self.name, self.health, ", ".join("(%s: %s)" % (k, v) for k, v in self.defenders.iteritems()), ", ".join("(%s: %s)" % (k, v) for k, v in self.offenders.iteritems()))
def newOffender(self, p):
if p not in self.offenders:
self.offenders[p] = Person(p, cooldown.getVitality(p))
def newDefender(self, p):
if p not in self.defenders:
self.defenders[p] = Person(p, cooldown.getVitality(p))
def idle(self, conn):
while not self.print_queue.empty():
res, timeout = self.print_queue.get()
print u"receive result: %s" % (res)
if timeout <= time.time():
utils.sendConf(conn, self.name, res)
else:
self.saved_message = (timeout, res)
# if self.defeated_timeout:
# utils.sendConf(conn, self.name, u"Time left: %d sec" % (int(self.defeated_timeout - time.time())))
if self.defeated():
if self.saved_message and self.saved_message[0] <= time.time():
utils.sendConf(conn, self.name, self.saved_message[1])
self.saved_message = None
if not self.defeated_commands:
background.getUrlBackground("hack_done.php?", {"hackers": ",".join(x.getNode() for x in self.offenders.keys()), "target": self.target})
rewards, score = logic.getRewardAndScore(self.target, time.time() - self.start_time)
self.defeated_timeout = time.time() + score
self.defeated_commands = rewards
print rewards
self.reward_person = None
self.reward_timeout = None
self.kickDefenders(conn)
utils.sendConf(conn, self.name, u"Hacking done. Time left: %d sec. Type command." % (score))
else:
if time.time() > self.defeated_timeout:
utils.sendConf(conn, self.name, u"Hacking finished. Connection terminated.", lambda sess, s: utils.leaveConf(conn, self.name))
return True
if self.reward_timeout and time.time() > self.reward_timeout:
self.reward_person = None
self.reward_timeout = None
self.saved_message = None
utils.sendConf(conn, self.name, u"Time left: %d sec. Type command." % (int(self.defeated_timeout - time.time())))
return False
if not self.offenders:
self.revive()
self.next_question = None
self.start_time = None
for l in [self.defenders, self.offenders]:
[p.idle(conn, self) for p in l.values()]
self.kickDeads(conn)
currentTime = time.time()
if not self.next_question:
if self.offenders:
self.start_time = currentTime
self.next_question = currentTime + random.randint(1, config.nextQuestionMaxTimeout)
else:
if currentTime > self.next_question:
if self.question and self.offenders:
person = random.choice(self.offenders.values())
person.damage(conn, Person(config.nickname, 0), config.systemAttack, self)
self.question = self.nextQuestion()
self.next_question = currentTime + self.question.timeout
utils.sendConf(conn, self.name, self.question.text)
return False
def nextQuestion(self):
return random.choice(self.questions)
def defeated(self):
return self.health <= 0
def kickDefenders(self, conn):
for jid, d in self.defenders.iteritems():
d.revive(0)
self.kickDeads(conn)
def kickDeads(self, conn):
toKick = []
for l in [self.offenders, self.defenders]:
toDelete = []
for name, person in [x for x in l.iteritems() if x[1].isDead()]:
toKick.append(self.registry.getNick(person.name))
person.onExit(True)
toDelete.append(name)
for x in toDelete:
del l[x]
utils.sendKick(conn, self.name, toKick, u"Terminated!")
def findPerson(self, person):
for l in [self.offenders, self.defenders]:
if person in l:
return l[person]
return None
def findRandomDefender(self, person, me):
l = []
exclude = unicode(me.name)
for n,v in self.defenders.iteritems():
name = unicode(v.name)
if name[:len(person)] == person and name[:len(exclude)] != exclude:
l.append(v)
return random.choice(l) if len(l) > 0 else None
def findRandomOffender(self, person, me):
l = []
exclude = unicode(me.name)
for n,v in self.offenders.iteritems():
name = unicode(v.name)
if name[:len(person)] == person and name[:len(exclude)] != exclude:
l.append(v)
return random.choice(l) if len(l) > 0 else None
def onMessage(self, conn, msg):
person = self.registry[msg.getFrom().getResource()]
if not self.findPerson(person):
return
print u"message from %s: %s" % (person, msg.getBody())
if not self.defeated_commands and self.question and utils.sEq(msg.getBody(), self.question.answer):
if person in self.offenders:
damage = logic.getDamage(person, self.target)
self.health -= damage
if not self.defeated():
utils.answerConf(conn, msg, u"System damaged: %d, left: %d" % (damage, self.health))
else:
return
self.question = None
self.next_question = time.time() + random.randint(1, config.nextQuestionMaxTimeout)
else:
if not msg.getBody(): return
parts = [utils.normalize(x) for x in msg.getBody().strip().split(" ")]
if parts:
if self.defeated_commands and parts[0] in logic.availableRewards():
if parts[0] in self.defeated_commands:
print u"reward command: %s" % (parts[0])
if not self.reward_person:
self.rewardCommand(conn, person, parts[0], parts[1:])
else:
utils.answerConf(conn, msg, u"Command %s is unsupported by target. Time left: %d" % (parts[0], int(self.defeated_timeout - time.time())))
else:
{"stat": self.printStats, "attack": self.scheduleAttack, "defend": self.doDefend}.get(parts[0], lambda x, y, z: None)(conn, person, parts[1:])
def printStats(self, conn, person, args):
utils.sendConf(conn, self.name, unicode(self))
def scheduleAttack(self, conn, person, args):
attackPerson = self.findPerson(person)
print u"person %s attacks %s can attack %s" % (attackPerson, args, attackPerson.canAttack())
if not attackPerson or not attackPerson.canAttack():
return
try:
code, target = args[0], args[1]
if len(code) == config.codeLength and int(code) >= 0:
if person in self.offenders:
targetPerson = self.findRandomDefender(target, attackPerson)
if not targetPerson:
targetPerson = self.findRandomOffender(target, attackPerson)
elif person in self.defenders:
targetPerson = self.findRandomOffender(target, attackPerson)
else:
return
if targetPerson:
targetPerson.scheduleAttack(attackPerson, code, person in self.defenders)
except:
print traceback.format_exc()
def doDefend(self, conn, person, args):
defenderPerson = self.findPerson(person)
if not defenderPerson:
return
try:
code = args[0]
if len(args) == 2:
targetPerson = self.findPerson(self.registry[args[1]])
else:
targetPerson = defenderPerson
targetPerson.doDefend(code)
except:
print traceback.format_exc()
def rewardCommand(self, conn, person, cmd, args):
rewardPerson = self.findPerson(person)
print u"reward command %s for %s" % (cmd, self)
if not rewardPerson:
return
self.reward_person = rewardPerson
self.reward_timeout = time.time() + logic.getCommandTime(cmd)
print u"timeout %s" % (logic.getCommandTime(cmd))
background.getUrlBackground("hack_cmd.php?", {"target": self.target, "cmd": cmd, "args": " ".join(args)}, self, self.reward_timeout)
def backgroundDone(self, res, timeout):
res = res.decode('utf-8')
print u"background done: %s timeout %s" % (res, timeout)
self.print_queue.put((res,timeout))
def test_all_names(self):
registry = Registry()
registry.register('a', 1)
registry.register('b', 5)
registry.add_alias('c', 'b')
self.assertEqual(['a', 'b'], sorted(registry.get_all_names()))
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_unknown_entry(self):
registry = Registry()
with self.assertRaises(NoSuchMachineException):
registry.get('b')
class Conf(object):
__slots__ = ["target", "name", "health", "next_question", "defenders", "offenders", "question", "start_time", "registry", "cooldowns", "questions"]
def __init__(self, target, name = None):
self.target = target
self.name = name if name else utils.randStr()
self.health = logic.getSystemVitality(self.target)
self.next_question = time.time() + 5
self.start_time = self.next_question
self.defenders = {}
self.offenders = {}
self.cooldowns = {}
self.questions = logic.getQuestions(self.target)
self.question = None
self.registry = Registry()
# def onExit(self, person):
# self.cooldowns[person] = time.time() + logic.getCooldownOnExit(person, self.target)
# def onEnter(self, conn, person, nickname):
# if self.cooldowns.get(person, 0) > time.time():
# utils.sendKick(conn, self.name, [nickname], u"Отдохни!")
@utils.protect
def onPresence(self, conn, person, nickname, alive):
if not self.registry.onPresence(person, nickname, alive) and self.findPerson(person):
self.findPerson(person).onExit(False)
# self.onExit(person)
# else:
# self.onEnter(conn, person, nickname)
def revive(self):
self.health = logic.getSystemVitality(self.target)
[person.revive(logic.getVitalityDefend(name, self.target)) for name, person in self.defenders.items()]
def __str__(self):
return unicode(u"Conference(target = %s, name = %s, health = %s, defenders = [%s], offenders = [%s]" % (self.target, self.name, self.health, ", ".join("(%s: %s)" % (k, v) for k, v in self.defenders.iteritems()), ", ".join("(%s: %s)" % (k, v) for k, v in self.offenders.iteritems()))).encode("utf-8")
def newOffender(self, p):
if p not in self.offenders:
self.offenders[p] = Person(p, logic.getVitalityOffend(p, self.target))
def newDefender(self, p):
if p not in self.defenders:
self.defenders[p] = Person(p, logic.getVitalityDefend(p, self.target))
def idle(self, conn):
if self.allDone():
msg = u"Конец!"
if self.defeated():
msg = logic.getReward(self.target, time.time() - self.start_time)
background.getUrlBackground("hack_done.php?", {"hackers": ",".join(x.getNode() for x in self.offenders.keys()), "target": self.target})
utils.sendConf(conn, self.name, msg, lambda sess, s: utils.leaveConf(conn, self.name))
return True
if not self.offenders:
self.revive()
for l in [self.defenders, self.offenders]:
[p.idle(conn, self.name) for p in l.values()]
self.kickDeads(conn)
currentTime = time.time()
if currentTime > self.next_question:
self.question = self.nextQuestion()
self.next_question = currentTime + self.question.timeout
#utils.sendConf(conn, self.name, u"%s (время: %d)" % (self.question.text, self.question.timeout))
utils.sendConf(conn, self.name, self.question.text)
return False
def nextQuestion(self):
return random.choice(self.questions)
def allDone(self):
return self.defeated()
def defeated(self):
return self.health <= 0
def kickDeads(self, conn):
toKick = []
for l in [self.offenders, self.defenders]:
toDelete = []
for name, person in [x for x in l.iteritems() if x[1].isDead()]:
toKick.append(self.registry.getNick(person.name))
person.onExit(True)
toDelete.append(name)
for x in toDelete:
del l[x]
utils.sendKick(conn, self.name, toKick, u"Готов")
def findPerson(self, person):
for l in [self.offenders, self.defenders]:
if person in l:
return l[person]
return None
def onMessage(self, conn, msg):
person = self.registry[msg.getFrom().getResource()]
if not self.findPerson(person):
return
if self.question and utils.sEq(msg.getBody(), self.question.answer):
if person in self.offenders:
damage = logic.getDamage(person, self.target)
self.health -= damage
if not self.defeated():
utils.answerConf(conn, msg, u"Нанесено урона: %d, осталось: %d" % (damage, self.health))
elif person in self.defenders:
for p in self.offenders.itervalues():
p.damage(conn, self.findPerson(person), logic.getDefenderDamage(person, self.target), self.name)
else:
return
self.kickDeads(conn)
self.question = None
self.next_question = time.time() + 1
else:
parts = [utils.normalize(x) for x in msg.getBody().strip().split(" ")]
if parts:
{"stat": self.printStats, "attack": self.scheduleAttack, "defend": self.doDefend}.get(parts[0], lambda x, y, z: None)(conn, person, parts[1:])
def printStats(self, conn, person, args):
utils.sendConf(conn, self.name, str(self))
def scheduleAttack(self, conn, person, args):
attackPerson = self.findPerson(person)
if not attackPerson or not attackPerson.canAttack():
return
try:
code, target = args[0], args[1]
if len(code) == 4 and int(code) >= 0:
targetPerson = self.findPerson(self.registry[target])
if targetPerson:
targetPerson.scheduleAttack(attackPerson, code, person in self.defenders)
except:
print traceback.format_exc()
def doDefend(self, conn, person, args):
defenderPerson = self.findPerson(person)
if not defenderPerson:
return
try:
code = args[0]
if len(args) == 2:
targetPerson = self.findPerson(self.registry[args[1]])
else:
targetPerson = defenderPerson
targetPerson.doDefend(code)
except:
print traceback.format_exc()
def register(model_cls, config_cls=None, filter_by_parent=False):
from registry import Registry
Registry.register(model_cls, config_cls, filter_by_parent)
def register(model_cls, config_cls=None):
from registry import Registry
Registry.register(model_cls, config_cls)
<br/>
Width: <input type="text" name="width" value="${data.get('width', '')}"/><br/>
Heigth: <input type="text" name="height" value="${data.get('height', '')}"/>
<input type="submit" value="Save"/>
<input type="button" name="cancel" value="Cancel"/>
</form>
<iframe name="img_save" id="img_save" style="display: none"></iframe>
"""
class ImageBlock(Block):
add_form = edit_form = FORM
def __init__(self, block_id, **props):
Block.__init__(self, block_id, **props)
self.type = "image"
class ImageBlockView(BlockView):
@property
def img_url(self):
return self.context.get('img_url', '')
Registry.register_type("image", ImageBlock)
def unregister(model_cls):
from registry import Registry
Registry.unregister(model_cls)
def test_lookup(self):
registry = Registry()
registry.register('a', 1)
self.assertEqual(1, registry.get('a'))
