code stringlengths 281 23.7M |
|---|
def dedent(text, baseline_index=None, indent=None):
if (not text):
return ''
if (indent is not None):
lines = text.split('\n')
ind = (' ' * indent)
indline = ('\n' + ind)
return (ind + indline.join((line.strip() for line in lines)))
elif (baseline_index is None):
return textwrap.dedent(text)
else:
lines = text.split('\n')
baseline = lines[baseline_index]
spaceremove = (len(baseline) - len(baseline.lstrip(' ')))
return '\n'.join((line[min(spaceremove, (len(line) - len(line.lstrip(' ')))):] for line in lines)) |
class SimpleModelSemanticExtractor(ModelSemanticExtractor):
def __init__(self, semantic_content_class_by_tag: Optional[Mapping[(str, SemanticContentFactoryProtocol)]]=None):
super().__init__()
self.semantic_content_class_by_tag = (semantic_content_class_by_tag or {})
def get_semantic_content_for_entity_name(self, name: str, layout_block: LayoutBlock) -> SemanticContentWrapper:
semantic_content_class = self.semantic_content_class_by_tag.get(name)
if semantic_content_class:
return semantic_content_class(layout_block=layout_block)
return SemanticNote(layout_block=layout_block, note_type=name) |
class HtmlNavBar(Html.Html):
name = 'Nav Bar'
def __init__(self, page: primitives.PageModel, components: Optional[List[Html.Html]], width: tuple, height: tuple, options: Optional[dict], html_code: str, profile: Optional[Union[(dict, bool)]]):
super(HtmlNavBar, self).__init__(page, [], html_code=html_code, css_attrs={'width': width, 'height': height}, profile=profile, options=options)
(self.scroll, self.background) = (None, True)
if (components is not None):
if (not isinstance(components, list)):
components = [components]
for c in components:
self.__add__(c)
self.buttons = []
self.avatar = None
def style(self) -> GrpClsMenu.ClassNav:
if (self._styleObj is None):
self._styleObj = GrpClsMenu.ClassNav(self)
return self._styleObj
def move(self):
super(HtmlNavBar, self).move()
self.style.css.position = None
self.page.body.style.css.padding_top = 0
return self
def __add__(self, component: Html.Html):
if (not hasattr(component, 'options')):
component = self.page.ui.div(component)
component.style.add_classes.div.color_hover()
component.style.css.user_select = 'none'
component.style.css.margin_left = 5
component.style.css.margin_right = 5
component.style.css.cursor = 'pointer'
component.options.managed = False
component.style.css.display = 'inline'
if (component.css('height') is None):
component.style.css.vertical_align = 'middle'
if (component.css('width') == '100%'):
component.style.css.width = None
self.val.append(component)
if hasattr(self, 'buttons'):
self.buttons.append(component)
return self
def no_background(self, to_top: bool=True):
self.background = False
self.style.css.background_color = '#11ffee00'
self.style.css.border_bottom = None
if to_top:
self.page.body.style.css.padding_top = 0
return self
def set_theme(self):
self.style.css.background_color = self.page.theme.colors[0]
self.style.css.border_bottom = ('1px solid %s' % self.page.theme.greys[0])
return self
def add_right(self, component: Html.Html, css: Optional[dict]=None, prepend: bool=False, with_css_cls: bool=True) -> Html.Html:
if (not hasattr(component, 'options')):
component = self.page.ui.text(component, width=('auto', ''))
component.style.css.margin_left = 5
component.style.css.user_select = 'none'
component.style.css.margin_right = 5
component.style.css.cursor = 'pointer'
component.options.managed = False
if (css is not None):
component.css(css)
if with_css_cls:
component.style.add_classes.div.color_hover()
component.style.css.color = self.page.theme.greys[self.page.theme.index]
if (not hasattr(self, '_right')):
self._right = self.page.ui.div(width=('auto', ''), height=(100, '%'))
self._right.style.css.display = 'inline-block'
self._right.style.css.float = 'right'
self._right.style.css.text_transform = 'uppercase'
self._right.style.css.font_weight = 'bold'
self._right.style.css.font_factor(0)
self._right.style.css.display = 'flex'
self._right.style.css.align_items = 'center'
self._right.options.managed = False
self._vals.append(self._right)
if prepend:
self._right.insert(0, component)
else:
self._right.add(component)
self.buttons.append(component)
return component
def add_text(self, text: Union[(Html.Html, str)]) -> Html.Html:
if (not hasattr(text, 'options')):
text = self.page.ui.text(text)
text.style.css.height = '100%'
text.style.css.vertical_align = 'middle'
self.__add__(text)
return text
def __str__(self):
if (self.avatar is not None):
self.add_right(self.avatar, with_css_cls=False)
if (self.scroll is not None):
self.val.append(self.scroll)
if (self.scroll.css('width') == '100%'):
self.scroll.style.css.width = None
str_h = ''.join([h.html() for h in self.val])
if (self.style.css.position != 'fixed'):
self.page.body.style.css.padding_top = 0
return ('<div %s>%s</div>' % (self.get_attrs(css_class_names=self.style.get_classes()), str_h)) |
class geneve(packet_base.PacketBase):
_HEADER_FMT = '!BBHI'
_MIN_LEN = struct.calcsize(_HEADER_FMT)
OAM_PACKET_FLAG = (1 << 7)
CRITICAL_OPTIONS_FLAG = (1 << 6)
def __init__(self, version=0, opt_len=0, flags=0, protocol=ether_types.ETH_TYPE_TEB, vni=None, options=None):
super(geneve, self).__init__()
self.version = version
self.opt_len = opt_len
assert ((flags & 63) == 0)
self.flags = flags
self.protocol = protocol
self.vni = vni
for o in options:
assert isinstance(o, Option)
self.options = options
def parser(cls, buf):
(ver_opt_len, flags, protocol, vni) = struct.unpack_from(cls._HEADER_FMT, buf)
version = (ver_opt_len >> 6)
opt_len = ((ver_opt_len & 63) * 4)
opt_bin = buf[cls._MIN_LEN:(cls._MIN_LEN + opt_len)]
options = []
while opt_bin:
(option, opt_bin) = Option.parser(opt_bin)
options.append(option)
msg = cls(version, opt_len, flags, protocol, (vni >> 8), options)
from . import ethernet
geneve._TYPES = ethernet.ethernet._TYPES
geneve.register_packet_type(ethernet.ethernet, ether_types.ETH_TYPE_TEB)
return (msg, geneve.get_packet_type(protocol), buf[(cls._MIN_LEN + opt_len):])
def serialize(self, payload=None, prev=None):
tunnel_options = bytearray()
for o in self.options:
tunnel_options += o.serialize()
self.opt_len = len(tunnel_options)
opt_len = (self.opt_len // 4)
return (struct.pack(self._HEADER_FMT, ((self.version << 6) | opt_len), self.flags, self.protocol, (self.vni << 8)) + tunnel_options) |
.unit
def test_transform_redshift_systems(redshift_describe_clusters: Generator, redshift_systems: Generator) -> None:
actual_result = aws_connector.create_redshift_systems(describe_clusters=redshift_describe_clusters, organization_key='default_organization')
assert (actual_result == redshift_systems) |
def main():
try:
base_conf(project='ryu', version=('ryu %s' % version))
except cfg.RequiredOptError as e:
base_conf.print_help()
raise SystemExit(1)
subcmd_name = base_conf.subcommand
try:
subcmd_mod_name = subcommands[subcmd_name]
except KeyError:
base_conf.print_help()
raise SystemExit(('Unknown subcommand %s' % subcmd_name))
subcmd_mod = utils.import_module(subcmd_mod_name)
subcmd = SubCommand(name=subcmd_name, entry=subcmd_mod.main)
subcmd.run(base_conf.subcommand_args) |
class OptionPlotoptionsStreamgraphSonificationDefaultinstrumentoptionsMappingFrequency(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
_func
def get_message(query: fixieai.Message) -> str:
if (not query.embeds):
return 'You need to specify the embed ID of the message you want to read.'
for embed in query.embeds.values():
if (embed.content_type != 'text/plain'):
return f'I can only read plain-text emails specified by #{EMBED_NAME}.'
embed_texts = [embed.text for embed in query.embeds.values()]
return '\n\n'.join(embed_texts) |
def test_MeshAdaptRestart_adaptiveTime_BackwardEuler_baseline(verbose=0):
currentPath = os.path.dirname(os.path.abspath(__file__))
runCommand = (('cd ' + currentPath) + '; parun -C "gen_mesh=False usePUMI=True adapt=0 fixedTimeStep=False" -D "baseline" dambreak_Colagrossi_so.py;')
subprocess.check_call(runCommand, shell=True)
assert True |
def extract_config(t: Type[TensorFlow2ONNX]) -> Tuple[(Type[TensorFlow2ONNX], TensorFlow2ONNXConfig)]:
config = None
if (get_origin(t) is Annotated):
(base_type, config) = get_args(t)
if isinstance(config, TensorFlow2ONNXConfig):
return (base_type, config)
else:
raise TypeTransformerFailedError(f"{t}'s config isn't of type TensorFlow2ONNX")
return (t, config) |
def rolling_median_by_h(x, h, w, name):
df = pd.DataFrame({'x': x, 'h': h})
grouped = df.groupby('h')
df2 = grouped.size().reset_index().sort_values('h')
hs = df2['h']
res_h = []
res_x = []
i = (len(hs) - 1)
while (i >= 0):
h_i = hs[i]
xs = grouped.get_group(h_i).x.tolist()
next_idx_to_add = (np.array((h == h_i)).argmax() - 1)
while ((len(xs) < w) and (next_idx_to_add >= 0)):
xs.append(x[next_idx_to_add])
next_idx_to_add -= 1
if (len(xs) < w):
break
res_h.append(hs[i])
res_x.append(np.median(xs))
i -= 1
res_h.reverse()
res_x.reverse()
return pd.DataFrame({'horizon': res_h, name: res_x}) |
def extractAsadatranslationsWordpressCom(item):
(vol, chp, frag, postfix) = extractVolChapterFragmentPostfix(item['title'])
if ((not (chp or vol)) or ('preview' in item['title'].lower())):
return None
tagmap = [('npc town building game', 'NPC Town-building Game', 'translated'), ('reader', 'reader', 'translated'), ('horror game escape guide', 'horror game escape guide', 'translated'), ('study magic in my free time', 'Study Magic In My Free Time', 'translated'), ('delta in the darkness', 'delta in the darkness', 'translated'), ('i am a summoning master', 'I am a Summoning Master', 'translated'), ('the villain happy being a father', 'The Villain is Happy being a Father', 'translated'), ('graduated from witchcraft institute', 'graduated from witchcraft institute', 'translated'), ("the prince's battle to concede the throne", "the prince's battle to concede the throne", 'translated'), ('PRC', 'PRC', 'translated'), ('Loiterous', 'Loiterous', 'oel')]
for (tagname, name, tl_type) in tagmap:
if (tagname in item['tags']):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
if (item['tags'] == ['Announcements']):
titlemap = [('[ISM] Chapter ', 'I am a Summoning Master', 'translated'), ('[VHBF] Chapter ', 'The Villain is Happy being a Father', 'translated'), ('[Reader] Chapter ', 'Reader', 'translated'), ('Tensei Shoujo no Rirekisho', 'Tensei Shoujo no Rirekisho', 'translated'), ('[HGEG] Chapter ', 'Horror Game Escape Guide', 'translated'), ("The Worst Princes' Battle Over Giving Up the Imperial Throne Chapter ", "the prince's battle to concede the throne", 'translated'), ('Master of Dungeon', 'Master of Dungeon', 'oel')]
for (titlecomponent, name, tl_type) in titlemap:
if (titlecomponent.lower() in item['title'].lower()):
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False |
class VmMigrateSerializer(s.Serializer):
node = s.SlugRelatedField(slug_field='hostname', queryset=Node.objects, required=False)
root_zpool = s.CharField(max_length=64, required=False)
disk_zpools = DiskPoolDictField(required=False)
live = s.BooleanField(default=False)
def __init__(self, request, vm, *args, **kwargs):
self.img_required = None
self.request = request
self.vm = vm
super(VmMigrateSerializer, self).__init__(*args, **kwargs)
self.fields['node'].queryset = get_nodes(request, is_compute=True)
self._disks = vm.json_active_get_disks()
self._live = False
if vm.is_hvm():
self.fields['disk_zpools'].max_items = len(self._disks)
else:
del self.fields['disk_zpools']
def validate_disk_zpools(self, attrs, source):
disk_zpools = attrs.get(source, None)
if disk_zpools:
if (max(disk_zpools.keys()) > len(self._disks)):
raise s.ValidationError(_('Invalid disk_id.'))
return attrs
def validate_node(self, attrs, source):
node = attrs.get(source, None)
if (not node):
attrs.pop(source, None)
return attrs
vm = self.vm
if (node == vm.node):
raise s.ValidationError(_('Target node is the same as current node.'))
if (node.status != Node.ONLINE):
raise s.ValidationError(_('Target node is not in online state.'))
try:
validate_nic_tags(vm, new_node=node)
except s.ValidationError:
raise s.ValidationError(_('Some networks are not available on target node.'))
return attrs
def validate_live(self, attrs, source):
value = attrs.get(source, None)
if value:
self._live = True
if (not self.vm.is_kvm()):
raise s.ValidationError(_('Live migration is currently available only for KVM.'))
return attrs
def validate(self, attrs):
vm = self.vm
node = attrs.get('node', vm.node)
changing_node = (attrs.get('node', vm.node) != vm.node)
if self._live:
if (not changing_node):
self._errors['live'] = s.ErrorList([_('Live migration cannot be performed locally.')])
return attrs
if ((node.platform_version_short < MIN_PLATFORM_VERSION_LIVE_MIGRATION) or (vm.node.platform_version_short < MIN_PLATFORM_VERSION_LIVE_MIGRATION)):
self._errors['live'] = s.ErrorList([_('Source and/or target node platform does not support live migration.')])
return attrs
ghost_vm = SlaveVm(_master_vm=vm)
ghost_vm.reserve_resources = changing_node
ghost_vm.set_migration_hostname()
ghost_vm.node = node
ghost_vm_define = SlaveVmDefine(ghost_vm)
root_zpool = attrs.get('root_zpool', None)
try:
root_zpool = ghost_vm_define.save_root_zpool(root_zpool, save_same_zpool=changing_node)
except APIValidationError as exc:
self._errors['node'] = exc.api_errors
return attrs
if ghost_vm.vm.is_hvm():
disk_zpools = attrs.get('disk_zpools', {})
try:
disk_zpools = ghost_vm_define.save_disk_zpools(disk_zpools, save_same_zpool=changing_node)
except APIValidationError as exc:
self._errors['node'] = exc.api_errors
return attrs
else:
disk_zpools = {}
if ((not changing_node) and (not (root_zpool or disk_zpools))):
raise s.ValidationError(_('Nothing to do.'))
try:
ghost_vm_define.validate_node_resources(ignore_cpu_ram=(not changing_node))
except APIValidationError as exc:
self._errors['node'] = exc.api_errors
return attrs
try:
ghost_vm_define.validate_storage_resources()
except APIValidationError as exc:
self._errors['node'] = exc.api_errors
return attrs
self.img_required = ghost_vm_define.check_required_images()
self._root_zpool = root_zpool
self._disk_zpools = disk_zpools
self.ghost_vm_define = ghost_vm_define
self.changing_node = changing_node
return attrs
def save_ghost_vm(self):
self.ghost_vm_define.save()
return self.ghost_vm_define.slave_vm
def node_image_import(self):
if self.img_required:
(ns, img) = self.img_required
return NodeImageView.import_for_vm(self.request, ns, img, self.vm)
return None
def esmigrate_cmd(self):
vm = self.vm
get_json = ('vmadm get %s 2>/dev/null' % vm.uuid)
params = []
if self.changing_node:
node = self.object['node']
params.append(('-H %s' % node.address))
ssh = 'ssh -o ConnectTimeout=10 -o BatchMode=yes -o StrictHostKeyChecking=no -o GSSAPIAuthentication=no -o LogLevel=QUIET -l root'
get_json = ('%s %s "%s"' % (ssh, node.address, get_json))
if vm.is_hvm():
params.append(('-C %s' % self.ghost_vm_define.vm.vnc_port))
if self._live:
params.append('-L')
if self._root_zpool:
params.append(('-p %s' % self._root_zpool))
if self._disk_zpools:
for (n, zpool) in self._disk_zpools.items():
n -= 1
params.append(('-%s %s' % (n, zpool)))
return (('esmigrate migrate %s %s >&2; ' % (vm.uuid, ' '.join(params))) + get_json)
def detail_dict(self, **kwargs):
dd = {'live': self._live}
if self.changing_node:
dd['node'] = self.object['node'].hostname
if self._root_zpool:
dd['root_zpool'] = self._root_zpool
if self._disk_zpools:
dd['disk_zpools'] = self._disk_zpools
return dd |
def test_validation_custom_types():
def complex_args(rate: StrictFloat, steps: PositiveInt=10, log_level: constr(regex='(DEBUG|INFO|WARNING|ERROR)')='ERROR'):
return None
my_registry.complex = catalogue.create(my_registry.namespace, 'complex', entry_points=False)
my_registry.complex('complex.v1')(complex_args)
cfg = {'': 'complex.v1', 'rate': 1.0, 'steps': 20, 'log_level': 'INFO'}
my_registry.resolve({'config': cfg})
cfg = {'': 'complex.v1', 'rate': 1.0, 'steps': (- 1), 'log_level': 'INFO'}
with pytest.raises(ConfigValidationError):
my_registry.resolve({'config': cfg})
cfg = {'': 'complex.v1', 'rate': 1.0, 'steps': 20, 'log_level': 'none'}
with pytest.raises(ConfigValidationError):
my_registry.resolve({'config': cfg})
cfg = {'': 'complex.v1', 'rate': 1.0, 'steps': 20, 'log_level': 'INFO'}
with pytest.raises(ConfigValidationError):
my_registry.resolve(cfg)
with pytest.raises(ConfigValidationError):
my_registry.fill(cfg)
cfg = {'': 'complex.v1', 'rate': 1.0, '': 'catsie.v1'}
with pytest.raises(ConfigValidationError):
my_registry.resolve({'config': cfg}) |
class BarcodeMatcher():
def __init__(self, barcode):
self.__barcode = barcode
def barcode(self):
return self.__barcode
def match(self, test_barcode, max_mismatches=0):
if test_barcode.startswith(self.__barcode):
return True
nmismatches = 0
try:
for i in range(len(self.__barcode)):
if (test_barcode[i] != self.__barcode[i]):
nmismatches += 1
if (nmismatches > max_mismatches):
return False
except IndexError:
return False
return True |
class ServicePlanFixtureTestTracebackEntry(TracebackEntry):
def __init__(self, name, line_number, path, local_variables, fixture_source, test_source, raw_entry):
super(ServicePlanFixtureTestTracebackEntry, self).__init__(raw_entry)
self._name = name
self.lineno = (line_number - 1)
self._path = path
self._locals = local_variables
self._fixture_source = Source(fixture_source)
self._test_source = test_source
self._frame = mock.Mock(spec=object)
self._frame.statement = self.statement
self._frame.getargs = (lambda *_, **__: list(six.iteritems(local_variables)))
self._frame.f_locals = local_variables
self._frame.code = mock.Mock(spec=object)
self._frame.code.path = path
self._frame.code.raw = mock.Mock(spec=object)
self._frame.code.raw.co_filename = str(path)
def frame(self):
return self._frame
def relline(self):
return (self.lineno - self.getfirstlinesource())
def statement(self):
return self._fixture_source[self.lineno]
def path(self):
return self._path
def getlocals(self):
return self._locals
locals = property(getlocals, None, None, str('locals of underlying frame'))
def getfirstlinesource(self):
return max((self.lineno - 3), 0)
def getsource(self, astcache=None):
start = self.getfirstlinesource()
end = ((start + len(self._test_source)) + 5)
return self._fixture_source[start:end]
source = property(getsource, None, None, str('source code of failing test'))
def ishidden(self):
return False
def getname(self):
return self._name
name = property(getname, None, None, str('name of underlaying code'))
def __str__(self):
return ' File {path} line {line_number} (approximate) in {test}\n {source}\n'.format(path=self.path, line_number=(self.lineno + 1), test=self.name, source=self._test_source)
def __repr__(self):
return '<TracebackEntry {}:{}>'.format(self.path, (self.lineno + 1)) |
def parse_members(filepath: str) -> Set[str]:
with open(filepath, 'r') as filehandle:
filecontent = filehandle.read()
members = set()
for node in ast.parse(filecontent).body:
if (isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom)):
members.update(((alias.asname or alias.name) for alias in node.names))
elif isinstance(node, ast.FunctionDef):
members.update([node.name])
return members |
class Heartbeat(object):
def __init__(self, interval, send_heartbeat, timer=threading.Timer):
self.send_heartbeat = send_heartbeat
self.timer_impl = timer
self._lock = threading.Lock()
self._running = threading.Event()
self._timer = None
self._exceptions = None
self._reads_since_check = 0
self._writes_since_check = 0
self._interval = interval
self._threshold = 0
def register_read(self):
self._reads_since_check += 1
def register_write(self):
self._writes_since_check += 1
def start(self, exceptions):
if (not self._interval):
return False
self._running.set()
with self._lock:
self._threshold = 0
self._reads_since_check = 0
self._writes_since_check = 0
self._exceptions = exceptions
LOGGER.debug('Heartbeat Checker Started')
return self._start_new_timer()
def stop(self):
self._running.clear()
with self._lock:
if self._timer:
self._timer.cancel()
self._timer = None
def _check_for_life_signs(self):
if (not self._running.is_set()):
return False
if (self._writes_since_check == 0):
self.send_heartbeat()
self._lock.acquire()
try:
if (self._reads_since_check == 0):
self._threshold += 1
if (self._threshold >= 2):
self._running.clear()
self._raise_or_append_exception()
return False
else:
self._threshold = 0
finally:
self._reads_since_check = 0
self._writes_since_check = 0
self._lock.release()
return self._start_new_timer()
def _raise_or_append_exception(self):
message = ('Connection dead, no heartbeat or data received in >= %ds' % (self._interval * 2))
why = AMQPConnectionError(message)
if (self._exceptions is None):
raise why
self._exceptions.append(why)
def _start_new_timer(self):
if (not self._running.is_set()):
return False
self._timer = self.timer_impl(interval=self._interval, function=self._check_for_life_signs)
self._timer.daemon = True
self._timer.start()
return True |
def test_parse_latlng() -> None:
bad = ['', 'aaa', '12', '1,2,3', '48,', '48,x', '4 8,8', '91,8', '-91,8', '48,-181', '48,181']
for s in bad:
with pytest.raises(ValueError):
staticmaps.parse_latlng(s)
good = ['48,8', ' 48 , 8 ', '-48,8', '+48,8', '48,-8', '48,+8', '48.123,8.456']
for s in good:
c = staticmaps.parse_latlng(s)
assert c.is_valid() |
def bitread2bits(txt):
bits_ref = set()
for l in txt.split('\n'):
l = l.strip()
if (not l):
continue
m = re.match('bit_(.{8})_(.{3})_(.{2})', l)
addr = int(m.group(1), 16)
word = int(m.group(2), 10)
bit = int(m.group(3), 10)
bits_ref.add((addr, word, bit))
return bits_ref |
class Flow_Add_6(base_tests.SimpleProtocol):
def runTest(self):
logging.info('Flow_Add_6 TEST BEGIN')
logging.info('Deleting all flows from switch')
delete_all_flows(self.controller)
sw = Switch()
self.assertTrue(sw.connect(self.controller), 'Failed to connect to switch')
num_flows = 0
for ts in sw.tbl_stats.entries:
num_flows = (num_flows + ts.max_entries)
logging.info(('Switch capacity is %d flows' % num_flows))
logging.info(('Generating %d flows' % num_flows))
fi = Flow_Info()
fi.rand(max((2 * int(math.log(num_flows))), 1))
ft = Flow_Tbl()
ft.rand(required_wildcards(self), sw, fi, num_flows)
logging.info('Sending flow adds to switch')
for fc in ft.values():
logging.info('Adding flow:')
logging.info(str(fc))
self.assertTrue(sw.flow_add(fc), 'Failed to add flow')
self.assertTrue(sw.barrier(), 'Barrier failed')
result = True
sw.settle()
if (not sw.errors_verify(0)):
result = False
logging.info('Creating one more flow')
while True:
fc = Flow_Cfg()
fc.rand(fi, required_wildcards(self), sw.tbl_stats.entries[0].wildcards, sw.sw_features.actions, sw.valid_ports, sw.valid_queues)
fc = fc.canonical()
if (not ft.find(fc)):
break
fc.send_rem = False
logging.info('Sending flow add switch')
logging.info(str(fc))
self.assertTrue(sw.flow_add(fc), 'Failed to add flow')
self.assertTrue(sw.barrier(), 'Barrier failed')
sw.settle()
if (not sw.errors_verify(1, ofp.OFPET_FLOW_MOD_FAILED, ofp.OFPFMFC_ALL_TABLES_FULL)):
result = False
sw.flow_tbl = ft
if (not sw.flow_tbl_verify()):
result = False
self.assertTrue(result, 'Flow_add_6 TEST FAILED')
logging.info('Flow_add_6 TEST PASSED') |
_op([AllocCursorA, IntA, NewExprA('buf_cursor'), NewExprA('buf_cursor')])
def resize_dim(proc, buf_cursor, dim_idx, size, offset):
stmt_c = buf_cursor._impl
(ir, fwd) = scheduling.DoResizeDim(stmt_c, dim_idx, size, offset)
return Procedure(ir, _provenance_eq_Procedure=proc, _forward=fwd) |
('Updater.last_required_reboot_performed', return_value=False)
('Updater.sdlog.error')
('Updater.sdlog.info')
def test_overall_update_status_reboot_not_done_previously(mocked_info, mocked_error, mocked_reboot_performed):
result = updater.overall_update_status(TEST_RESULTS_UPDATES)
assert (result == UpdateStatus.REBOOT_REQUIRED)
assert (not mocked_error.called) |
def paragraph(node: RenderTreeNode, context: RenderContext) -> str:
inline_node = node.children[0]
text = inline_node.render(context)
if context.do_wrap:
wrap_mode = context.options['mdformat']['wrap']
if isinstance(wrap_mode, int):
wrap_mode -= context.env['indent_width']
wrap_mode = max(1, wrap_mode)
text = _wrap(text, width=wrap_mode)
text = decimalify_leading(codepoints.UNICODE_WHITESPACE, text)
text = decimalify_trailing(codepoints.UNICODE_WHITESPACE, text)
lines = text.split('\n')
for i in range(len(lines)):
lines[i] = lines[i].strip()
if re.match('#{1,6}( |\\t|$)', lines[i]):
lines[i] = f'\{lines[i]}'
if lines[i].startswith('>'):
lines[i] = f'\{lines[i]}'
if re.match('[-*+]( |\\t|$)', lines[i]):
lines[i] = f'\{lines[i]}'
if re.match('[0-9]+\\)( |\\t|$)', lines[i]):
lines[i] = lines[i].replace(')', '\\)', 1)
if re.match('[0-9]+\\.( |\\t|$)', lines[i]):
lines[i] = lines[i].replace('.', '\\.', 1)
space_removed = lines[i].replace(' ', '').replace('\t', '')
if (len(space_removed) >= 3):
if all(((c == '*') for c in space_removed)):
lines[i] = lines[i].replace('*', '\\*', 1)
elif all(((c == '-') for c in space_removed)):
lines[i] = lines[i].replace('-', '\\-', 1)
elif all(((c == '_') for c in space_removed)):
lines[i] = lines[i].replace('_', '\\_', 1)
stripped = lines[i].strip(' \t')
if all(((c == '-') for c in stripped)):
lines[i] = lines[i].replace('-', '\\-', 1)
elif all(((c == '=') for c in stripped)):
lines[i] = lines[i].replace('=', '\\=', 1)
for html_seq_tuple in HTML_SEQUENCES:
can_break_paragraph = html_seq_tuple[2]
opening_re = html_seq_tuple[0]
if (can_break_paragraph and opening_re.search(lines[i])):
lines[i] = f' {lines[i]}'
break
text = '\n'.join(lines)
return text |
def query_pfam_annotate(arguments):
(queries_pfams_group, queries_fasta, pfam_db, temp_dir, translate, pfam_file, cpu, data_path) = arguments
set_data_path(data_path)
aligned_pfams = None
(fasta_file, hmm_file) = filter_fasta_hmm_files(queries_pfams_group, queries_fasta, pfam_db, temp_dir)
if ((fasta_file is None) or (hmm_file is None)):
pass
else:
P = NamedTemporaryFile(mode='w', dir=temp_dir)
(pfam_args, infile) = get_hmmsearch_args(cpu, fasta_file.name, hmm_file.name, translate, temp_dir)
pfam_aligner = PfamAligner(pfam_args)
pfam_aligner.align_whole_pfam(infile, P.name, silent=True)
aligned_pfams = parse_hmmsearch_file(P.name)
with open(pfam_file, 'a') as pfamf:
pfamf.write(open(P.name, 'r').read())
P.close()
if (fasta_file is not None):
fasta_file.close()
if (hmm_file is not None):
hmm_file.close()
return aligned_pfams |
class UltimateSpeedHandler(THBEventHandler):
interested = ['action_apply', 'choose_target', 'post_calcdistance']
def handle(self, evt_type, arg):
def is_card(card):
return (('skill' not in card.category) or ('treat_as' in card.category))
if (evt_type == 'post_calcdistance'):
(src, card, dist) = arg
if (not is_card(card)):
return arg
if ttags(src)['aya_range_max']:
return arg
g = self.game
current = PlayerTurn.get_current(g).target
if (current is not src):
return arg
for k in dist:
dist[k] = 0
elif (evt_type == 'choose_target'):
(lca, _) = arg
g = self.game
if (not is_card(lca.card)):
return arg
src = lca.source
if (not src.has_skill(UltimateSpeed)):
return arg
try:
current = PlayerTurn.get_current(g).target
except IndexError:
return arg
if (current is not src):
return arg
ttags(src)['aya_count'] += 1
if (src.tags['aya_count'] == 1):
g.process_action(UltimateSpeedUnleashAction(src, src))
if (ttags(src)['aya_count'] == 2):
g.process_action(UltimateSpeedDrawAction(src, src))
return arg |
class OptionPlotoptionsAreasplineSonificationTracksMappingHighpass(Options):
def frequency(self) -> 'OptionPlotoptionsAreasplineSonificationTracksMappingHighpassFrequency':
return self._config_sub_data('frequency', OptionPlotoptionsAreasplineSonificationTracksMappingHighpassFrequency)
def resonance(self) -> 'OptionPlotoptionsAreasplineSonificationTracksMappingHighpassResonance':
return self._config_sub_data('resonance', OptionPlotoptionsAreasplineSonificationTracksMappingHighpassResonance) |
def show_dependencies(reqs, python=None, *, dryrun=False):
if (not python):
python = sys.executable
print('dependencies:')
for req in reqs:
for c in '<=>;':
req = req.partition(c)[0]
if dryrun:
print(' ', req)
else:
print()
_get_dependencies(python, req) |
def main():
module_spec = schema_to_module_spec(versioned_schema)
mkeyname = 'ems-id'
fields = {'access_token': {'required': False, 'type': 'str', 'no_log': True}, 'enable_log': {'required': False, 'type': 'bool', 'default': False}, 'vdom': {'required': False, 'type': 'str', 'default': 'root'}, 'member_path': {'required': False, 'type': 'str'}, 'member_state': {'type': 'str', 'required': False, 'choices': ['present', 'absent']}, 'state': {'required': True, 'type': 'str', 'choices': ['present', 'absent']}, 'endpoint_control_fctems_override': {'required': False, 'type': 'dict', 'default': None, 'options': {}}}
for attribute_name in module_spec['options']:
fields['endpoint_control_fctems_override']['options'][attribute_name] = module_spec['options'][attribute_name]
if (mkeyname and (mkeyname == attribute_name)):
fields['endpoint_control_fctems_override']['options'][attribute_name]['required'] = True
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
check_legacy_fortiosapi(module)
is_error = False
has_changed = False
result = None
diff = None
versions_check_result = None
if module._socket_path:
connection = Connection(module._socket_path)
if ('access_token' in module.params):
connection.set_option('access_token', module.params['access_token'])
if ('enable_log' in module.params):
connection.set_option('enable_log', module.params['enable_log'])
else:
connection.set_option('enable_log', False)
fos = FortiOSHandler(connection, module, mkeyname)
versions_check_result = check_schema_versioning(fos, versioned_schema, 'endpoint_control_fctems_override')
(is_error, has_changed, result, diff) = fortios_endpoint_control(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
if (versions_check_result and (versions_check_result['matched'] is False)):
module.warn('Ansible has detected version mismatch between FortOS system and your playbook, see more details by specifying option -vvv')
if (not is_error):
if (versions_check_result and (versions_check_result['matched'] is False)):
module.exit_json(changed=has_changed, version_check_warning=versions_check_result, meta=result, diff=diff)
else:
module.exit_json(changed=has_changed, meta=result, diff=diff)
elif (versions_check_result and (versions_check_result['matched'] is False)):
module.fail_json(msg='Error in repo', version_check_warning=versions_check_result, meta=result)
else:
module.fail_json(msg='Error in repo', meta=result) |
def google_search(search: str, search_depth: int):
try:
res = requests.get((' + search))
res.raise_for_status()
except:
warning("There was a problem with this services's internet")
st.warning("There was a problem with this services's internet. \n If you got HTTPError: 429, that means this services's IP is being rate limited. If you experience this, please report the issue at \n \nYou can try again by refreshing the page.")
raise
links = find_links_from_search(res)
largest_results = page_search(search, search_depth, links)
return largest_results |
def main():
module_spec = schema_to_module_spec(versioned_schema)
mkeyname = None
fields = {'access_token': {'required': False, 'type': 'str', 'no_log': True}, 'enable_log': {'required': False, 'type': 'bool', 'default': False}, 'vdom': {'required': False, 'type': 'str', 'default': 'root'}, 'member_path': {'required': False, 'type': 'str'}, 'member_state': {'type': 'str', 'required': False, 'choices': ['present', 'absent']}, 'log_fortianalyzer_cloud_setting': {'required': False, 'type': 'dict', 'default': None, 'options': {}}}
for attribute_name in module_spec['options']:
fields['log_fortianalyzer_cloud_setting']['options'][attribute_name] = module_spec['options'][attribute_name]
if (mkeyname and (mkeyname == attribute_name)):
fields['log_fortianalyzer_cloud_setting']['options'][attribute_name]['required'] = True
module = AnsibleModule(argument_spec=fields, supports_check_mode=False)
check_legacy_fortiosapi(module)
is_error = False
has_changed = False
result = None
diff = None
versions_check_result = None
if module._socket_path:
connection = Connection(module._socket_path)
if ('access_token' in module.params):
connection.set_option('access_token', module.params['access_token'])
if ('enable_log' in module.params):
connection.set_option('enable_log', module.params['enable_log'])
else:
connection.set_option('enable_log', False)
fos = FortiOSHandler(connection, module, mkeyname)
versions_check_result = check_schema_versioning(fos, versioned_schema, 'log_fortianalyzer_cloud_setting')
(is_error, has_changed, result, diff) = fortios_log_fortianalyzer_cloud(module.params, fos)
else:
module.fail_json(**FAIL_SOCKET_MSG)
if (versions_check_result and (versions_check_result['matched'] is False)):
module.warn('Ansible has detected version mismatch between FortOS system and your playbook, see more details by specifying option -vvv')
if (not is_error):
if (versions_check_result and (versions_check_result['matched'] is False)):
module.exit_json(changed=has_changed, version_check_warning=versions_check_result, meta=result, diff=diff)
else:
module.exit_json(changed=has_changed, meta=result, diff=diff)
elif (versions_check_result and (versions_check_result['matched'] is False)):
module.fail_json(msg='Error in repo', version_check_warning=versions_check_result, meta=result)
else:
module.fail_json(msg='Error in repo', meta=result) |
def log_syslogd3_override_setting(data, fos):
vdom = data['vdom']
log_syslogd3_override_setting_data = data['log_syslogd3_override_setting']
filtered_data = underscore_to_hyphen(filter_log_syslogd3_override_setting_data(log_syslogd3_override_setting_data))
return fos.set('log.syslogd3', 'override-setting', data=filtered_data, vdom=vdom) |
def getHexToRgb(hex_color: str):
res = re.search('rgba\\(([0-9]*), ([0-9]*), ([0-9]*)', hex_color)
if (res is not None):
return [res.group(1), res.group(2), res.group(3)]
if (not hex_color.startswith('#')):
raise ValueError('Hexadecimal color should start with #')
if (not (len(hex_color) == 7)):
raise ValueError('Color should have a length of 7')
return [int(hex_color[1:3], 16), int(hex_color[3:5], 16), int(hex_color[5:7], 16)] |
def _check_scalar_array(obj, name, value):
if (value is None):
return None
arr = np.asarray(value)
assert (len(arr.shape) in [2, 3]), 'Scalar array must be 2 or 3 dimensional'
vd = obj.vector_data
if (vd is not None):
assert (vd.shape[:(- 1)] == arr.shape), ('Scalar array must match already set vector data.\nvector_data.shape = %s, given array shape = %s' % (vd.shape, arr.shape))
return arr |
class OptionSeriesArcdiagramSonificationContexttracksMappingPan(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
(no_gui_test_assistant, 'No GuiTestAssistant')
class TestAboutDialog(unittest.TestCase, GuiTestAssistant):
def setUp(self):
GuiTestAssistant.setUp(self)
self.dialog = AboutDialog()
def tearDown(self):
if (self.dialog.control is not None):
with self.delete_widget(self.dialog.control):
self.dialog.destroy()
self.dialog = None
GuiTestAssistant.tearDown(self)
def test_create(self):
with self.event_loop():
self.dialog.create()
with self.event_loop():
self.dialog.destroy()
def test_destroy(self):
with self.event_loop():
self.dialog.destroy()
def test_create_parent(self):
parent = Window()
with self.event_loop():
parent.create(parent.control)
self.dialog.create()
with self.event_loop():
self.dialog.destroy()
with self.event_loop():
parent.destroy()
(no_modal_dialog_tester, 'ModalDialogTester unavailable')
def test_accept(self):
tester = ModalDialogTester(self.dialog.open)
tester.open_and_run(when_opened=(lambda x: x.close(accept=True)))
self.assertEqual(tester.result, OK)
self.assertEqual(self.dialog.return_code, OK)
(no_modal_dialog_tester, 'ModalDialogTester unavailable')
def test_close(self):
tester = ModalDialogTester(self.dialog.open)
tester.open_and_run(when_opened=(lambda x: self.dialog.close()))
self.assertEqual(tester.result, CANCEL)
self.assertEqual(self.dialog.return_code, CANCEL)
(no_modal_dialog_tester, 'ModalDialogTester unavailable')
def test_parent(self):
parent = Window()
self.dialog.parent = parent.control
parent.open()
tester = ModalDialogTester(self.dialog.open)
tester.open_and_run(when_opened=(lambda x: x.close(accept=True)))
with self.event_loop():
parent.close()
self.assertEqual(tester.result, OK)
self.assertEqual(self.dialog.return_code, OK)
def test__create_html(self):
self.dialog.additions.extend(['test line 1', 'test line 2'])
self.dialog.copyrights.extend(['copyright', 'copyleft'])
html = self.dialog._create_html()
self.assertIn('test line 1<br />test line 2<br>', html)
self.assertIn('Copyright © copyright<br />Copyright © copyleft', html)
def test_image_default(self):
import pyface
expected_path = os.path.join(os.path.dirname(pyface.__file__), 'images', 'about.png')
self.assertEqual(self.dialog.image.absolute_path, expected_path) |
def search(payload, method='general'):
log.debug(('Searching with payload (%s): %s' % (method, repr(payload))))
if ((method == 'episode') and ('anime' in payload) and payload['anime']):
method = 'anime'
if (method == 'general'):
if ('query' in payload):
payload['title'] = payload['query']
payload['titles'] = {'source': payload['query'], 'original': payload['query']}
else:
payload = {'title': payload, 'titles': {'source': payload, 'original': payload}}
payload['titles'] = dict(((k.lower(), v) for (k, v) in iteritems(payload['titles'])))
payload['has_special'] = (('titles' in payload) and bool(payload['titles']) and ('source' in payload['titles']) and any(((c in payload['titles']['source']) for c in special_chars)))
if payload['has_special']:
log.debug('Query title contains special chars, so removing any quotes in the search query')
if ('episode' not in payload):
payload['episode'] = 0
if ('proxy_url' not in payload):
payload['proxy_url'] = ''
if ('internal_proxy_url' not in payload):
payload['internal_proxy_url'] = ''
if ('elementum_url' not in payload):
payload['elementum_url'] = ''
if ('silent' not in payload):
payload['silent'] = False
if ('skip_auth' not in payload):
payload['skip_auth'] = False
global request_time
global provider_cache
global provider_names
global provider_results
global available_providers
provider_cache = {}
provider_names = []
provider_results = []
available_providers = 0
request_time = time.time()
providers = get_enabled_providers(method)
if (len(providers) == 0):
if (not payload['silent']):
notify(translation(32060), image=get_icon_path())
log.error('No providers enabled')
return []
log.info(("Burstin' with %s" % ', '.join([definitions[provider]['name'] for provider in providers])))
if use_kodi_language:
kodi_language = xbmc.getLanguage(xbmc.ISO_639_1)
if (not kodi_language):
log.warning('Kodi returned empty language code...')
elif (('titles' not in payload) or (not payload['titles'])):
log.info('No translations available...')
elif (payload['titles'] and (kodi_language not in payload['titles'])):
log.info(("No '%s' translation available..." % kodi_language))
p_dialog = xbmcgui.DialogProgressBG()
if (not payload['silent']):
p_dialog.create('Elementum [COLOR FFFF6B00]Burst[/COLOR]', translation(32061))
if ('titles' in payload):
log.debug(('Translated titles from Elementum: %s' % repr(payload['titles'])))
providers_time = time.time()
for provider in providers:
available_providers += 1
provider_names.append(definitions[provider]['name'])
task = Thread(target=run_provider, args=(provider, payload, method, providers_time, timeout))
task.start()
total = float(available_providers)
while (((time.time() - providers_time) < timeout) and (available_providers > 0)):
timer = (time.time() - providers_time)
log.debug(('Timer: %ds / %ds' % (timer, timeout)))
if (timer > timeout):
break
message = ((translation(32062) % available_providers) if (available_providers > 1) else translation(32063))
if (not payload['silent']):
p_dialog.update(int((((total - available_providers) / total) * 100)), message=message)
time.sleep(0.25)
if (not payload['silent']):
p_dialog.close()
del p_dialog
if (available_providers > 0):
message = ', '.join(provider_names)
message = (message + translation(32064))
log.warning(message)
if (not payload['silent']):
notify(message, ADDON_ICON)
log.debug(('all provider_results of %d: %s' % (len(provider_results), repr(provider_results))))
filtered_results = apply_filters(provider_results)
log.debug(('all filtered_results of %d: %s' % (len(filtered_results), repr(filtered_results))))
log.info(('Providers returned %d results in %s seconds' % (len(filtered_results), round((time.time() - request_time), 2))))
return filtered_results |
def get_textNqF0s(line, phids):
line = line.decode('utf-8').split()[1:]
texts = [phids['<']]
qF0s = [0.0]
for k in line:
if ('_' in k):
phone = k.split('_')[0]
texts.append(phids[phone])
qF0 = float(k.split('_')[1])
qF0s.append(qF0)
else:
phone = k
texts.append(phids[phone])
qF0s.append(4.0)
texts += [phids['>']]
qF0s += [0.0]
assert (len(texts) == len(qF0s))
return (texts, qF0s) |
def check_all_variables(X: pd.DataFrame, variables: Variables) -> List[Union[(str, int)]]:
if isinstance(variables, (str, int)):
if (variables not in X.columns.to_list()):
raise KeyError(f'The variable {variables} is not in the dataframe.')
variables_ = [variables]
else:
if (not set(variables).issubset(set(X.columns))):
raise KeyError('Some of the variables are not in the dataframe.')
variables_ = variables
return variables_ |
def populate_dot_thbattle():
res_path = _set_bootstrap_path()
os.system('rm -rf ~/.thbattle/{osx-eggs,src}')
os.system(('mkdir -p ~/.thbattle/osx-eggs && cd ~/.thbattle/osx-eggs && tar -xf %s' % os.path.join(res_path, 'osx-eggs.tar')))
os.system(('mkdir -p ~/.thbattle/src && cd ~/.thbattle/src && tar -xf %s' % os.path.join(res_path, 'src.tar')))
import pygit2
repo = pygit2.Repository(os.path.expanduser('~/.thbattle/osx-eggs'))
repo.reset(repo.revparse_single('origin/master').id, pygit2.GIT_RESET_HARD)
repo = pygit2.Repository(os.path.expanduser('~/.thbattle/src'))
repo.reset(repo.revparse_single('origin/production').id, pygit2.GIT_RESET_HARD) |
class FunctionDataSourceTestCase(UnittestTools, unittest.TestCase):
def setUp(self):
self.myfunc = (lambda low, high: (linspace(low, high, 101) ** 2))
self.data_source = FunctionDataSource(func=self.myfunc)
def test_init_defaults(self):
data_source = FunctionDataSource()
assert_array_equal(data_source._data, [])
self.assertEqual(data_source.value_dimension, 'scalar')
self.assertEqual(data_source.sort_order, 'ascending')
self.assertFalse(data_source.is_masked())
def test_basic_setup(self):
assert_array_equal(self.myfunc, self.data_source.func)
self.assertEqual(self.data_source.value_dimension, 'scalar')
self.assertEqual(self.data_source.sort_order, 'ascending')
self.assertFalse(self.data_source.is_masked())
def test_set_data(self):
with self.assertRaises(RuntimeError):
self.data_source.set_data((lambda low, high: linspace(low, high, 101)))
def test_range_high_changed(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=1.0)
with self.assertTraitChanges(self.data_source, 'data_changed', count=1):
self.data_source.data_range.high_setting = 2.0
assert_array_equal((linspace(0.0, 2.0, 101) ** 2), self.data_source.get_data())
def test_range_low_changed(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=1.0)
with self.assertTraitChanges(self.data_source, 'data_changed', count=1):
self.data_source.data_range.low_setting = (- 1.0)
assert_array_equal((linspace((- 1.0), 1.0, 101) ** 2), self.data_source.get_data())
def test_range_data_range_changed(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=1.0)
with self.assertTraitChanges(self.data_source, 'data_changed', count=1):
self.data_source.data_range = DataRange1D(low_setting=(- 2.0), high_setting=2.0)
assert_array_equal((linspace((- 2.0), 2.0, 101) ** 2), self.data_source.get_data())
def test_set_mask(self):
mymask = array([(i % 2) for i in range(101)], dtype=bool)
with self.assertRaises(NotImplementedError):
self.data_source.set_mask(mymask)
def test_remove_mask(self):
with self.assertRaises(NotImplementedError):
self.data_source.remove_mask()
def test_get_data(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=1.0)
assert_array_equal((linspace(0.0, 1.0, 101) ** 2), self.data_source.get_data())
def test_get_data_no_data(self):
self.data_source = FunctionDataSource()
assert_array_equal(self.data_source.get_data(), array([], dtype=float))
def test_get_data_mask(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=1.0)
(data, mask) = self.data_source.get_data_mask()
assert_array_equal(data, (linspace(0.0, 1.0, 101) ** 2))
assert_array_equal(mask, ones(shape=101, dtype=bool))
def test_bounds(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=2.0)
bounds = self.data_source.get_bounds()
self.assertEqual(bounds, (0.0, 4.0))
("default sort_order is ascending, which isn't right")
def test_bounds_non_monotone(self):
self.data_source.data_range = DataRange1D(low_setting=(- 2.0), high_setting=2.0)
bounds = self.data_source.get_bounds()
self.assertEqual(bounds, (0.0, 4.0))
def test_data_size(self):
self.data_source.data_range = DataRange1D(low_setting=0.0, high_setting=2.0)
self.assertEqual(101, self.data_source.get_size()) |
def format_running_time(runtime: int) -> str:
days = 0
hours = 0
minutes = 0
seconds = math.trunc(runtime)
if (seconds >= 60):
(minutes, seconds) = divmod(seconds, 60)
if (minutes >= 60):
(hours, minutes) = divmod(minutes, 60)
if (hours >= 24):
(days, hours) = divmod(hours, 24)
if (days > 0):
layout = 'Running time: {d} days {h} hours {m} minutes {s} seconds'
elif (hours > 0):
layout = 'Running time: {h} hours {m} minutes {s} seconds'
elif (minutes > 0):
layout = 'Running time: {m} minutes {s} seconds'
else:
layout = 'Running time: {s} seconds'
return layout.format(d=days, h=hours, m=minutes, s=seconds) |
def read_fixture_file(path: (str | Path)) -> list[list[Any]]:
text = Path(path).read_text(encoding='utf-8')
tests = []
section = 0
last_pos = 0
lines = text.splitlines(keepends=True)
for i in range(len(lines)):
if (lines[i].rstrip() == '.'):
if (section == 0):
tests.append([i, lines[(i - 1)].strip()])
section = 1
elif (section == 1):
tests[(- 1)].append(''.join(lines[(last_pos + 1):i]))
section = 2
elif (section == 2):
tests[(- 1)].append(''.join(lines[(last_pos + 1):i]))
section = 0
last_pos = i
return tests |
def get_boundaries(is_jp: bool) -> Optional[list[int]]:
file_data = game_data_getter.get_file_latest('DataLocal', 'GamatotoExpedition.csv', is_jp)
if (file_data is None):
helper.error_text('Failed to get gamatoto xp requirements')
return None
boundaries = file_data.decode('utf-8').splitlines()
previous = 0
xp_requirements: list[int] = []
previous = 0
for line in boundaries:
requirement = int(line.split(',')[0])
if (previous >= requirement):
break
xp_requirements.append(requirement)
previous = requirement
return xp_requirements |
('pyscf')
.parametrize('hbond_angles, prim_len_ref', ((True, 56), (False, 42)))
def test_run_geom_section_union(hbond_angles, prim_len_ref):
ref_energy = (- 160.)
def run_assert(run_dict, prim_len):
res = run_from_dict(run_dict)
geom = res.calced_geoms[0]
assert (geom.energy == pytest.approx(ref_energy))
int_ = geom.internal
assert (len(int_.prim_indices_set) == prim_len)
def get_run_dict():
return {'geom': {'type': 'redund', 'fn': 'lib:test_union_ts_001.xyz', 'coord_kwargs': {'hbond_angles': hbond_angles}}, 'calc': {'type': 'pyscf', 'basis': 'sto3g'}}
run_assert(get_run_dict(), prim_len=prim_len_ref)
run_dict = get_run_dict()
run_dict['geom']['union'] = 'lib:test_union_rx_001.trj'
run_assert(run_dict, prim_len=89) |
class DomainMetadata(models.Model):
domain = models.ForeignKey('pdns.Domain', blank=True, null=True)
kind = models.CharField(max_length=32, blank=True, null=True)
content = models.TextField(blank=True, null=True)
class Meta():
managed = False
db_table = 'domainmetadata'
def __unicode__(self):
return ('(%s: %s=%s)' % (self.domain, self.kind, self.content))
def save(self, *args, **kwargs):
logger.info('Saving domainmetadata entry for domain "%s": "%s"="%s"', self.domain, self.kind, self.content)
return super(DomainMetadata, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
logger.info('Deleting domainmetadata entry for domain "%s": "%s"="%s"', self.domain, self.kind, self.content)
return super(DomainMetadata, self).delete(*args, **kwargs)
def get_content(self):
return self.content |
.parametrize(['expr', 'value', 'typ', 'fs_type'], itertools.product(['f', '2.0*tanh(f) + cos(f) + sin(f)', '1.0/tanh(f) + 1.0/f'], [1, 10, (- 1), (- 10)], ['function', 'constant'], ['scalar', 'vector', 'tensor']))
def test_functions(mesh, expr, value, typ, fs_type):
if (typ == 'function'):
if (fs_type == 'vector'):
V = VectorFunctionSpace(mesh, 'CG', 1)
elif (fs_type == 'tensor'):
V = TensorFunctionSpace(mesh, 'CG', 1)
else:
V = FunctionSpace(mesh, 'CG', 1)
f = Function(V)
f.assign(value)
if (fs_type == 'vector'):
f = dot(f, f)
elif (fs_type == 'tensor'):
f = inner(f, f)
elif (typ == 'constant'):
if (fs_type == 'vector'):
f = Constant([value, value], domain=mesh)
f = dot(f, f)
elif (fs_type == 'tensor'):
f = Constant([[value, value], [value, value]], domain=mesh)
f = inner(f, f)
else:
f = Constant(value, domain=mesh)
actual = assemble(Tensor((eval(expr) * dx)))
if (fs_type == 'vector'):
f = (2 * (value ** 2))
elif (fs_type == 'tensor'):
f = (4 * (value ** 2))
else:
f = value
expect = eval(expr)
assert np.allclose(actual, expect) |
class LocationFlatPage(models.Model):
menu = models.ForeignKey(LocationMenu, related_name='pages', help_text='Note: If there is only one page in the menu, it will be used as a top level nav item, and the menu name will not be used.')
flatpage = models.OneToOneField(FlatPage)
def slug(self):
url = self.flatpage.url
u_split = url.split('/')
if (len(u_split) > 3):
return u_split[3]
return None
def title(self):
return self.flatpage.title
def content(self):
return self.flatpage.content
def __str__(self):
return self.flatpage.title |
class AccountBasedExpenseLineDetail(QuickbooksBaseObject):
class_dict = {'CustomerRef': Ref, 'AccountRef': Ref, 'TaxCodeRef': Ref, 'ClassRef': Ref, 'MarkupInfo': MarkupInfo}
def __init__(self):
super(AccountBasedExpenseLineDetail, self).__init__()
self.BillableStatus = None
self.TaxAmount = 0
self.TaxInclusiveAmt = 0
self.CustomerRef = None
self.AccountRef = None
self.TaxCodeRef = None
self.ClassRef = None
self.MarkupInfo = None
def __str__(self):
return self.BillableStatus |
class UPnPService(Service):
logger = get_logger('trinity.components.upnp.UPnPService')
def __init__(self, port: int, event_bus: EndpointAPI) -> None:
self.port = port
self.event_bus = event_bus
async def run(self) -> None:
while self.manager.is_running:
async for _ in every(UPNP_PORTMAP_DURATION):
with trio.move_on_after(UPNP_DISCOVER_TIMEOUT_SECONDS) as scope:
try:
(internal_ip, external_ip) = (await trio.to_thread.run_sync(setup_port_map, self.port, UPNP_PORTMAP_DURATION))
event = UPnPMapping(str(external_ip))
self.logger.debug('NAT portmap created, broadcasting UPnPMapping event: %s', event)
(await self.event_bus.broadcast(event, FIRE_AND_FORGET_BROADCASTING))
except PortMapFailed as err:
self.logger.error('Failed to setup NAT portmap: %s', err)
except Exception:
self.logger.exception('Error setuping NAT portmap')
if scope.cancelled_caught:
self.logger.error('Timeout attempting to setup UPnP port map') |
def setup_after_launch(cfg: CfgNode, output_dir: str, runner_class: Union[(None, str, Type[BaseRunner], Type[DefaultTask])]) -> Union[(None, BaseRunner, Type[DefaultTask])]:
create_dir_on_global_main_process(output_dir)
setup_loggers(output_dir)
log_system_info()
cfg.freeze()
maybe_override_output_dir(cfg, output_dir)
logger.info('Running with full config:\n{}'.format(cfg))
dump_cfg(cfg, os.path.join(output_dir, 'config.yaml'))
if isinstance(runner_class, str):
logger.info(f'Importing runner: {runner_class} ...')
runner_class = import_runner(runner_class)
if issubclass(runner_class, DefaultTask):
logger.info(f'Importing lightning task: {runner_class} ...')
runner = runner_class
elif issubclass(runner_class, BaseRunner):
logger.info(f'Initializing runner: {runner_class} ...')
runner = runner_class()
runner = initialize_runner(runner, cfg)
logger.info('Running with runner: {}'.format(runner))
else:
assert (runner_class is None), f'Unsupported runner class: {runner_class}'
runner = None
default_cfg = (runner_class.get_default_cfg() if (runner_class and (not issubclass(runner_class, RunnerV2Mixin))) else cfg.get_default_cfg())
dump_cfg(get_diff_cfg(default_cfg, cfg), os.path.join(output_dir, 'diff_config.yaml'))
auto_scale_world_size(cfg, new_world_size=comm.get_world_size())
if cfg.SOLVER.DETERMINISTIC:
logging.warning('Using deterministic training for the reproducibility')
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
torch.use_deterministic_algorithms(True)
os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'
if (cfg.SEED > 0):
seed_all_rng(cfg.SEED)
return runner |
class WriteFontInfoVersion3TestCase(unittest.TestCase):
def setUp(self):
self.tempDir = tempfile.mktemp()
os.mkdir(self.tempDir)
self.dstDir = os.path.join(self.tempDir, 'test.ufo')
def tearDown(self):
shutil.rmtree(self.tempDir)
def tearDownUFO(self):
if os.path.exists(self.dstDir):
shutil.rmtree(self.dstDir)
def makeInfoObject(self):
infoObject = TestInfoObject()
for (attr, value) in list(fontInfoVersion3.items()):
setattr(infoObject, attr, value)
return infoObject
def readPlist(self):
path = os.path.join(self.dstDir, 'fontinfo.plist')
with open(path, 'rb') as f:
plist = plistlib.load(f)
return plist
def testWrite(self):
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
writtenData = self.readPlist()
for (attr, originalValue) in list(fontInfoVersion3.items()):
newValue = writtenData[attr]
self.assertEqual(newValue, originalValue)
self.tearDownUFO()
def testGenericWrite(self):
infoObject = self.makeInfoObject()
infoObject.familyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.styleName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.styleMapFamilyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.styleMapStyleName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.styleMapStyleName = 'REGULAR'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.versionMajor = '1'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.versionMinor = '0'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.copyright = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.trademark = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.unitsPerEm = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.descender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.xHeight = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.capHeight = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.ascender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.italicAngle = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testGaspWrite(self):
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = []
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = ['abc']
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=65535, notTheRightKey=1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(notTheRightKey=1, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM='abc', rangeGaspBehavior=[0]), dict(rangeMaxPPEM=65535, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior='abc'), dict(rangeMaxPPEM=65535, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[(- 1)]), dict(rangeMaxPPEM=65535, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=65535, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=10, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeGaspRangeRecords = [dict(rangeMaxPPEM=10, rangeGaspBehavior=[0]), dict(rangeMaxPPEM=20, rangeGaspBehavior=[0])]
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
def testHeadWrite(self):
infoObject = self.makeInfoObject()
infoObject.openTypeHeadCreated = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHeadCreated = '2000-Jan-01 00:00:00'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHeadLowestRecPPEM = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHeadFlags = [(- 1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testHheaWrite(self):
infoObject = self.makeInfoObject()
infoObject.openTypeHheaAscender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHheaDescender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHheaLineGap = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHheaCaretSlopeRise = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHheaCaretSlopeRun = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeHheaCaretOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testNameWrite(self):
infoObject = self.makeInfoObject()
infoObject.openTypeNameDesigner = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameDesignerURL = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameManufacturer = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameManufacturerURL = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameLicense = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameLicenseURL = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameVersion = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameUniqueID = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameDescription = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNamePreferredFamilyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNamePreferredSubfamilyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameCompatibleFullName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameSampleText = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameWWSFamilyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameWWSSubfamilyName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = ['abc']
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(foo='bar')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, languageID=1, string='Name Record.', foo='bar')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(platformID=1, encodingID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, encodingID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, languageID=1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID='1', platformID=1, encodingID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID='1', encodingID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID='1', languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, languageID='1', string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, languageID=1, string=1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeNameRecords = [dict(nameID=1, platformID=1, encodingID=1, languageID=1, string='Name Record.'), dict(nameID=1, platformID=1, encodingID=1, languageID=1, string='Name Record.')]
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
def testOS2Write(self):
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WidthClass = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WidthClass = 15
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WeightClass = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WeightClass = (- 50)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Selection = [(- 1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2VendorID = 1234
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, str(9)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Panose = [0, 1, 2, 3]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Panose = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2FamilyClass = [0, str(1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2FamilyClass = [1]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2FamilyClass = [1, 1, 1]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2FamilyClass = [1, 20]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2UnicodeRanges = ['0']
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2UnicodeRanges = [(- 1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2CodePageRanges = ['0']
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2CodePageRanges = [(- 1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2TypoAscender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2TypoDescender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2TypoLineGap = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WinAscent = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WinAscent = (- 1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WinDescent = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2WinDescent = (- 1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Type = ['1']
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2Type = [(- 1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SubscriptXSize = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SubscriptYSize = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SubscriptXOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SubscriptYOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SuperscriptXSize = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SuperscriptYSize = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SuperscriptXOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2SuperscriptYOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2StrikeoutSize = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeOS2StrikeoutPosition = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testVheaWrite(self):
infoObject = self.makeInfoObject()
infoObject.openTypeVheaVertTypoAscender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeVheaVertTypoDescender = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeVheaVertTypoLineGap = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeVheaCaretSlopeRise = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeVheaCaretSlopeRun = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.openTypeVheaCaretOffset = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testFONDWrite(self):
infoObject = self.makeInfoObject()
infoObject.macintoshFONDFamilyID = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.macintoshFONDName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testPostscriptWrite(self):
infoObject = self.makeInfoObject()
infoObject.postscriptFontName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFullName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptSlantAngle = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptUniqueID = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptUnderlineThickness = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptUnderlinePosition = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptIsFixedPitch = 2
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueValues = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueValues = [500]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueValues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptOtherBlues = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptOtherBlues = [500]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptOtherBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyBlues = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyBlues = [500]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyOtherBlues = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyOtherBlues = [500]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptFamilyOtherBlues = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptStemSnapH = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptStemSnapH = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptStemSnapV = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptStemSnapV = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueFuzz = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueShift = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptBlueScale = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptForceBold = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptDefaultWidthX = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptNominalWidthX = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptWeightName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptDefaultCharacter = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.postscriptWindowsCharacterSet = (- 1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.macintoshFONDFamilyID = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.macintoshFONDName = 123
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testWOFFWrite(self):
infoObject = self.makeInfoObject()
infoObject.woffMajorVersion = 1.0
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMajorVersion = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMinorVersion = 1.0
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMinorVersion = 'abc'
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = None
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = 1
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = dict(id='foo', notTheRightKey=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = dict()
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = dict(id=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataUniqueID = dict(id='')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(url='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name=1, url='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='', url='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url='')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url='bar', dir='ltr')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url='bar', dir='rtl')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url='bar', dir=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = dict(name='foo', url='bar', dir='utd')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = {'name': 'foo', 'url': 'bar', 'class': 'hello'}
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = {'name': 'foo', 'url': 'bar', 'class': 1}
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataVendor = {'name': 'foo', 'url': 'bar', 'class': ''}
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = {}
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo')], notTheRightKey=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits='abc')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=['abc'])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo', notTheRightKey=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(url='foo')])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo', url=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo', role=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo', dir=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[dict(name='foo', dir='utd')])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCredits = dict(credits=[{'name': 'foo', 'class': 1}])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo')])
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo')], url=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(url='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text='abc')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=['abc'])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo', notTheRightKey=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(language='foo')])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo', url=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo', language=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[dict(text='foo', dir='utd')])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataDescription = dict(text=[{'text': 'foo', 'class': 1}])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text=[dict(text='foo')])
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text=[dict(text='foo')], url=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text=[dict(text='foo')], id=1)
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(url='foo')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text='abc')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text=['abc'])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicense = dict(text=[dict(text='foo', notTheRightKey=1)])
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[dict(language='foo')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[dict(text=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[dict(text='foo', url=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[dict(text='foo', language=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[dict(text='foo', dir='utd')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicense = dict(text=[{'text': 'foo', 'class': 1}])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text='foo')], notTheRightKey=1)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict()
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text='abc')
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=['abc'])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text='foo', notTheRightKey=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataCopyright = dict(text=[dict(language='foo')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text='foo', url=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text='foo', language=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[dict(text='foo', dir='utd')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataCopyright = dict(text=[{'text': 'foo', 'class': 1}])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text='foo')], notTheRightKey=1)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict()
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text='abc')
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=['abc'])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text='foo', notTheRightKey=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(language='foo')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text='foo', url=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text='foo', language=1)])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[dict(text='foo', dir='utd')])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataTrademark = dict(text=[{'text': 'foo', 'class': 1}])
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicensee = dict()
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicensee = dict(name='foo', notTheRightKey=1)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
writer = UFOWriter(self.dstDir, formatVersion=3)
infoObject.woffMetadataLicensee = dict(name=1)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicensee = dict(name='foo', dir='ltr')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicensee = dict(name='foo', dir='rtl')
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicensee = dict(name='foo', dir='utd')
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicensee = {'name': 'foo', 'class': 'hello'}
writer = UFOWriter(self.dstDir, formatVersion=3)
writer.writeInfo(infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.woffMetadataLicensee = {'name': 'foo', 'class': 1}
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
def testGuidelinesWrite(self):
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x='1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(y='1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, y=0, angle=(- 1))]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, y=0, angle=361)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, name=1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color=1)]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1 0, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1 0 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1 0 0 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color=', 0, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, , 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, 0, , 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, 0, 0, ')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color=', , , ')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='r, 1, 1, 1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, g, 1, 1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, 1, b, 1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, 1, 1, a')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='1, 0, 0, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='-1, 0, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, -1, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, 0, -1, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, 0, 0, -1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='2, 0, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, 2, 0, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, 0, 2, 0')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, color='0, 0, 0, 2')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, identifier='guide1'), dict(y=0, identifier='guide1')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, identifier='\x00x1F')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO()
infoObject = self.makeInfoObject()
infoObject.guidelines = [dict(x=0, identifier='\x00x7F')]
writer = UFOWriter(self.dstDir, formatVersion=3)
self.assertRaises(UFOLibError, writer.writeInfo, info=infoObject)
self.tearDownUFO() |
class OptionSeriesDumbbellSonificationDefaultinstrumentoptionsMappingPan(Options):
def mapFunction(self):
return self._config_get(None)
def mapFunction(self, value: Any):
self._config(value, js_type=False)
def mapTo(self):
return self._config_get(None)
def mapTo(self, text: str):
self._config(text, js_type=False)
def max(self):
return self._config_get(None)
def max(self, num: float):
self._config(num, js_type=False)
def min(self):
return self._config_get(None)
def min(self, num: float):
self._config(num, js_type=False)
def within(self):
return self._config_get(None)
def within(self, value: Any):
self._config(value, js_type=False) |
class SimulationTest(BasicTest):
def _setRelativePath(self, input_file):
self.scriptdir = os.path.dirname(input_file)
def remove_files(filelist):
for file in filelist:
if os.path.isfile(file):
os.remove(file)
def teardown_method(self):
extens = 'm'
for currentFile in os.listdir('.'):
if any((currentFile.endswith(ext) for ext in extens)):
if os.path.isfile(currentFile):
os.remove(currentFile)
def _setPETSc(petsc_file):
for key in petsc4py.PETSc.Options().getAll():
petsc4py.PETSc.Options().delValue(key)
petsc_options = []
with open(petsc_file) as petsc_file:
data = petsc_file.readlines()
def strip_comments(line):
if ('#' in line):
line = line[:line.index('#')]
return line
stripped_data = [strip_comments(line) for line in data]
petsc_options = ''.join(stripped_data).split('\n')
new_petsc = []
for item in petsc_options:
if (item != ''):
new = item.split()
new[0] = new[0][1:]
new_petsc.append(new)
for item in new_petsc:
if (len(item) == 2):
petsc4py.PETSc.Options().setValue(item[0], item[1])
if (len(item) == 1):
petsc4py.PETSc.Options().setValue(item[0], '') |
def build_train_graph(master_spec, hyperparam_config=None):
tf.logging.info('Building Graph...')
if (not hyperparam_config):
hyperparam_config = spec_pb2.GridPoint(learning_method='adam', learning_rate=0.0005, adam_beta1=0.9, adam_beta2=0.9, adam_eps=1e-05, decay_steps=128000, dropout_rate=0.8, gradient_clip_norm=1, use_moving_average=True, seed=1)
graph = tf.Graph()
with graph.as_default():
builder = graph_builder.MasterBuilder(master_spec, hyperparam_config)
component_targets = [spec_pb2.TrainTarget(name=component.name, max_index=(idx + 1), unroll_using_oracle=(([False] * idx) + [True])) for (idx, component) in enumerate(master_spec.component) if ('shift-only' not in component.transition_system.registered_name)]
trainers = [builder.add_training_from_config(target) for target in component_targets]
annotator = builder.add_annotation(enable_tracing=True)
builder.add_saver()
return (graph, builder, trainers, annotator) |
class Idl(idl.Idl):
def __init__(self, session, schema):
if (not isinstance(schema, idl.SchemaHelper)):
schema = idl.SchemaHelper(schema_json=schema)
schema.register_all()
schema = schema.get_idl_schema()
self._events = []
self.tables = schema.tables
self.readonly = schema.readonly
self._db = schema
self._session = session
self._monitor_request_id = None
self._last_seqno = None
self.change_seqno = 0
self.uuid = uuid.uuid1()
self.state = self.IDL_S_INITIAL
self.lock_name = None
self.has_lock = False
self.is_lock_contended = False
self._lock_request_id = None
self.txn = None
self._outstanding_txns = {}
for table in schema.tables.values():
for column in table.columns.values():
if (not hasattr(column, 'alert')):
column.alert = True
table.need_table = False
table.rows = {}
table.idl = self
table.condition = []
table.cond_changed = False
def events(self):
events = self._events
self._events = []
return events
def __process_update(self, table, uuid, old, new):
old_row = table.rows.get(uuid)
if (old_row is not None):
old_row = model.Row(dictify(old_row))
old_row['_uuid'] = uuid
changed = idl.Idl.__process_update(self, table, uuid, old, new)
if changed:
if (not new):
ev = (event.EventRowDelete, (table.name, old_row))
elif (not old):
new_row = model.Row(dictify(table.rows.get(uuid)))
new_row['_uuid'] = uuid
ev = (event.EventRowInsert, (table.name, new_row))
else:
new_row = model.Row(dictify(table.rows.get(uuid)))
new_row['_uuid'] = uuid
ev = (event.EventRowUpdate, (table.name, old_row, new_row))
self._events.append(ev)
return changed |
def acSubmitPseudo(session, dom):
pseudo = dom.getValue('Pseudo').strip()
room = session.room
if (not pseudo):
dom.alert('Pseudo. can not be empty !')
dom.setValue('Pseudo', '')
dom.focus('Pseudo')
elif room.handlePseudo(pseudo.upper()):
session.pseudo = pseudo
dom.addClass('PseudoButton', 'hidden')
dom.disableElement('Pseudo')
dom.enableElements(['Message', 'MessageButton'])
dom.focus('Message')
else:
dom.alert('Pseudo. not available!')
dom.setValue('Pseudo', pseudo)
dom.focus('Pseudo') |
class SchemaManager(SingletonConfigurable):
schemaspaces: Dict[(str, 'Schemaspace')]
schemaspace_id_to_name: Dict[(str, str)]
schemaspace_schemasproviders: Dict[(str, Dict[(str, 'SchemasProvider')])]
schemaspace_schema_validators: Dict[(str, Dict[(str, Any)])]
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.schemaspaces = {}
self.schemaspace_id_to_name = {}
self.schemaspace_schemasproviders = {}
self.schemaspace_schema_validators = {}
self.metadata_testing_enabled = bool(os.getenv('METADATA_TESTING', 0))
self._meta_schema: dict
schema_file = os.path.join(os.path.dirname(__file__), 'schemas', 'meta-schema.json')
with io.open(schema_file, 'r', encoding='utf-8') as f:
self._meta_schema = json.load(f)
self._load_schemaspace_schemas()
def get_schemaspace_names(self, include_deprecated: bool=False) -> List[str]:
schemaspace_names: List[str] = []
for (id, name) in self.schemaspace_id_to_name.items():
if ((not include_deprecated) and self.schemaspaces.get(id).is_deprecated):
self.log.debug(f"get_schemaspace_names: skipping deprecated schemaspace '{name}'...")
continue
schemaspace_names.append(name)
return schemaspace_names
def get_schemaspace_name(self, schemaspace_name_or_id: str) -> str:
self._validate_schemaspace(schemaspace_name_or_id)
return self.schemaspaces.get(schemaspace_name_or_id.lower()).name
def get_schemaspace_schemas(self, schemaspace_name_or_id: str) -> dict:
self._validate_schemaspace(schemaspace_name_or_id)
schemaspace = self.schemaspaces.get(schemaspace_name_or_id.lower())
schemas = copy.deepcopy(schemaspace.schemas)
for schema_name in schemaspace.deprecated_schema_names:
del schemas[schema_name]
return schemas
def get_schema(self, schemaspace_name_or_id: str, schema_name: str) -> dict:
self._validate_schemaspace(schemaspace_name_or_id)
schemaspace = self.schemaspaces.get(schemaspace_name_or_id.lower())
schemas = schemaspace.schemas
if (schema_name not in schemas.keys()):
raise SchemaNotFoundError(schemaspace_name_or_id, schema_name)
schema_json = schemas.get(schema_name)
return copy.deepcopy(schema_json)
def get_schemaspace(self, schemaspace_name_or_id: str) -> 'Schemaspace':
self._validate_schemaspace(schemaspace_name_or_id)
schemaspace = self.schemaspaces.get(schemaspace_name_or_id.lower())
return copy.deepcopy(schemaspace)
def get_schemasproviders(self, schemaspace_id: str) -> Dict[(str, 'SchemasProvider')]:
return self.schemaspace_schemasproviders.get(schemaspace_id, {})
def clear_all(self) -> None:
self.log.debug('SchemaManager: Reloading all schemas for all schemaspaces.')
self._load_schemaspace_schemas()
def validate_instance(self, schemaspace_name_or_id: str, schema_name: str, instance: dict) -> None:
self._validate_schemaspace(schemaspace_name_or_id)
schemaspace_id = self.schemaspaces[schemaspace_name_or_id].id
validator = self.schemaspace_schema_validators[schemaspace_id][schema_name]
validator.validate(instance)
def _validate_schemaspace(self, schemaspace_name_or_id: str) -> None:
if (schemaspace_name_or_id.lower() not in self.schemaspaces):
raise ValueError(f"The schemaspace name or id '{schemaspace_name_or_id}' is not in the list of valid schemaspaces: '{self.get_schemaspace_names()}'!")
def _load_schemaspace_schemas(self):
self._load_schemaspaces()
self._load_schemas_providers()
empty_schemaspaces = []
for schemaspace_name in self.schemaspace_id_to_name.values():
if (len(self.schemaspaces[schemaspace_name].schemas) == 0):
empty_schemaspaces.append(self.schemaspaces[schemaspace_name].name)
if (len(empty_schemaspaces) > 0):
self.log.warning(f'The following schemaspaces have no schemas: {empty_schemaspaces}')
def _load_schemaspaces(self):
for schemaspace in SchemaManager._get_schemaspaces():
try:
if ((not self.metadata_testing_enabled) and (schemaspace.name == METADATA_TEST_SCHEMASPACE)):
continue
self.log.debug(f"Loading schemaspace '{schemaspace.name}'...")
schemaspace_instance = schemaspace.load()(parent=self.parent)
if (not isinstance(schemaspace_instance, Schemaspace)):
raise ValueError(f"Schemaspace instance '{schemaspace.name}' is not an instance of '{Schemaspace.__name__}'!")
self.schemaspaces[schemaspace_instance.id.lower()] = schemaspace_instance
self.schemaspaces[schemaspace_instance.name.lower()] = schemaspace_instance
self.schemaspace_id_to_name[schemaspace_instance.id.lower()] = schemaspace_instance.name.lower()
except Exception as err:
self.log.error(f"Error loading schemaspace '{schemaspace.name}' - {err}")
def _load_schemas_providers(self):
for schemas_provider_ep in SchemaManager._get_schemas_providers():
try:
if ((not self.metadata_testing_enabled) and (schemas_provider_ep.name == METADATA_TEST_SCHEMASPACE)):
continue
self.log.debug(f"Loading SchemasProvider '{schemas_provider_ep.name}'...")
schemas_provider = schemas_provider_ep.load()()
if (not isinstance(schemas_provider, SchemasProvider)):
raise ValueError(f"SchemasProvider instance '{schemas_provider_ep.name}' is not an instance of '{SchemasProvider.__name__}'!")
provider_validators = {}
schemas = schemas_provider.get_schemas()
for schema in schemas:
try:
schemaspace_id = schema.get('schemaspace_id').lower()
schemaspace_name = schema.get('schemaspace')
schema_name = schema.get('name')
if (schemaspace_id not in self.schemaspaces):
raise ValueError(f"Schema '{schema_name}' references a schemaspace '{schemaspace_id}' that is not loaded!")
if (schemaspace_name not in self.schemaspaces):
raise ValueError(f"Schema '{schema_name}' references a schemaspace '{schemaspace_name}' that is not loaded!")
if (self.schemaspaces[schemaspace_id] != self.schemaspaces[schemaspace_name.lower()]):
raise ValueError(f"Schema '{schema_name}' references a schemaspace name '{schemaspace_name}' and a schemaspace id '{schemaspace_id}' that are associated with different Schemaspace instances!")
schema = self.schemaspaces[schemaspace_id].filter_schema(schema)
self._validate_schema(schemaspace_name, schema_name, schema)
self.schemaspaces[schemaspace_id].add_schema(schema)
providers = self.schemaspace_schemasproviders.get(schemaspace_id, {})
providers[schema_name] = schemas_provider
provider_validators = self.schemaspace_schema_validators.get(schemaspace_id, {})
provider_validators[schema_name] = schemas_provider.get_validator(schema)
self.schemaspace_schemasproviders[schemaspace_id] = providers
self.schemaspace_schema_validators[schemaspace_id] = provider_validators
except Exception as schema_err:
self.log.error(f"Error loading schema '{schema.get('name', '??')}' for SchemasProvider '{schemas_provider_ep.name}' - {schema_err}")
except Exception as provider_err:
self.log.error(f"Error loading schemas for SchemasProvider '{schemas_provider_ep.name}' - {provider_err}")
def _validate_schema(self, schemaspace_name: str, schema_name: str, schema: dict):
try:
self.log.debug(f"Validating schema '{schema_name}' of schemaspace {schemaspace_name}...")
validate(instance=schema, schema=self._meta_schema, format_checker=draft7_format_checker)
except ValidationError as ve:
first_line = str(ve).partition('\n')[0]
msg = f"Validation failed for schema '{schema_name}' of schemaspace '{schemaspace_name}' with error: {first_line}."
self.log.error(msg)
raise ValidationError(msg) from ve
def _get_schemaspaces():
return get_group_all('metadata.schemaspaces')
def _get_schemas_providers():
return get_group_all('metadata.schemas_providers') |
def benchmark(fn: Callable, *args, num_iterations: int=10, **kwargs) -> Benchmark:
timer = Timer('fn(*args, **kwargs)', globals={'fn': fn, 'args': args, 'kwargs': kwargs})
times = timer.repeat(number=1, repeat=(num_iterations + 1))
return Benchmark(np.mean(times[1:]).item(), np.std(times[1:]).item()) |
class BsCard(Component):
css_classes = ['card']
name = 'Bootstrap Card'
str_repr = '<div {attrs}><div class="card-body">{sub_items}</div></div>'
dyn_repr = '{sub_item}'
def add_header(self, value):
title = self.page.web.std.div(value)
title.attr['class'].initialise(['card-header'])
title.options.managed = False
self.items.insert(0, title)
return title
def add_footer(self, value):
title = self.page.web.std.div(value)
title.attr['class'].initialise(['card-footer'])
title.options.managed = False
self.items.insert(0, title)
return title
def add_title(self, value):
title = self.page.web.std.tags.hn(5, value)
title.attr['class'].initialise(['card-title'])
title.options.managed = False
self.items.append(title)
return title
def add_subtitle(self, value):
title = self.page.web.std.tags.hn(6, value)
title.attr['class'].initialise(['card-subtitle'])
title.options.managed = False
self.items.append(title)
return title
def add_text(self, value):
pass
def add_link(self, value, url: str='#'):
link = self.page.web.std.link(value, url)
link.attr['class'].initialise(['card-link'])
link.options.managed = False
self.items.append(link)
return link |
_router.get('/item/{item_uid}/chunk/{chunk_uid}/download/', dependencies=PERMISSIONS_READ)
def chunk_download(chunk_uid: str, collection: models.Collection=Depends(get_collection)):
chunk = get_object_or_404(collection.chunks, uid=chunk_uid)
filename = chunk.chunkFile.path
return sendfile(filename) |
def random_select(seed: bytes32) -> address:
select_val: wei_value = as_wei_value(as_num128(num256_mod(as_num256(seed), as_num256(self.total_deposits))), wei)
ind: num = 1
for i in range(15):
if (select_val <= self.validator_table[(ind * 2)].bal):
ind = (ind * 2)
else:
select_val -= self.validator_table[(ind * 2)].bal
ind = ((ind * 2) + 1)
return self.validator_table[ind].addr |
def test_switch_no_empty_fallthough(task):
task.options.set('pattern-independent-restructuring.min_switch_case_number', 11)
(switch_variable, vertices) = _switch_no_empty_fallthrough(task)
PatternIndependentRestructuring().run(task)
assert (isinstance((seq_node := task.syntax_tree.root), SeqNode) and (len(seq_node.children) == 3))
assert (isinstance(seq_node.children[0], CodeNode) and (seq_node.children[0].instructions == vertices[0].instructions[:(- 1)]))
assert isinstance((current_cond := seq_node.children[1]), ConditionNode)
assert (isinstance(seq_node.children[2], CodeNode) and (seq_node.children[2].instructions == vertices[3].instructions))
for constants in [[0, 1], [2, 3, 4], [5, 6, 7, 8, 9]]:
assert (isinstance(current_cond, ConditionNode) and current_cond.condition.is_disjunction)
assert ({task.syntax_tree.condition_map[op] for op in current_cond.condition.operands} == {Condition(OperationType.equal, [switch_variable, Constant(c, Integer(32))]) for c in constants})
assert (isinstance((fallthrough := current_cond.true_branch_child), SeqNode) and (len(fallthrough.children) == len(constants)))
or_cases = []
for (child, const) in zip(fallthrough.children[:(- 1)], constants):
or_cases.append(const)
assert (isinstance(child, ConditionNode) and (child.false_branch is None))
assert (((len(or_cases) > 1) and child.condition.is_disjunction) or ((len(or_cases) == 1) and child.condition.is_symbol))
operands = (child.condition.operands if (len(or_cases) > 1) else [child.condition])
assert ({task.syntax_tree.condition_map[op] for op in operands} == {Condition(OperationType.equal, [switch_variable, Constant(c, Integer(32))]) for c in or_cases})
assert (isinstance(child.true_branch_child, CodeNode) and (child.true_branch_child.instructions == vertices[(const + 4)].instructions))
assert (isinstance(fallthrough.children[(- 1)], CodeNode) and (fallthrough.children[(- 1)].instructions == vertices[(constants[(- 1)] + 4)].instructions))
current_cond = current_cond.false_branch_child
assert (isinstance(current_cond, CodeNode) and (current_cond.instructions == vertices[1].instructions)) |
def upgrade():
op.drop_index(op.f('ix_session_data'), table_name='session')
op.execute('ALTER TABLE session ALTER COLUMN data TYPE JSON USING data::JSON;')
op.drop_index(op.f('ix_config_config'), table_name='config')
op.execute('ALTER TABLE config ALTER COLUMN config TYPE JSON USING config::JSON;') |
.skipif((yaml is None), reason='needs yaml')
def test_yaml_file_handler(tmpdir, testconfig):
yaml_file = tmpdir.join('config.yaml')
yaml_file.write('\ndevelopment:\n DATABASE_URI: mysql://root:/posts\n\nproduction:\n DATABASE_URI: mysql://poor_user:poor_/poor_posts\n')
config = kaptan.Kaptan(handler='yaml')
config.import_config(str(yaml_file))
assert (config.get('production.DATABASE_URI') == 'mysql://poor_user:poor_/poor_posts') |
def update_or_create_camera_trace(patched_figure, trace_idx, cam_coords, wireframe_scale=0.5, linewidth=3, color='red', name='Camera'):
(x, y, z) = (cam_coords['x'], cam_coords['y'], cam_coords['z'])
if (trace_idx is None):
patched_figure['data'].append(go.Scatter3d(x=x, y=y, z=z, mode='lines', marker={'size': 1, 'color': color}, line=dict(width=linewidth, color=color), name=name))
else:
patched_figure['data'][trace_idx]['x'] = x
patched_figure['data'][trace_idx]['y'] = y
patched_figure['data'][trace_idx]['z'] = z |
(autouse=True)
def no_cert_in_test(monkeypatch):
class MockESConfig(EvaluatorServerConfig):
def __init__(self, *args, **kwargs):
if ('use_token' not in kwargs):
kwargs['use_token'] = False
if ('generate_cert' not in kwargs):
kwargs['generate_cert'] = False
super().__init__(*args, **kwargs)
monkeypatch.setattr('ert.cli.main.EvaluatorServerConfig', MockESConfig) |
class OptionPlotoptionsColumnpyramidSonificationDefaultinstrumentoptionsMappingLowpass(Options):
def frequency(self) -> 'OptionPlotoptionsColumnpyramidSonificationDefaultinstrumentoptionsMappingLowpassFrequency':
return self._config_sub_data('frequency', OptionPlotoptionsColumnpyramidSonificationDefaultinstrumentoptionsMappingLowpassFrequency)
def resonance(self) -> 'OptionPlotoptionsColumnpyramidSonificationDefaultinstrumentoptionsMappingLowpassResonance':
return self._config_sub_data('resonance', OptionPlotoptionsColumnpyramidSonificationDefaultinstrumentoptionsMappingLowpassResonance) |
class OptionSeriesPictorialStatesHoverMarker(Options):
def enabled(self):
return self._config_get(None)
def enabled(self, flag: bool):
self._config(flag, js_type=False)
def enabledThreshold(self):
return self._config_get(2)
def enabledThreshold(self, num: float):
self._config(num, js_type=False)
def fillColor(self):
return self._config_get(None)
def fillColor(self, text: str):
self._config(text, js_type=False)
def height(self):
return self._config_get(None)
def height(self, num: float):
self._config(num, js_type=False)
def lineColor(self):
return self._config_get('#ffffff')
def lineColor(self, text: str):
self._config(text, js_type=False)
def lineWidth(self):
return self._config_get(0)
def lineWidth(self, num: float):
self._config(num, js_type=False)
def radius(self):
return self._config_get(4)
def radius(self, num: float):
self._config(num, js_type=False)
def width(self):
return self._config_get(None)
def width(self, num: float):
self._config(num, js_type=False) |
def _get_alembic_config(url):
from alembic.config import Config
current_dir = os.path.dirname(os.path.abspath(__file__))
package_dir = os.path.normpath(os.path.join(current_dir, '..'))
directory = os.path.join(package_dir, 'migrations')
config = Config(os.path.join(package_dir, 'alembic.ini'))
config.set_main_option('script_location', directory.replace('%', '%%'))
config.set_main_option('sqlalchemy.url', url.replace('%', '%%'))
return config |
def create_ref_node(link_type, uri, text, tooltip):
innernode = nodes.inline(text, text)
if (link_type == 'ref'):
ref_node = addnodes.pending_xref(reftarget=unquote(uri), reftype='any', refdomain='', refexplicit=True, refwarn=True)
innernode['classes'] = ['xref', 'any']
else:
ref_node = nodes.reference()
ref_node['refuri'] = uri
if tooltip:
ref_node['reftitle'] = tooltip
ref_node += innernode
return ref_node |
class Migration(migrations.Migration):
dependencies = [('gather', '0002_auto__1301')]
operations = [migrations.AlterField(model_name='event', name='attendees', field=models.ManyToManyField(related_name='events_attending', to=settings.AUTH_USER_MODEL, blank=True)), migrations.AlterField(model_name='event', name='endorsements', field=models.ManyToManyField(related_name='events_endorsed', to=settings.AUTH_USER_MODEL, blank=True)), migrations.AlterField(model_name='event', name='organizers', field=models.ManyToManyField(related_name='events_organized', to=settings.AUTH_USER_MODEL, blank=True))] |
_type(OSPF_MSG_LS_UPD)
class OSPFLSUpd(OSPFMessage):
_PACK_STR = '!I'
_PACK_LEN = struct.calcsize(_PACK_STR)
_MIN_LEN = (OSPFMessage._HDR_LEN + _PACK_LEN)
def __init__(self, length=None, router_id='0.0.0.0', area_id='0.0.0.0', au_type=1, authentication=0, checksum=None, version=_VERSION, lsas=None):
lsas = (lsas if lsas else [])
super(OSPFLSUpd, self).__init__(OSPF_MSG_LS_UPD, length, router_id, area_id, au_type, authentication, checksum, version)
self.lsas = lsas
def parser(cls, buf):
binnum = buf[:cls._PACK_LEN]
(num,) = struct.unpack_from(cls._PACK_STR, six.binary_type(binnum))
buf = buf[cls._PACK_LEN:]
lsas = []
while buf:
(lsa, _cls, buf) = LSA.parser(buf)
lsas.append(lsa)
assert (len(lsas) == num)
return {'lsas': lsas}
def serialize_tail(self):
head = bytearray(struct.pack(self._PACK_STR, len(self.lsas)))
try:
return (head + reduce((lambda a, b: (a + b)), (lsa.serialize() for lsa in self.lsas)))
except TypeError:
return head |
class PDFGraphicState():
def __init__(self):
self.linewidth = 0
self.linecap = None
self.linejoin = None
self.miterlimit = None
self.dash = None
self.intent = None
self.flatness = None
return
def copy(self):
obj = PDFGraphicState()
obj.linewidth = self.linewidth
obj.linecap = self.linecap
obj.linejoin = self.linejoin
obj.miterlimit = self.miterlimit
obj.dash = self.dash
obj.intent = self.intent
obj.flatness = self.flatness
return obj
def __repr__(self):
return ('<PDFGraphicState: linewidth=%r, linecap=%r, linejoin=%r, miterlimit=%r, dash=%r, intent=%r, flatness=%r>' % (self.linewidth, self.linecap, self.linejoin, self.miterlimit, self.dash, self.intent, self.flatness)) |
class FeistelRFirstRounds():
def __new__(cls, guesses=_np.arange(64, dtype='uint8'), words=None, plaintext_tag='plaintext', key_tag='key'):
return _decorated_selection_function(_AttackSelectionFunctionWrapped, _first_round, expected_key_function=_first_key, words=words, guesses=guesses, target_tag=plaintext_tag, key_tag=key_tag) |
def bindingQQ(request):
if (request.method == 'POST'):
openid = request.POST.get('openid')
figureurl_qq_1 = request.POST.get('figureurl_qq_1')
nickname = request.POST.get('nickname')
password = request.POST.get('password')
password1 = request.POST.get('password1')
email = request.POST.get('email')
if (password != password1):
return render(request, 'pc/qqregister.html', {'openid': openid, 'figureurl_qq_1': figureurl_qq_1, 'nickname': nickname, 'error': ''})
else:
User.objects.filter(email=email).exists()
if User.objects.filter(email=email).exists():
return render(request, 'pc/qqregister.html', {'openid': openid, 'figureurl_qq_1': figureurl_qq_1, 'nickname': nickname, 'error': ''})
else:
user = User()
user.username = nickname
user.email = email
user.user_image = figureurl_qq_1
user.is_staff = False
user.is_superuser = False
user.is_active = True
user.password = make_password(password1)
user.save()
qq = OAuthQQ()
user_id = get_object_or_404(User, email=email).id
qq.user_id = user_id
msg = UserMessage()
msg.user_id = user_id
msg.to_user = User.objects.get(is_superuser=True)
msg.message = ',,,Email: <a target="_blank" href=" style="text-decoration:none;"></a>'
msg.has_read = False
msg.is_supper = True
msg.save()
qq.qq_openid = openid
qq.nickname = nickname
qq.figureurl_qq = figureurl_qq_1
qq.save()
user = authenticate(request, username=email, password=password)
login(request, user)
return HttpResponseRedirect(reverse('home')) |
def _dbt_run_through_python(args: List[str], target_path: str, run_index: int, connection: Connection):
warnings.filterwarnings('ignore', category=DeprecationWarning, module='logbook')
from dbt.cli.main import dbtRunner
from dbt.contracts.results import RunExecutionResult
runner = dbtRunner()
run_results: Optional[RunExecutionResult] = None
exc = None
try:
runner_run_results = runner.invoke(args)
run_results = runner_run_results.result
except BaseException as _exc:
return_code = getattr(_exc, 'code', 1)
exc = _exc
else:
return_code = (0 if runner_run_results.success else 1)
LOGGER.debug(f'dbt exited with return code {return_code}')
if (run_results is not None):
run_results_path = os.path.join(target_path, f'fal_results_{run_index}.json')
run_results.write(run_results_path)
else:
connection.send(exc)
return
connection.send(return_code) |
class OptionPlotoptionsSolidgaugeSonificationContexttracksMappingTremolo(Options):
def depth(self) -> 'OptionPlotoptionsSolidgaugeSonificationContexttracksMappingTremoloDepth':
return self._config_sub_data('depth', OptionPlotoptionsSolidgaugeSonificationContexttracksMappingTremoloDepth)
def speed(self) -> 'OptionPlotoptionsSolidgaugeSonificationContexttracksMappingTremoloSpeed':
return self._config_sub_data('speed', OptionPlotoptionsSolidgaugeSonificationContexttracksMappingTremoloSpeed) |
def generate(annotations_path, output_path, log_step=5000, force_uppercase=True, save_filename=False):
logging.info('Building a dataset from %s.', annotations_path)
logging.info('Output file: %s', output_path)
writer = tf.io.TFRecordWriter(output_path)
longest_label = ''
idx = 0
with open(annotations_path, 'r') as annotations:
for (idx, line) in enumerate(annotations):
line = line.rstrip('\n')
line_match = re.match('(\\S+)\\s(.*)', line)
if (line_match is None):
logging.error('missing filename or label, ignoring line %i: %s', (idx + 1), line)
continue
(img_path, label) = line_match.groups()
with open(img_path, 'rb') as img_file:
img = img_file.read()
if force_uppercase:
label = label.upper()
if (len(label) > len(longest_label)):
longest_label = label
feature = {}
feature['image'] = _bytes_feature(img)
feature['label'] = _bytes_feature(b(label))
if save_filename:
feature['comment'] = _bytes_feature(b(img_path))
example = tf.train.Example(features=tf.train.Features(feature=feature))
writer.write(example.SerializeToString())
if ((idx % log_step) == 0):
logging.info('Processed %s pairs.', (idx + 1))
if idx:
logging.info('Dataset is ready: %i pairs.', (idx + 1))
logging.info('Longest label (%i): %s', len(longest_label), longest_label)
writer.close() |
class OptionSeriesPyramid3dDataDragdrop(Options):
def draggableX(self):
return self._config_get(None)
def draggableX(self, flag: bool):
self._config(flag, js_type=False)
def draggableY(self):
return self._config_get(None)
def draggableY(self, flag: bool):
self._config(flag, js_type=False)
def dragHandle(self) -> 'OptionSeriesPyramid3dDataDragdropDraghandle':
return self._config_sub_data('dragHandle', OptionSeriesPyramid3dDataDragdropDraghandle)
def dragMaxX(self):
return self._config_get(None)
def dragMaxX(self, num: float):
self._config(num, js_type=False)
def dragMaxY(self):
return self._config_get(None)
def dragMaxY(self, num: float):
self._config(num, js_type=False)
def dragMinX(self):
return self._config_get(None)
def dragMinX(self, num: float):
self._config(num, js_type=False)
def dragMinY(self):
return self._config_get(None)
def dragMinY(self, num: float):
self._config(num, js_type=False)
def dragPrecisionX(self):
return self._config_get(0)
def dragPrecisionX(self, num: float):
self._config(num, js_type=False)
def dragPrecisionY(self):
return self._config_get(0)
def dragPrecisionY(self, num: float):
self._config(num, js_type=False)
def dragSensitivity(self):
return self._config_get(2)
def dragSensitivity(self, num: float):
self._config(num, js_type=False)
def groupBy(self):
return self._config_get(None)
def groupBy(self, text: str):
self._config(text, js_type=False)
def guideBox(self) -> 'OptionSeriesPyramid3dDataDragdropGuidebox':
return self._config_sub_data('guideBox', OptionSeriesPyramid3dDataDragdropGuidebox)
def liveRedraw(self):
return self._config_get(True)
def liveRedraw(self, flag: bool):
self._config(flag, js_type=False) |
def test_trace(filename, get_datetime, print_commands=False):
with open(filename) as trace_file:
sequence = parse_trace(trace_file, get_datetime)
errors = {'crash': 0, 'clash': 0}
counter = 0
start = time.time()
for (command, out) in sequence:
counter += 1
if print_commands:
print(command)
(status, stdout, stderr) = run_command(command)
passed = True
try:
assert (status == 0)
assert (stderr == '')
except AssertionError:
print('[cRash] >', command)
print(('[stderr]:\n' + stderr))
errors['crash'] += 1
passed = False
try:
assert (out == stdout)
except AssertionError:
print('[cLash]', command)
print(('[output]:\n' + stdout))
print(('[expected]:\n' + out))
errors['clash'] += 1
passed = False
if passed:
print('.', end='')
sys.stdout.flush()
total = (time.time() - start)
print('\nRan {} commands in {:.3} seconds'.format(counter, total))
return errors |
def update_request_body_for_consent_served_or_saved(db: Session, verified_provided_identity: Optional[ProvidedIdentity], fides_user_provided_identity: Optional[ProvidedIdentity], request: Request, original_request_data: Union[(PrivacyPreferencesRequest, RecordConsentServedRequest)], resource_type: Union[(Type[PrivacyPreferencesCreate], Type[RecordConsentServedCreate])]) -> Dict[(str, Union[(Optional[RequestOrigin], Optional[str])])]:
request_data: Union[(PrivacyPreferencesCreate, RecordConsentServedCreate)] = _supplement_request_data_from_request_headers(db, request, original_request_data, resource_type=resource_type)
(email, hashed_email) = extract_identity_from_provided_identity(verified_provided_identity, ProvidedIdentityType.email)
(phone_number, hashed_phone_number) = extract_identity_from_provided_identity(verified_provided_identity, ProvidedIdentityType.phone_number)
(fides_user_device_id, hashed_device_id) = extract_identity_from_provided_identity(fides_user_provided_identity, ProvidedIdentityType.fides_user_device_id)
return {'anonymized_ip_address': request_data.anonymized_ip_address, 'email': email, 'privacy_experience_config_history_id': (request_data.experience_config_history_id if request_data.experience_config_history_id else None), 'privacy_experience_id': (request_data.privacy_experience_id if request_data.privacy_experience_id else None), 'fides_user_device': fides_user_device_id, 'fides_user_device_provided_identity_id': (fides_user_provided_identity.id if fides_user_provided_identity else None), 'hashed_email': hashed_email, 'hashed_fides_user_device': hashed_device_id, 'hashed_phone_number': hashed_phone_number, 'phone_number': phone_number, 'provided_identity_id': (verified_provided_identity.id if verified_provided_identity else None), 'request_origin': request_data.request_origin, 'user_agent': request_data.user_agent, 'user_geography': request_data.user_geography, 'url_recorded': request_data.url_recorded} |
('ClippedLinear.v1')
def ClippedLinear(nO: Optional[int]=None, nI: Optional[int]=None, *, init_W: Optional[Callable]=None, init_b: Optional[Callable]=None, dropout: Optional[float]=None, normalize: bool=False, slope: float=1.0, offset: float=0.0, min_val: float=0.0, max_val: float=1.0) -> Model[(Floats2d, Floats2d)]:
if (init_W is None):
init_W = glorot_uniform_init
if (init_b is None):
init_b = zero_init
model_attrs = {'slope': slope, 'offset': offset, 'min_val': min_val, 'max_val': max_val}
model: Model[(Floats2d, Floats2d)] = Model('clipped_linear', forward=forward, init=partial(init, init_W, init_b), dims={'nO': nO, 'nI': nI}, params={'W': None, 'b': None}, attrs=model_attrs)
if normalize:
model = chain(model, LayerNorm(nI=nO))
if (dropout is not None):
model = chain(model, cast(Model[(Floats2d, Floats2d)], Dropout(dropout)))
return model |
class Link(Sized):
def to_json(self) -> str:
encoder = JSONEncoder(sort_keys=True)
return encoder.encode(self)
def __len__(self) -> int:
return self.size
def displace(self, q: float) -> npt.NDArray[np.float64]:
raise NotImplementedError
def transform(self, q: float=0) -> npt.NDArray[np.float64]:
raise NotImplementedError
def vector(self) -> npt.NDArray[np.float64]:
raise NotImplementedError
def size(self) -> int:
raise NotImplementedError |
('fides.api.service.masking.strategy.masking_strategy_aes_encrypt.encrypt')
def test_mask_gcm_happypath(mock_encrypt: Mock):
mock_encrypt.return_value = 'encrypted'
cache_secrets()
masked_value = AES_STRATEGY.mask(['value'], request_id)[0]
mock_encrypt.assert_called_with('value', b'y\xc5I\xd4\x92\xf6G\t\x80\xb1$\x06\x19t/\xc4', b'\x94Y\xa8Z\xd9\x12\x83\x00\xa4~\ny')
assert (masked_value == mock_encrypt.return_value)
clear_cache_secrets(request_id) |
def test_ttlist_woff(capsys, tmpdir):
inpath = os.path.join('Tests', 'ttx', 'data', 'TestWOFF.woff')
fakeoutpath = tmpdir.join('TestWOFF.ttx')
options = ttx.Options([], 1)
options.listTables = True
options.flavor = 'woff'
ttx.ttList(inpath, str(fakeoutpath), options)
(out, err) = capsys.readouterr()
expected_tables = ('head', 'hhea', 'maxp', 'OS/2', 'name', 'cmap', 'post', 'CFF ', 'hmtx', 'DSIG')
for table in expected_tables:
assert (table in out)
assert ('OS/2 0x67230FF8 84 340' in out) |
def test_score_diff_from_transaction():
good_holdings = {'good_id': 2}
currency_holdings = {'FET': 100}
utility_params = {'good_id': 20.0}
exchange_params = {'FET': 10.0}
ownership_state = OwnershipState()
ownership_state.set(amount_by_currency_id=currency_holdings, quantities_by_good_id=good_holdings)
preferences = Preferences()
preferences.set(utility_params_by_good_id=utility_params, exchange_params_by_currency_id=exchange_params)
terms = Terms(ledger_id=EthereumCrypto.identifier, sender_address='agent_1', counterparty_address='pk', amount_by_currency_id={'FET': (- 20)}, is_sender_payable_tx_fee=True, quantities_by_good_id={'good_id': 10}, nonce='transaction nonce')
cur_score = preferences.utility(quantities_by_good_id=good_holdings, amount_by_currency_id=currency_holdings)
new_state = ownership_state.apply_transactions([terms])
new_score = preferences.utility(quantities_by_good_id=new_state.quantities_by_good_id, amount_by_currency_id=new_state.amount_by_currency_id)
diff_scores = (new_score - cur_score)
score_difference = preferences.utility_diff_from_transaction(ownership_state=ownership_state, terms=terms)
assert (score_difference == diff_scores), 'The calculated difference must be equal to the return difference from the function.'
assert (not preferences.is_utility_enhancing(ownership_state=ownership_state, terms=terms)), 'Should not enhance utility.' |
class OptionYaxisLabels(Options):
def align(self):
return self._config_get(None)
def align(self, text: str):
self._config(text, js_type=False)
def allowOverlap(self):
return self._config_get(False)
def allowOverlap(self, flag: bool):
self._config(flag, js_type=False)
def autoRotation(self):
return self._config_get('undefined')
def autoRotation(self, value: Any):
self._config(value, js_type=False)
def autoRotationLimit(self):
return self._config_get(80)
def autoRotationLimit(self, num: float):
self._config(num, js_type=False)
def distance(self):
return self._config_get(15)
def distance(self, num: float):
self._config(num, js_type=False)
def enabled(self):
return self._config_get(True)
def enabled(self, flag: bool):
self._config(flag, js_type=False)
def format(self):
return self._config_get(None)
def format(self, text: str):
self._config(text, js_type=False)
def formatter(self):
return self._config_get(None)
def formatter(self, value: Any):
self._config(value, js_type=False)
def maxStaggerLines(self):
return self._config_get(5)
def maxStaggerLines(self, num: float):
self._config(num, js_type=False)
def overflow(self):
return self._config_get('justify')
def overflow(self, text: str):
self._config(text, js_type=False)
def padding(self):
return self._config_get(5)
def padding(self, num: float):
self._config(num, js_type=False)
def position3d(self):
return self._config_get('offset')
.setter
def position3d(self, text: str):
self._config(text, js_type=False)
def reserveSpace(self):
return self._config_get(None)
def reserveSpace(self, flag: bool):
self._config(flag, js_type=False)
def rotation(self):
return self._config_get(0)
def rotation(self, num: float):
self._config(num, js_type=False)
def skew3d(self):
return self._config_get(False)
.setter
def skew3d(self, flag: bool):
self._config(flag, js_type=False)
def staggerLines(self):
return self._config_get(0)
def staggerLines(self, num: float):
self._config(num, js_type=False)
def step(self):
return self._config_get(0)
def step(self, num: float):
self._config(num, js_type=False)
def style(self) -> 'OptionYaxisLabelsStyle':
return self._config_sub_data('style', OptionYaxisLabelsStyle)
def useHTML(self):
return self._config_get(False)
def useHTML(self, flag: bool):
self._config(flag, js_type=False)
def x(self):
return self._config_get('undefined')
def x(self, num: float):
self._config(num, js_type=False)
def y(self):
return self._config_get(3)
def y(self, num: float):
self._config(num, js_type=False)
def zIndex(self):
return self._config_get(7)
def zIndex(self, num: float):
self._config(num, js_type=False) |
def _validate_and_bolster_requested_submission_window(fy: int, quarter: Optional[int], period: Optional[int]) -> (int, Optional[int], Optional[int]):
if ((quarter is None) and (period is None)):
raise InvalidParameterException("Either 'period' or 'quarter' is required in filters.")
if ((quarter is not None) and (period is not None)):
raise InvalidParameterException("Supply either 'period' or 'quarter' in filters but not both.")
if (period is not None):
quarter = sub_helpers.get_last_closed_quarter_relative_to_month(fy, period)
else:
period = sub_helpers.get_last_closed_month_relative_to_quarter(fy, quarter)
return (fy, quarter, period) |
class Login(MethodView):
def post(self):
user_api = UserTable()
data = request.get_data()
data = json.loads(data.decode('UTF-8'))
username = data.get('username')
password = data.get('password')
if (not re_user.search(username)):
ret = {'code': 401, 'message': ''}
return jsonify(ret)
(check_result, msg) = user_api.verify_user(username, password)
log.info('user', f'{username} ip:{request.remote_addr}')
if check_result:
ret = {'code': 200, 'data': {'token': create_token({'username': username}), 'username': username}}
log.info('user', f'{username} ip:{request.remote_addr}')
else:
ret = {'code': 401, 'message': msg}
log.info('user', f"{username} :'{msg}' ip:{request.remote_addr}")
return jsonify(ret)
def get(self):
return render_template('index.html') |
def test_schema_overrides_hydra(monkeypatch: Any, tmpdir: Path) -> None:
monkeypatch.chdir('tests/test_apps/schema_overrides_hydra')
cmd = ['my_app.py', ('hydra.run.dir=' + str(tmpdir)), 'hydra.job.chdir=True']
(result, _err) = run_python_script(cmd)
assert (result == 'job_name: test, name: James Bond, age: 7, group: a') |
def main():
try:
log_level = getattr(rospy, rospy.get_param(('/%s/log_level' % PROCESS_NAME), 'INFO'))
except Exception as e:
print(('Error while set the log level: %s\n->INFO level will be used!' % e))
log_level = rospy.INFO
rospy.init_node(PROCESS_NAME, log_level=log_level)
set_terminal_name(PROCESS_NAME)
set_process_name(PROCESS_NAME)
discoverer = master_sync.Main()
if (not rospy.is_shutdown()):
rospy.spin() |
.django_db
def test_federal_account_list_success(client, monkeypatch, bureau_data, helpers):
helpers.mock_current_fiscal_year(monkeypatch)
resp = client.get(url.format(toptier_code='001', bureau_slug='test-bureau-1', query_params=f'?fiscal_year={helpers.get_mocked_current_fiscal_year()}'))
expected_result = {'fiscal_year': helpers.get_mocked_current_fiscal_year(), 'toptier_code': '001', 'bureau_slug': 'test-bureau-1', 'totals': {'total_obligations': 1.0, 'total_outlays': 10.0, 'total_budgetary_resources': 100.0}, 'messages': [], 'page_metadata': {'hasNext': False, 'hasPrevious': False, 'next': None, 'page': 1, 'previous': None, 'total': 1, 'limit': 10}, 'results': [{'name': 'FA 1', 'id': '001-0000', 'total_obligations': 1.0, 'total_outlays': 10.0, 'total_budgetary_resources': 100.0}]}
assert (resp.status_code == status.HTTP_200_OK)
assert (resp.json() == expected_result) |
.parametrize('log_base, exp_age, exp_marks, learned_c', _params_test_automatic_find_variables)
def test_param_C_is_dict_user(log_base, exp_age, exp_marks, learned_c, df_vartypes):
transformer = LogCpTransformer(base=log_base, C={'Age': 19.0})
X = transformer.fit_transform(df_vartypes)
transf_df = df_vartypes.copy()
transf_df['Age'] = exp_age
assert (transformer.base == log_base)
assert (transformer.variables is None)
assert (transformer.C == {'Age': 19.0})
assert (transformer.variables_ == ['Age'])
assert (transformer.n_features_in_ == 5)
assert (transformer.C_ == {'Age': learned_c['Age']})
pd.testing.assert_frame_equal(X, transf_df)
Xit = transformer.inverse_transform(X)
Xit['Age'] = Xit['Age'].round().astype('int64')
Xit['Marks'] = Xit['Marks'].round(1)
pd.testing.assert_frame_equal(Xit, df_vartypes) |
def tts(model, text):
if use_cuda:
model = model.cuda()
model.encoder.eval()
model.postnet.eval()
sequence = np.array(text)
sequence = Variable(torch.from_numpy(sequence)).unsqueeze(0)
if use_cuda:
sequence = sequence.cuda()
(mel_outputs, linear_outputs, alignments) = model(sequence)
linear_output = linear_outputs[0].cpu().data.numpy()
spectrogram = audio.denormalize(linear_output)
alignment = alignments[0].cpu().data.numpy()
waveform = audio.inv_spectrogram(linear_output.T)
return (waveform, alignment, spectrogram) |
def test_get_contributors_ranking_mbm_change_report():
contributor_field = 'Contributor'
commits_amount_field = 'Commits'
(jan, feb, dec) = (datetime(year=2020, month=1, day=1), datetime(year=2020, month=2, day=1), datetime(year=2020, month=12, day=1))
reports = [(jan, pd.DataFrame([{contributor_field: 'User1', commits_amount_field: 3}, {contributor_field: 'User2', commits_amount_field: 4}])), (feb, pd.DataFrame([{contributor_field: 'User2', commits_amount_field: 1}, {contributor_field: 'User3', commits_amount_field: 2}])), (dec, pd.DataFrame([{contributor_field: 'User1', commits_amount_field: 3}, {contributor_field: 'User3', commits_amount_field: 1}, {contributor_field: 'User4', commits_amount_field: 1}]))]
reference = pd.DataFrame([{contributor_field: 'User1', jan.strftime('%b'): 3, feb.strftime('%b'): 0, dec.strftime('%b'): 3, 'Total': 6}, {contributor_field: 'User2', jan.strftime('%b'): 4, feb.strftime('%b'): 1, dec.strftime('%b'): 0, 'Total': 5}, {contributor_field: 'User3', jan.strftime('%b'): 0, feb.strftime('%b'): 2, dec.strftime('%b'): 1, 'Total': 3}, {contributor_field: 'User4', jan.strftime('%b'): 0, feb.strftime('%b'): 0, dec.strftime('%b'): 1, 'Total': 1}])
df = get_contributors_ranking_mbm_change_report(reports, contributor_field=contributor_field, commits_amount_field=commits_amount_field)
pd.testing.assert_frame_equal(reference, df) |
def normalise_font(font, padding=4):
DSIG_copy = copy.deepcopy(font['DSIG'])
del font['DSIG']
origFlavor = font.flavor
origRecalcBBoxes = font.recalcBBoxes
origRecalcTimestamp = font.recalcTimestamp
origLazy = font.lazy
font.flavor = None
font.recalcBBoxes = False
font.recalcTimestamp = False
font.lazy = True
infile = BytesIO()
font.save(infile)
infile.seek(0)
outfile = BytesIO()
reader = ttLib.sfnt.SFNTReader(infile)
writer = ttLib.sfnt.SFNTWriter(outfile, len(reader.tables), reader.sfntVersion, reader.flavor, reader.flavorData)
for tag in sorted(reader.keys()):
if (tag in (woff2TransformedTableTags + ('head',))):
writer[tag] = normalise_table(font, tag, padding)
else:
writer[tag] = reader[tag]
writer.close()
font['DSIG'] = DSIG_copy
font.flavor = origFlavor
font.recalcBBoxes = origRecalcBBoxes
font.recalcTimestamp = origRecalcTimestamp
font.lazy = origLazy
return outfile.getvalue() |
def test_remove_option(bus, config, mocker, tmpdir):
tmp_path = tmpdir.mkdir('tmp').join('tomate.config')
config.config_path = (lambda : tmp_path.strpath)
config.set('section', 'option', 'value')
subscriber = mocker.Mock()
bus.connect(Events.CONFIG_CHANGE, subscriber, weak=False)
config.remove('section', 'option')
config.load()
assert (config.parser.has_option('section', 'option') is False)
payload = ConfigPayload('remove', 'section', 'option', '')
subscriber.assert_called_once_with(Events.CONFIG_CHANGE, payload=payload) |
def _get_available_ram_linux() -> int:
with open('/proc/meminfo') as f:
for line in f:
try:
(key, value) = line.split(':', 1)
except ValueError:
continue
suffix = ' kB\n'
if ((key == 'MemAvailable') and value.endswith(suffix)):
value = value[:(- len(suffix))]
try:
return (int(value) // 1024)
except ValueError:
continue
raise NotImplementedError('/proc/meminfo had no valid MemAvailable') |
def main():
data = load_iris()
X = normalize(data['data'])
y = data['target']
y = np.zeros((data['target'].shape[0], 3))
y[(np.arange(data['target'].shape[0]).astype('int'), data['target'].astype('int'))] = 1
(X_train, X_test, y_train, y_test) = train_test_split(X, y, test_size=0.33)
clf = MLP()
clf.fit(X_train, y_train, n_epochs=1000, lr=0.01, n_units=16)
y_pred = np.argmax(clf.predict(X_test), axis=1)
y_test = np.argmax(y_test, axis=1)
accuracy = np.mean((y_pred == y_test))
y = np.argmax(y, axis=1)
print('Accuracy:', accuracy)
Plot().plot_in_2d(X, y, title='Multilayer Perceptron', accuracy=accuracy, legend_labels=data['target_names']) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.