def test_dead_default():
'''
You may now omit a transition, or even an entire state, from the map. This
affects every usage of `fsm.map`.
'''
blockquote = fsm(
alphabet = {"/", "*", anything_else},
states = {0, 1, 2, 3, 4, 5},
initial = 0,
finals = {4},
map = {
0 : {"/" : 1},
1 : {"*" : 2},
2 : {"/" : 2, anything_else : 2, "*" : 3},
3 : {"/" : 4, anything_else : 2, "*" : 3},
}
)
assert blockquote.accepts(["/", "*", "whatever", "*", "/"])
assert not blockquote.accepts(["*", "*", "whatever", "*", "/"])
str(blockquote) # test stringification
blockquote | blockquote
blockquote & blockquote
blockquote ^ blockquote
reversed(blockquote)
assert not blockquote.everythingbut().accepts(["/", "*", "whatever", "*", "/"])
assert blockquote.everythingbut().accepts(["*"]) # deliberately seek oblivion
assert blockquote.islive(3)
assert blockquote.islive(4)
assert not blockquote.islive(5)
gen = blockquote.strings()
assert next(gen) == ["/", "*", "*", "/"]
def backward_pass(self, accum_grad):
_, timesteps, _ = accum_grad.shape
# Variables where we save the accumulated gradient w.r.t each parameter
grad_U = np.zeros_like(self.U)
grad_V = np.zeros_like(self.V)
grad_W = np.zeros_like(self.W)
# The gradient w.r.t the layer input.
# Will be passed on to the previous layer in the network
accum_grad_next = np.zeros_like(accum_grad)
# Back Propagation Through Time
for t in reversed(range(timesteps)):
# Update gradient w.r.t V at time step t
grad_V += accum_grad[:, t].T.dot(self.states[:, t])
# Calculate the gradient w.r.t the state input
grad_wrt_state = accum_grad[:, t].dot(self.V) * self.activation.gradient(self.state_input[:, t])
# Gradient w.r.t the layer input
accum_grad_next[:, t] = grad_wrt_state.dot(self.U)
# Update gradient w.r.t W and U by backprop. from time step t for at most
# self.bptt_trunc number of time steps
for t_ in reversed(np.arange(max(0, t - self.bptt_trunc), t+1)):
grad_U += grad_wrt_state.T.dot(self.layer_input[:, t_])
grad_W += grad_wrt_state.T.dot(self.states[:, t_-1])
# Calculate gradient w.r.t previous state
grad_wrt_state = grad_wrt_state.dot(self.W) * self.activation.gradient(self.state_input[:, t_-1])
# Update weights
self.U = self.U_opt.update(self.U, grad_U)
self.V = self.V_opt.update(self.V, grad_V)
self.W = self.W_opt.update(self.W, grad_W)
return accum_grad_next
def test_create_changes_overridden_project(self):
def custom_split_file(path):
f = split_file(path)
if f:
f["project"] = "overridden-project"
f["repository"] = "overridden-repository"
f["codebase"] = "overridden-codebase"
return f
base = ("file:///home/warner/stuff/Projects/Buildbot/trees/" +
"svnpoller/_trial_temp/test_vc/repositories/SVN-Repository/sample")
s = self.attachSVNPoller(base, split_file=custom_split_file)
s._prefix = "sample"
logentries = dict(
zip(range(1, 7), reversed(make_logentry_elements(6))))
changes = s.create_changes(reversed([logentries[3], logentries[2]]))
self.assertEqual(len(changes), 2)
# note that parsing occurs in reverse
self.assertEqual(changes[0]['branch'], "branch")
self.assertEqual(changes[0]['revision'], '2')
self.assertEqual(changes[0]['project'], "overridden-project")
self.assertEqual(changes[0]['repository'], "overridden-repository")
self.assertEqual(changes[0]['codebase'], "overridden-codebase")
self.assertEqual(changes[1]['branch'], "branch")
self.assertEqual(changes[1]['files'], [u'çmain.c'])
self.assertEqual(changes[1]['revision'], '3')
self.assertEqual(changes[1]['project'], "overridden-project")
self.assertEqual(changes[1]['repository'], "overridden-repository")
self.assertEqual(changes[1]['codebase'], "overridden-codebase")
def reference_number(data):
chk = -sum(int(x) * [7, 3, 1][i % 3]
for i, x in enumerate(data[::-1])) % 10
ref = '%s%d' % (data, chk)
return ' '.join(
reversed(
[''.join(reversed(x)) for x in grouper(5, reversed(ref), '')]))
def wrap(f):
@wraps(f)
def inner_f(*args):
val = f(*args)
if nullable and val == ffi.NULL:
return None
elif returns_string:
return ffi.string(val)
return val
# this insanity inserts a formatted argspec string
# into the function's docstring, so that sphinx
# gets the right args instead of just the wrapper args
args, varargs, varkw, defaults = inspect.getargspec(f)
defaults = () if defaults is None else defaults
defaults = ["\"{}\"".format(a) if type(a) == str else a for a in defaults]
l = ["{}={}".format(arg, defaults[(idx+1)*-1])
if len(defaults)-1 >= idx else
arg for idx, arg in enumerate(reversed(list(args)))]
if varargs:
l.append('*' + varargs)
if varkw:
l.append('**' + varkw)
doc = "{}({})\n\nC: ``{}``\n\n{}".format(f.__name__, ', '.join(reversed(l)), decl, f.__doc__)
inner_f.__doc__ = doc
return inner_f
def test_reversed_simple_sequences(self):
l = range(5)
rev = reversed(l)
assert list(rev) == [4, 3, 2, 1, 0]
assert list(l.__reversed__()) == [4, 3, 2, 1, 0]
s = "abcd"
assert list(reversed(s)) == ['d', 'c', 'b', 'a']
def validate_anyOf(self, *args, **kwargs):
for error in super(SchemaValidator, self).validate_anyOf(*args, **kwargs):
# Split the suberrors up by which subschema they are from
subschema_errors = defaultdict(list)
for sube in error.context:
subschema_errors[sube.schema_path[0]].append(sube)
# Find the subschemas that did not have a 'type' error validating the instance at this path
no_type_errors = dict(subschema_errors)
valid_types = set()
for i, errors in subschema_errors.iteritems():
for e in errors:
if e.validator == 'type' and not e.path:
# Remove from the no_type_errors dict
no_type_errors.pop(i, None)
# Add the valid types to the list of all valid types
if self.is_type(e.validator_value, 'string'):
valid_types.add(e.validator_value)
else:
valid_types.update(e.validator_value)
if not no_type_errors:
# If all of the branches had a 'type' error, create our own virtual type error with all possible types
for e in self.descend(error.instance, {'type': valid_types}):
yield e
elif len(no_type_errors) == 1:
# If one of the possible schemas did not have a 'type' error, assume that is the intended one and issue
# all errors from that subschema
for e in no_type_errors.values()[0]:
e.schema_path.extendleft(reversed(error.schema_path))
e.path.extendleft(reversed(error.path))
yield e
else:
yield error
def train(self, inp, out, training_weight=1.):
inp = np.mat(inp).T
out = np.mat(out).T
deriv = []
val = inp
vals = [val]
# forward calculation of activations and derivatives
for weight,bias in self.__weights:
val = weight*val
val += bias
deriv.append(self.__derivative(val))
vals.append(self.__activation(val))
deriv = iter(reversed(deriv))
weights = iter(reversed(self.__weights))
errs = []
errs.append(np.multiply(vals[-1]-out, next(deriv)))
# backwards propagation of errors
for (w,b),d in zip(weights, deriv):
errs.append(np.multiply(np.dot(w.T, errs[-1]), d))
weights = iter(self.__weights)
for (w,b),v,e in zip(\
self.__weights,\
vals, reversed(errs)):
e *= self.__learning_rate*training_weight
w -= e*v.T
b -= e
tmp = vals[-1]-out
return np.dot(tmp[0].T,tmp[0])*.5*training_weight
def _balance_tags(tags):
"""Throw out any close tags without an open tag.
If {@code <table>} is used for formatting, embedded HTML shouldn't be able
to use a mismatched {@code </table>} to break page layout.
Args:
tags: The list of all tags in this text.
Returns:
A string containing zero or more closed tags that close all elements that
are opened in tags but not closed.
"""
open_tags = []
for i, tag in enumerate(tags):
if tag[1] == '/':
index = len(open_tags) - 1
while index >= 0 and open_tags[index] != tag:
index -= 1
if index < 0:
tags[i] = '' # Drop close tag.
else:
tags[i] = ''.join(reversed(open_tags[index:]))
del open_tags[index:]
elif not _HTML5_VOID_ELEMENTS_RE.match(tag):
open_tags.append('</' + tag[1:])
return ''.join(reversed(open_tags))
def test_walk_versions_all_true(self, _migrate_up, _migrate_down):
self.REPOSITORY.latest = 20
self.migration_api.db_version.return_value = self.INIT_VERSION
self._walk_versions(self.engine, snake_walk=True, downgrade=True)
versions = range(self.INIT_VERSION + 1, self.REPOSITORY.latest + 1)
upgraded = []
for v in versions:
upgraded.append(mock.call(self.engine, v, with_data=True))
upgraded.append(mock.call(self.engine, v))
upgraded.extend(
[mock.call(self.engine, v) for v in reversed(versions)]
)
self.assertEqual(upgraded, self._migrate_up.call_args_list)
downgraded_1 = [
mock.call(self.engine, v - 1, with_data=True) for v in versions
]
downgraded_2 = []
for v in reversed(versions):
downgraded_2.append(mock.call(self.engine, v - 1))
downgraded_2.append(mock.call(self.engine, v - 1))
downgraded = downgraded_1 + downgraded_2
self.assertEqual(self._migrate_down.call_args_list, downgraded)
def run(self):
self.correct_octave_errors_by_chunks()
self.remove_extreme_values()
self.correct_jumps()
self.pitch = list(reversed(self.pitch))
self.correct_jumps()
self.pitch = list(reversed(self.pitch))
self.filter_noise_region()
self.correct_oct_error()
self.pitch = list(reversed(self.pitch))
self.correct_oct_error()
self.pitch = list(reversed(self.pitch))
self.correct_octave_errors_by_chunks()
self.filter_chunks_by_energy(chunk_limit=60)
if self.out:
self.data['pitch'] = self.pitch
with open(self.fname[:-5] + "_filtered.json", 'w') as f: json.dump(self.data, f)
return self.pitch
def release_linked(self, event):
"""Called when mousebutton released over the linked list.
Removes items from the first list and adds them to the other
"""
# print self.curselection()
ot = self.otherDropList
#Go backwards so as to not delete wrong item when the list resizes
l = self.curselection()
items = []
varl = []
for d in reversed(l):
# print d,type(d)
items.append( self.get(d) )
varl.append( self.variables[int(d)] )
self.delete(d)
self.variables.pop(int(d))
# print items
y = event.y_root-ot.winfo_rooty()
i = ot.nearest(y)
for item in reversed(items):
if ot.nearest(y) == -1:
ot.insert("end",item,varl.pop())
i = ot.nearest(y)
continue
# print i
bbox = ot.bbox(i)
if bbox==None or bbox[3]/2.0 > y:
ot.insert(i,item,varl.pop())
else:
ot.insert(i+1,item,varl.pop())
i += 1
def show_registers(self):
"""Print the available registers"""
i = -1
print('1D histograms')
print('{: <3} {: ^40} {: ^5} {: ^8} {: ^8}'.\
format('i', 'Title', 'Bin', 'Norm', 'Active'))
print('-' * 79)
for p in reversed(Experiment.plots):
print('{: >3} {: <40} {: >5} {: >5.2e} {: >5}'.\
format(i, p.histogram.title[:40], p.bin_size,
p.norm, p.active))
i -= 1
print()
i = -1
print('2D histograms')
print('{: <3} {: ^40} {: ^5} {: ^8} {: ^8}'.\
format('i', 'Title', 'Bin', 'Norm', 'Active'))
print('-' * 79)
for p in reversed(Experiment.maps):
print('{: >3} {: <40} {: >5} {: >5.2e} {: >5}'.\
format(i, p.histogram.title[:40], p.bin_size,
p.norm, p.active))
i -= 1
print()
def align(self, dataX, dataXY, reverse=False): if reverse: self.aligned = list(reversed(np.interp(list(reversed(dataX)), list(reversed(dataXY[0])), list(reversed(dataXY[1]))))) else: self.aligned = list(np.interp(dataX, dataXY[0], dataXY[1])) return self.aligned
def filterRevisions(self, revisions, filter=None, max_revs=None):
"""Filter a set of revisions based on any number of filter criteria.
If specified, filter should be a dict with keys corresponding to
revision attributes, and values of 1+ strings"""
if not filter:
if max_revs is None:
for rev in reversed(revisions):
yield DevRevision(rev)
else:
for index,rev in enumerate(reversed(revisions)):
if index >= max_revs:
break
yield DevRevision(rev)
else:
for index, rev in enumerate(reversed(revisions)):
if max_revs and index >= max_revs:
break
try:
for field,acceptable in filter.iteritems():
if not hasattr(rev, field):
raise DoesNotPassFilter
if type(acceptable) in (str, unicode):
if getattr(rev, field) != acceptable:
raise DoesNotPassFilter
elif type(acceptable) in (list, tuple, set):
if getattr(rev, field) not in acceptable:
raise DoesNotPassFilter
yield DevRevision(rev)
except DoesNotPassFilter:
pass
def _get_descendants_by_speech(self, **kwargs):
dqs = self._get_descendants(include_min=True, **kwargs)
max_datetime = datetime.datetime(datetime.MAXYEAR, 12, 31)
lookup = dict((x.id, x) for x in dqs)
lookup[self.id] = self
self.speech_min = max_datetime
for d in dqs:
if not d.speech_min:
continue
for parent_id in reversed(d.path):
parent = lookup[parent_id]
if not parent.speech_min or d.speech_min < parent.speech_min:
parent.speech_min = d.speech_min
# Set the speech_min to all the earliests
for d in dqs:
if d.speech_min:
continue
for parent_id in reversed(d.path):
parent = lookup[parent_id]
if parent.speech_min:
d.speech_min = parent.speech_min
break
return sorted(dqs, key=lambda s: getattr(s, 'speech_min', max_datetime))
def _do_get_provider_count_and_objs(self, **kw):
"""
Se utiliza para listar solo los proyectos que cumplan ciertas
condiciones y de acuerdo a ciertos permisos.
"""
if TieneAlgunPermiso(tipo = u"Fase", recurso = u"Linea Base"):
proyectos = DBSession.query(Proyecto).filter(Proyecto.estado != \
u"Nuevo").order_by(Proyecto.id).all()
for proyecto in reversed(proyectos):
buscado = self.buscado in str(proyecto.nro_fases) or \
self.buscado in str(proyecto.fecha_inicio) or \
self.buscado in str(proyecto.fecha_fin) or \
self.buscado in proyecto.lider.nombre_usuario or \
self.buscado in proyecto.nombre or \
self.buscado in proyecto.descripcion or \
self.buscado in proyecto.estado
if not buscado: proyectos.remove(proyecto)
for proyecto in reversed(proyectos):
if not (TieneAlgunPermiso(tipo = u"Fase", recurso = \
u"Linea Base", id_proyecto = proyecto.id) \
.is_met(request.environ) and self.fase_apta(proyecto)):
proyectos.remove(proyecto)
else: proyectos = list()
return len(proyectos), proyectos
def setZeroes(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: void Do not return anything, modify matrix in-place instead.
"""
# O(1) 176ms
rows, cols = len(matrix), len(matrix[0])
col0 = False # reverse the row assign action to save rows
# mark the state at first row and col
for i in range(0, rows):
if matrix[i][0] == 0:
col0 = True
for j in range(1, cols):
if matrix[i][j] == 0:
matrix[i][0] = matrix[0][j] = 0
# mark the entire row or column to 0
for i in reversed(range(rows)):
for j in reversed(range(1, cols)):
if matrix[i][0] == 0 or matrix[0][j] == 0:
matrix[i][j] = 0
if col0:
matrix[i][0] = 0
# # O(m+n) 216ms
# m, n = [], []
# for i in range(len(matrix)):
# for j in range(len(matrix[i])):
# if matrix[i][j] == 0:
# m.append(i)
# n.append(j)
# for i in range(len(matrix)):
# for j in range(len(matrix[i])):
# if i in m or j in n:
# matrix[i][j] = 0
return matrix
def scanner_network(self,gateway):
scan = ''
config_gateway = gateway.split('.')
del config_gateway[-1]
for i in config_gateway:
scan += str(i) + '.'
gateway = scan
ranger = str(self.ip_range.text()).split('-')
jobs = []
manager = Manager()
on_ips = manager.dict()
for n in xrange(int(ranger[0]),int(ranger[1])):
ip='%s{0}'.format(n)%(gateway)
p = Process(target=self.working,args=(ip,on_ips))
jobs.append(p)
p.start()
for i in jobs: i.join()
for i in on_ips.values():
Headers = []
n = i.split('|')
self.data['IPaddress'].append(n[0])
self.data['MacAddress'].append(n[1])
self.data['Hostname'].append('<unknown>')
for n, key in enumerate(reversed(self.data.keys())):
Headers.append(key)
for m, item in enumerate(self.data[key]):
item = QTableWidgetItem(item)
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.tables.setItem(m, n, item)
Headers = []
for key in reversed(self.data.keys()):
Headers.append(key)
self.tables.setHorizontalHeaderLabels(Headers)
def instructions_reversed(self):
"""Iterate in reverse order over all instructions in the module."""
for function in reversed(self.functions[:]):
for inst in function.instructions_reversed():
yield inst
for inst in reversed(self.global_insts[:]):
yield inst
def _layout(self, entries, totallines):
"""Layout the items, trying to keep the box as small as possible
while still filling the columns"""
maxcols = self.settings.columns
numcols = min(maxcols, max(len(entries), 1))
if not entries:
return (list(), (0, 0))
# start with evenly-sized rows and expand to fit
numrows = totallines / numcols
layout = []
while not layout:
# try to do a first cut of the layout, and expand the box until
# everything fits
(layout, colstats, newrows) = self._layoutChunk(entries, (0, 0), (numrows, numcols))
if not layout:
numrows = newrows
# ok, we've got a layout where everything fits, now pull items right
# to fill the remaining columns, if need be
while colstats[-1] == 0:
# shift 1 item to the right, up to the first column that has
# excess items
meanoccupation = max(1, sum(colstats)/float(numcols))
# loop until we find a victim item which can be safely moved
victimcol = numcols
while True:
# find the right-most column with excess occupation number
for i in reversed(xrange(victimcol)):
if colstats[i] > meanoccupation:
victimcol = i
break
# find the last item in the victim column
victim = 0
for i in reversed(xrange(len(layout))):
if layout[i][2] == victimcol:
victim = i
break
# try to relayout with the victim item shoved to the next column
(newlayout, newcolstats, newrows) = self._layoutChunk(entries[victim:],
(0, victimcol+1), (numrows, numcols))
if newlayout:
# the relayout worked, so accept it
layout = layout[0:victim] + newlayout
colstats[victimcol] -= 1
del colstats[victimcol+1:]
colstats += newcolstats[victimcol+1:]
break
# if we've run out of potential victims, just return what we have
if victimcol == 0:
return (layout, (numrows, numcols))
return (layout, (numrows, numcols))
def get_tail(self, n=10, raw=True, output=False, include_latest=False):
"""Get the last n lines from the history database.
Parameters
----------
n : int
The number of lines to get
raw, output : bool
See :meth:`get_range`
include_latest : bool
If False (default), n+1 lines are fetched, and the latest one
is discarded. This is intended to be used where the function
is called by a user command, which it should not return.
Returns
-------
Tuples as :meth:`get_range`
"""
self.writeout_cache()
if not include_latest:
n += 1
cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?", (n,), raw=raw, output=output)
if not include_latest:
return reversed(list(cur)[1:])
return reversed(list(cur))
def execute(self, slot, subindex, roi, result):
if numpy.prod(roi.stop - roi.start) > 1e9:
logger.error("Requesting a very large volume from DVID: {}\n"\
"Is that really what you meant to do?"
.format( roi ))
# TODO: Modify accessor implementation to accept a pre-allocated array.
# FIXME: Disabled throttling for now. Need a better heuristic or explicit setting.
# # For "heavy" requests, we'll use the throttled accessor
# HEAVY_REQ_SIZE = 256*256*10
# if numpy.prod(result.shape) > HEAVY_REQ_SIZE:
# accessor = self._throttled_accessor
# else:
# accessor = self._default_accessor
accessor = self._default_accessor # FIXME (see above)
if self._transpose_axes:
roi_start = tuple(reversed(roi.start))
roi_stop = tuple(reversed(roi.stop))
result[:] = accessor.get_ndarray(roi_start, roi_stop).transpose()
else:
result[:] = accessor.get_ndarray(roi.start, roi.stop)
return result
def list_changes(upstream, feature, paths=[]):
feature_revs = tuple(list_revs(upstream, feature, paths=paths))
upstream_revs = tuple(list_revs(feature, upstream, paths=paths))
feature_cids = dict([
(c.change_id, c) for c in feature_revs if c.change_id is not None ])
upstream_cids = dict([
(c.change_id, c) for c in upstream_revs if c.change_id is not None ])
incoming = filter(
lambda r: r.change_id and r.change_id not in feature_cids,
reversed(upstream_revs))
outgoing = filter(
lambda r: r.change_id and r.change_id not in upstream_cids,
reversed(feature_revs))
common = filter(
lambda r: r.change_id in upstream_cids,
reversed(feature_revs))
upstream_unknown = filter(
lambda r: r.change_id is None,
reversed(upstream_revs))
feature_unknown = filter(
lambda r: r.change_id is None,
reversed(feature_revs))
return incoming, outgoing, common, upstream_unknown, feature_unknown
def try_to_bump(self, left, right):
left_edge = []
# Instead of bumping left and right, one has to bump all [..., left] and [right, ...] children.
# It may be that the child just before the left had a branch that overlaps with the right side branches.
for child in self.child_blocks:
left_edge += child.right_edges
if child is left:
break
right_edge = []
for child in reversed(self.child_blocks):
right_edge += child.left_edges
if child is right:
break
adjust = prefs.edge_width
while (not bump_polygons(left_edge, right_edge, adjust)) and adjust < 1000:
adjust += prefs.edge_width
amount = adjust - 3 * prefs.edge_width
if amount > 0:
a2 = amount / 2
self.width -= amount
self.left += a2
for child in self.child_blocks:
child.move(a2, 0)
if child is left:
break
for child in reversed(self.child_blocks):
child.move(-a2, 0)
if child is right:
break
def _FindNodeValue(self, key):
# |found_node_list| will be all the nodes that |key| has been found in.
# |checked_node_set| are those that have been checked.
info = self._value_info.get(key)
if info is None:
info = ([], set())
self._value_info[key] = info
found_node_list, checked_node_set = info
# Check all the nodes not yet checked for |key|.
newly_found = []
for node in reversed(self._nodes):
if node in checked_node_set:
break
value = node.Get(key)
if value is not None:
newly_found.append(node)
checked_node_set.add(node)
# The nodes will have been found in reverse stack order. After extending
# the found nodes, the freshest value will be at the tip of the stack.
found_node_list.extend(reversed(newly_found))
if not found_node_list:
return None
return found_node_list[-1]._value.get(key)
def new_enum_type(self, name, enumerators, enumvalues, CTypesInt):
assert isinstance(name, str)
reverse_mapping = dict(zip(reversed(enumvalues),
reversed(enumerators)))
#
class CTypesEnum(CTypesInt):
__slots__ = []
_reftypename = '%s &' % name
def _get_own_repr(self):
value = self._value
try:
return '%d: %s' % (value, reverse_mapping[value])
except KeyError:
return str(value)
def _to_string(self, maxlen):
value = self._value
try:
return reverse_mapping[value]
except KeyError:
return str(value)
#
CTypesEnum._fix_class()
return CTypesEnum
def _get_flatmirror_attrdict(cls, add, exclude, bases, dict_factory):
attrdict = dict_factory()
slotset = set()
rev_mro = reversed(cls.mro())
supercls = next(rev_mro)
for basecls in reversed(bases):
# skip some redundant base classes (typically: object)
if issubclass(basecls, supercls):
supercls = next(rev_mro)
else:
break
while True:
slots = getattr(supercls, '__slots__', ())
excl = frozenset(slots).union(exclude)
slotset.update(slots)
for attrname, obj in supercls.__dict__.items():
if attrname not in excl:
attrdict[attrname] = obj
if supercls is not cls:
supercls = next(rev_mro)
else:
break
if add is not None:
attrdict.update(add)
slots = attrdict.get('__slots__', None)
if slots is not None:
if isinstance(slots, basestring):
slots = (slots,)
slotset.update(slots)
attrdict['__slots__'] = tuple(slotset)
return attrdict
def signature_argspec(f):
from inspect import signature, Parameter, _empty
try:
if NO_ARGSPEC:
sig = signature(f, follow_wrapped=False)
else:
sig = signature(f)
except ValueError:
raise TypeError("unsupported callable")
args = list(
k for k, v in sig.parameters.items() if v.kind in (Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD)
)
varargs = None
keywords = None
for k, v in sig.parameters.items():
if v.kind == Parameter.VAR_POSITIONAL:
varargs = k
elif v.kind == Parameter.VAR_KEYWORD:
keywords = k
defaults = []
for a in reversed(args):
default = sig.parameters[a].default
if default is _empty:
break
else:
defaults.append(default)
if defaults:
defaults = tuple(reversed(defaults))
else:
defaults = None
return FakeArgSpec(args, varargs, keywords, defaults)
def uniquePathsWithObstacles(self, obstacleGrid):
row = len(obstacleGrid)
col = len(obstacleGrid[0])
if obstacleGrid[row-1][col-1] == 1:
return 0
path = [[1 for x in xrange(col)] for x in xrange(row)]
_i, _j = row, col
for i in reversed(xrange(row)):
if obstacleGrid[i][0] == 1:
_i = i
while _i < row:
path[_i][0] = 0
_i += 1
for j in reversed(xrange(col)):
if obstacleGrid[0][j] == 1:
_j = j
while _j < col:
path[0][_j] = 0
_j += 1
for i in xrange(1, row):
for j in xrange(1, col):
if obstacleGrid[i-1][j] == 1 and obstacleGrid[i][j-1] == 1:
path[i][j] = 0
elif obstacleGrid[i-1][j] == 1:
path[i][j] = path[i][j-1]
elif obstacleGrid[i][j-1] == 1:
path[i][j] = path[i-1][j]
else:
path[i][j] = path[i-1][j] + path[i][j-1]
return path[row-1][col-1]
def _merge_minidump_response(data, response):
data['platform'] = 'native'
if response.get('crashed') is not None:
data['level'] = 'fatal' if response['crashed'] else 'info'
validate_and_set_timestamp(data, response.get('timestamp'))
if response.get('system_info'):
_merge_system_info(data, response['system_info'])
sdk_info = get_sdk_from_event(data)
images = []
set_path(data, 'debug_meta', 'images', value=images)
for complete_image in response['modules']:
image = {}
_merge_image(
image, complete_image, sdk_info,
lambda e: write_error(e, data)
)
images.append(image)
# Extract the crash reason and infos
data_exception = get_path(data, 'exception', 'values', 0)
exc_value = (
'Assertion Error: %s' % response.get('assertion')
if response.get('assertion')
else 'Fatal Error: %s' % response.get('crash_reason')
)
data_exception['value'] = exc_value
data_exception['type'] = response.get('crash_reason')
data_threads = []
if response['stacktraces']:
data['threads'] = {'values': data_threads}
else:
error = SymbolicationFailed(message='minidump has no thread list',
type=EventError.NATIVE_SYMBOLICATOR_FAILED)
write_error(error, data)
for complete_stacktrace in response['stacktraces']:
is_requesting = complete_stacktrace.get('is_requesting')
thread_id = complete_stacktrace.get('thread_id')
data_thread = {
'id': thread_id,
'crashed': is_requesting,
}
data_threads.append(data_thread)
if is_requesting:
data_exception['thread_id'] = thread_id
data_stacktrace = data_exception.setdefault('stacktrace', {})
data_stacktrace['frames'] = []
else:
data_thread['stacktrace'] = data_stacktrace = {'frames': []}
if complete_stacktrace.get('registers'):
data_stacktrace['registers'] = complete_stacktrace['registers']
for complete_frame in reversed(complete_stacktrace['frames']):
new_frame = {}
_merge_frame(new_frame, complete_frame)
data_stacktrace['frames'].append(new_frame)
# -*- coding: utf-8 -*-
from pylab import *
from random import *
cases = 100
max_n = 8
inp = open("poly.in", "w")
outp = open("poly.out", "w")
inp.write("%d\n" % cases)
for cc in xrange(cases):
n = randint(2,max_n)
xs = array([(random()-0.5)*10 for i in xrange(n)])*(random()+1)
coefs = poly(xs)
inp.write("%d\n%s\n" % (n, " ".join(["%.12lf" % c for c in reversed(coefs)])))
outp.write("%s\n" % " ".join(["%.12lf" % s for s in sorted(xs)]))
# Name: Hunter
# Date: 6/13/2017
"""
proj04
Asks the user for a string and prints out whether or not the string is a palindrome.
"""
user_input1 = raw_input(
"Enter a word, and I will tell you if it is a palindrome! : ")
print user_input1
reverse = reversed(user_input1)
stringList = []
for letter in user_input1:
stringList.append(letter)
print stringList
print user_input1
while user_input1:
if user_input1[0:-1] == user_input1[-1:0]:
print "This word is a palindrome!"
break
else:
print "This word is not a palindrome :4("
break
def backward(self,e_y):
self.e_ys[-1] = e_y
for (i, l) in reversed(list(enumerate(self.layers))):
self.e_ys[i] = l.backward(self.e_ys[i+1])
return self.e_ys[0]
# -*- coding: utf-8 -*-
# generated from catkin/cmake/template/__init__.py.in
# keep symbol table as clean as possible by deleting all unnecessary symbols
from os import path as os_path
from sys import path as sys_path
from pkgutil import extend_path
__extended_path = "/home/vincent/catkin_ws/src/navigation/base_local_planner/src".split(
";")
for p in reversed(__extended_path):
sys_path.insert(0, p)
del p
del sys_path
__path__ = extend_path(__path__, __name__)
del extend_path
__execfiles = []
for p in __extended_path:
src_init_file = os_path.join(p, __name__ + '.py')
if os_path.isfile(src_init_file):
__execfiles.append(src_init_file)
else:
src_init_file = os_path.join(p, __name__, '__init__.py')
if os_path.isfile(src_init_file):
__execfiles.append(src_init_file)
del src_init_file
del p
del os_path
def addToken(conllu, sent_id, option, token_id, conllu_completo="", new_tokens=[], mergeSentencesId="", form=False):
if form:
if not os.path.isfile("../cgi-bin/tokenization.json"):
tokenization = {}
with open("../cgi-bin/tokenization.json", "w") as f:
json.dump(tokenization, f)
with open("../cgi-bin/tokenization.json") as f:
tokenization = json.load(f)
if not isinstance(conllu, estrutura_ud.Corpus):
corpus = estrutura_ud.Corpus(recursivo=False, any_of_keywords=[re.escape("# sent_id = " + sent_id + "\n"), re.escape("# sent_id = " + mergeSentencesId + "\n")])
corpus.load(conllu if not conllu_completo else conllu_completo)
else:
corpus = conllu
if token_id == "left":
token_id = corpus.sentences[sent_id].tokens[0].id
elif token_id == "right":
token_id = str(int(corpus.sentences[sent_id].tokens[-1].id)+1)
if option in ["add", "addContraction"]:
if not new_tokens:
if not mergeSentencesId:
novo_token = estrutura_ud.Token()
novo_token.build("_\t_\t_\t_\t_\t_\t0\t_\t_\t_")
new_tokens.append(novo_token)
else:
new_tokens = corpus.sentences[mergeSentencesId].tokens
else:
novo_token = estrutura_ud.Token()
novo_token.build(new_tokens[0])
new_tokens = [novo_token]
last_id = ""
for novo_token in reversed(new_tokens):
if option == "add":
novo_token.id = token_id if not '-' in novo_token.id else str(int(token_id)) + "-" + str(int(token_id)+int(novo_token.id.split("-")[1])-int(novo_token.id.split("-")[0]))
elif option == "addContraction":
novo_token.id = token_id + "-" + token_id
if mergeSentencesId:
if not last_id:
last_id = corpus.sentences[sent_id].tokens[-1].id
if token_id == str(int(last_id)+1) and not '-' in novo_token.id:
novo_token.dephead = str(int(novo_token.dephead) + int(last_id))
if not token_id in corpus.sentences[sent_id].map_token_id:
corpus.sentences[sent_id].tokens.append(novo_token)
corpus.sentences[sent_id].map_token_id[token_id] = len(corpus.sentences[sent_id].tokens) - 1
else:
corpus.sentences[sent_id].tokens.insert(corpus.sentences[sent_id].map_token_id[token_id], novo_token)
if option == "add":
for t, token in enumerate(corpus.sentences[sent_id].tokens):
if not '-' in novo_token.id:
if t > corpus.sentences[sent_id].map_token_id[token_id]:
token.id = str(int(token.id)+1) if not '-' in token.id else str(int(token.id.split("-")[0])+1) + "-" + str(int(token.id.split("-")[1])+1)
corpus.sentences[sent_id].map_token_id[token.id] = t
for t, token in enumerate(corpus.sentences[sent_id].tokens):
if not mergeSentencesId and token.dephead not in ["0", "_"] and token.dephead in corpus.sentences[sent_id].map_token_id and token_id in corpus.sentences[sent_id].map_token_id and corpus.sentences[sent_id].map_token_id[token.dephead] >= corpus.sentences[sent_id].map_token_id[token_id]:
token.dephead = str(int(token.dephead)+1)
if form:
if not conllu in tokenization:
tokenization[conllu] = {}
if not sent_id in tokenization[conllu]:
tokenization[conllu][sent_id] = []
tokenization[conllu][sent_id].append({'option': option, 'token_id': token_id, 'new_token': [novo_token.to_str()]})
if mergeSentencesId and token_id != str(int(last_id)+1):
for t, token in enumerate(corpus.sentences[sent_id].tokens):
if token.dephead not in ["0", "_"] and t > int(corpus.sentences[sent_id].map_token_id[new_tokens[-1].id]):
token.dephead = str(int(token.dephead) + int(new_tokens[-1].id))
if mergeSentencesId:
if token_id == corpus.sentences[sent_id].tokens[0].id:
corpus.sentences[sent_id].metadados['text'] = corpus.sentences[mergeSentencesId].text + ' ' + corpus.sentences[sent_id].text
else:
corpus.sentences[sent_id].metadados['text'] += ' ' + corpus.sentences[mergeSentencesId].text
corpus.sentences.pop(mergeSentencesId)
elif option in ["rm"]:
if not '-' in token_id:
for t, token in enumerate(corpus.sentences[sent_id].tokens):
if token_id in corpus.sentences[sent_id].map_token_id and t > corpus.sentences[sent_id].map_token_id[token_id]:
token.id = str(int(token.id)-1) if not '-' in token.id else str(int(token.id.split("-")[0])-1) + "-" + str(int(token.id.split("-")[1])-1)
if token.dephead not in ["_", "0"]:
if token.dephead in corpus.sentences[sent_id].map_token_id and token_id in corpus.sentences[sent_id].map_token_id and corpus.sentences[sent_id].map_token_id[token.dephead] > corpus.sentences[sent_id].map_token_id[token_id]:
token.dephead = str(int(token.dephead)-1)
corpus.sentences[sent_id].tokens = [x for t, x in enumerate(corpus.sentences[sent_id].tokens) if t != corpus.sentences[sent_id].map_token_id[token_id]]
if form:
if not conllu in tokenization:
tokenization[conllu] = {}
if not sent_id in tokenization[conllu]:
tokenization[conllu][sent_id] = []
tokenization[conllu][sent_id].append({'option': option, 'token_id': token_id})
if form:
with open("../cgi-bin/tokenization.json", "w") as f:
json.dump(tokenization, f)
corpus.save(conllu + "_tokenization" if not conllu_completo else conllu_completo + "_tokenization")
os.remove(conllu if not conllu_completo else conllu_completo)
os.rename(conllu + "_tokenization" if not conllu_completo else conllu_completo + "_tokenization", conllu if not conllu_completo else conllu_completo)
else:
return corpus
def process_payload(data):
project = Project.objects.get_from_cache(id=data['project'])
task_id_cache_key = task_id_cache_key_for_event(data)
symbolicator = Symbolicator(
project=project,
task_id_cache_key=task_id_cache_key
)
stacktrace_infos = [
stacktrace
for stacktrace in find_stacktraces_in_data(data)
if any(is_native_platform(x) for x in stacktrace.platforms)
]
stacktraces = [
{
'registers': sinfo.stacktrace.get('registers') or {},
'frames': [
f for f in reversed(sinfo.stacktrace.get('frames') or ())
if _handles_frame(data, f)
]
}
for sinfo in stacktrace_infos
]
if not any(stacktrace['frames'] for stacktrace in stacktraces):
return
modules = native_images_from_data(data)
signal = signal_from_data(data)
response = symbolicator.process_payload(
stacktraces=stacktraces,
modules=modules,
signal=signal,
)
if not _handle_response_status(data, response):
return data
assert len(modules) == len(response['modules']), (modules, response)
sdk_info = get_sdk_from_event(data)
for raw_image, complete_image in zip(modules, response['modules']):
_merge_image(
raw_image,
complete_image,
sdk_info,
lambda e: write_error(
e,
data))
assert len(stacktraces) == len(response['stacktraces']), (stacktraces, response)
for sinfo, complete_stacktrace in zip(stacktrace_infos, response['stacktraces']):
complete_frames_by_idx = {}
for complete_frame in complete_stacktrace.get('frames') or ():
complete_frames_by_idx \
.setdefault(complete_frame['original_index'], []) \
.append(complete_frame)
new_frames = []
native_frames_idx = 0
for raw_frame in reversed(sinfo.stacktrace['frames']):
if not _handles_frame(data, raw_frame):
new_frames.append(raw_frame)
continue
for complete_frame in complete_frames_by_idx.get(native_frames_idx) or ():
merged_frame = dict(raw_frame)
_merge_frame(merged_frame, complete_frame)
if merged_frame.get('package'):
raw_frame['package'] = merged_frame['package']
new_frames.append(merged_frame)
native_frames_idx += 1
if sinfo.container is not None and native_frames_idx > 0:
sinfo.container['raw_stacktrace'] = {
'frames': list(sinfo.stacktrace['frames']),
'registers': sinfo.stacktrace.get('registers')
}
new_frames.reverse()
sinfo.stacktrace['frames'] = new_frames
return data
def s(to, data):
computers = reversed(to.split('to'))
reversed_way = '{}to{}'.format(*computers)
res = get_connect
for i, com in enumerate(pravila[to]):
if i / 2 == 1 or i == 0:
com.isOpen()
com.write(res)
com.close()
if i / 2 != 1 and i != 0:
com.isOpen()
response = com.read(16)
res = response
com.close()
print(com.port)
for i, com in enumerate(pravila[reversed_way]):
if i / 2 == 1 or i == 0:
com.isOpen()
com.write(res)
com.close()
if i / 2 != 1 and i != 0:
com.isOpen()
response = com.read(16)
res = response
com.close()
if res == get_connect:
print('Соединение открыто', res)
time.sleep(5)
res_data = b''
rdata = data
for i, com in enumerate(pravila[to]):
if i / 2 == 1 or i == 0:
com.isOpen()
com.open()
com.write(rdata)
com.close()
if i / 2 != 1 and i != 0:
com.isOpen()
com.open()
print(com.in_waiting)
s_data = com.read(16)
res_data = s_data
print(res_data, com.port)
com.close()
if res_data == data:
print('Данные переданы:', res_data)
time.sleep(5)
computers = reversed(to.split('to'))
reversed_way = '{}to{}'.format(*computers)
res = get_connect
for i, com in enumerate(pravila[to]):
if i / 2 == 1 or i == 0:
com.open()
com.write(res)
print('Пакет передан')
com.close()
if i / 2 != 1 and i != 0:
com.open()
response = com.read(16)
res = response
print(response, com.port)
com.close()
for i, com in enumerate(pravila[reversed_way]):
if i / 2 == 1 or i == 0:
com.open()
com.write(res)
com.close()
if i / 2 != 1 and i != 0:
com.open()
response = com.read(16)
res = response
com.close()
if res == get_connect:
print('Соединение закрыто', res)
def scan_fxt(self, fxtid):
order = reversed(self.obj_order[fxtid])
for k in order:
yield k, self.registry[fxtid][k]
def unregister():
for cls in reversed(classes):
bpy.utils.unregister_class(cls)
del bpy.types.Scene.point_cloud
bpy.types.SpaceView3D.draw_handler_remove(draw_handler['cloud'], 'WINDOW')
def reverseAxes(img):
'''Reverse the axes of numpy array `img'.'''
return np.transpose(img,list(reversed(range(img.ndim))))
data = [111, 444, 555, 888, 412, 647, 951,
789, 654, 258, 5, 4, 234,
543, 345, 123235245, 213,
435, 2334, 345
]
min_valid_amount = 200
max_valid_amount = 400
for index in range(len(data) - 1, -1, -1):
if data[index] > max_valid_amount or data[index] < min_valid_amount:
print(index, data)
del data[index]
print(data)
# another backwards/reverse way
top_index = len(data) - 1
for index, number in enumerate(reversed(data)):
if number < min_valid_amount or number > min_valid_amount:
print(top_index - index, number)
del data[top_index - index]
print(data)
import EasyFiles as ef
# Given: A DNA string s of length at most 1000 bp.
# Return: The reverse complement sc of s.
complement = {'A':'T','C':'G','G':'C','T':'A'}
input = ef.getInput() # get the input list
DNA = input[0]
reverse = ''
for bp in reversed(DNA):
bpComplement = complement[bp]
reverse+=bpComplement
ef.writeOutput( reverse )
def krit_descending(self):
mass = list(reversed(Sort.t_sort(self.mass.copy())))
print(self.__print_matrix(mass))
print('T = {}'.format(mass))
self.__krit(mass)
def all_shortest_paths(G, source, target, weight=None, method='dijkstra'):
"""Compute all shortest paths in the graph.
Parameters
----------
G : NetworkX graph
source : node
Starting node for path.
target : node
Ending node for path.
weight : None or string, optional (default = None)
If None, every edge has weight/distance/cost 1.
If a string, use this edge attribute as the edge weight.
Any edge attribute not present defaults to 1.
method : string, optional (default = 'dijkstra')
The algorithm to use to compute the path lengths.
Supported options: 'dijkstra', 'bellman-ford'.
Other inputs produce a ValueError.
If `weight` is None, unweighted graph methods are used, and this
suggestion is ignored.
Returns
-------
paths : generator of lists
A generator of all paths between source and target.
Raises
------
ValueError
If `method` is not among the supported options.
NetworkXNoPath
If `target` cannot be reached from `source`.
Examples
--------
>>> G = nx.Graph()
>>> nx.add_path(G, [0, 1, 2])
>>> nx.add_path(G, [0, 10, 2])
>>> print([p for p in nx.all_shortest_paths(G, source=0, target=2)])
[[0, 1, 2], [0, 10, 2]]
Notes
-----
There may be many shortest paths between the source and target.
See Also
--------
shortest_path()
single_source_shortest_path()
all_pairs_shortest_path()
"""
method = 'unweighted' if weight is None else method
if method == 'unweighted':
pred = nx.predecessor(G, source)
elif method == 'dijkstra':
pred, dist = nx.dijkstra_predecessor_and_distance(G,
source,
weight=weight)
elif method == 'bellman-ford':
pred, dist = nx.bellman_ford_predecessor_and_distance(G,
source,
weight=weight)
else:
raise ValueError('method not supported: {}'.format(method))
if target not in pred:
raise nx.NetworkXNoPath('Target {} cannot be reached'
'from Source {}'.format(target, source))
stack = [[target, 0]]
top = 0
while top >= 0:
node, i = stack[top]
if node == source:
yield [p for p, n in reversed(stack[:top + 1])]
if len(pred[node]) > i:
top += 1
if top == len(stack):
stack.append([pred[node][i], 0])
else:
stack[top] = [pred[node][i], 0]
else:
stack[top - 1][1] += 1
top -= 1
def draw_snake(window,color, snake , size):
for x,y in snake[:-1]:
pygame.draw.rect(window,WHITE,[x, y, size, size])
for x,y in reversed(snake):
pygame.draw.rect(window,GREEN,[x, y, size, size])
break
from match import *
for dir in [1, 2, 3]:
print "*" * 100
print "Working on set" + str(dir) + " images"
for i in [11, 10, 9, 8, 7, 6, 5, 4]:
s1 = HarrisExtractor(8, 4, 10**i, 1, dir)
s2 = HarrisExtractor(8, 4, 10**i, 3, dir)
y = matcher(s1, s2)
print "\n"
print "*" * 60
print "Using a threshold of 10^" + str(
i) + " for filteirng Harris Points"
print "Number of Harris Points in 1st ", len(s1.harris_Points)
print "Number of Harris Points in 2nd ", len(s2.harris_Points)
for j in reversed([
1, 1.05, 1.1, 1.15, 1.2, 1.25, 1.3, 1.35, 1.4, 1.45, 1.5, 1.6,
1.7
]):
print "\n"
print "Using a threshold of " + str(j) + " for ratio of 1st to 2nd"
y.match_point_by_point(j)
y.compare_Image(j)
print "Number of matching points found", len(y.matching_pairs)
def shortest_path(G, source=None, target=None, weight=None, method='dijkstra'):
"""Compute shortest paths in the graph.
Parameters
----------
G : NetworkX graph
source : node, optional
Starting node for path. If not specified, compute shortest
paths for each possible starting node.
target : node, optional
Ending node for path. If not specified, compute shortest
paths to all possible nodes.
weight : None or string, optional (default = None)
If None, every edge has weight/distance/cost 1.
If a string, use this edge attribute as the edge weight.
Any edge attribute not present defaults to 1.
method : string, optional (default = 'dijkstra')
The algorithm to use to compute the path.
Supported options: 'dijkstra', 'bellman-ford'.
Other inputs produce a ValueError.
If `weight` is None, unweighted graph methods are used, and this
suggestion is ignored.
Returns
-------
path: list or dictionary
All returned paths include both the source and target in the path.
If the source and target are both specified, return a single list
of nodes in a shortest path from the source to the target.
If only the source is specified, return a dictionary keyed by
targets with a list of nodes in a shortest path from the source
to one of the targets.
If only the target is specified, return a dictionary keyed by
sources with a list of nodes in a shortest path from one of the
sources to the target.
If neither the source nor target are specified return a dictionary
of dictionaries with path[source][target]=[list of nodes in path].
Raises
------
NodeNotFound
If `source` is not in `G`.
ValueError
If `method` is not among the supported options.
Examples
--------
>>> G = nx.path_graph(5)
>>> print(nx.shortest_path(G, source=0, target=4))
[0, 1, 2, 3, 4]
>>> p = nx.shortest_path(G, source=0) # target not specified
>>> p[4]
[0, 1, 2, 3, 4]
>>> p = nx.shortest_path(G, target=4) # source not specified
>>> p[0]
[0, 1, 2, 3, 4]
>>> p = nx.shortest_path(G) # source, target not specified
>>> p[0][4]
[0, 1, 2, 3, 4]
Notes
-----
There may be more than one shortest path between a source and target.
This returns only one of them.
See Also
--------
all_pairs_shortest_path()
all_pairs_dijkstra_path()
all_pairs_bellman_ford_path()
single_source_shortest_path()
single_source_dijkstra_path()
single_source_bellman_ford_path()
"""
if method not in ('dijkstra', 'bellman-ford'):
# so we don't need to check in each branch later
raise ValueError('method not supported: {}'.format(method))
method = 'unweighted' if weight is None else method
if source is None:
if target is None:
# Find paths between all pairs.
if method == 'unweighted':
paths = dict(nx.all_pairs_shortest_path(G))
elif method == 'dijkstra':
paths = dict(nx.all_pairs_dijkstra_path(G, weight=weight))
else: # method == 'bellman-ford':
paths = dict(nx.all_pairs_bellman_ford_path(G, weight=weight))
else:
# Find paths from all nodes co-accessible to the target.
with nx.utils.reversed(G):
if method == 'unweighted':
paths = nx.single_source_shortest_path(G, target)
elif method == 'dijkstra':
paths = nx.single_source_dijkstra_path(G,
target,
weight=weight)
else: # method == 'bellman-ford':
paths = nx.single_source_bellman_ford_path(G,
target,
weight=weight)
# Now flip the paths so they go from a source to the target.
for target in paths:
paths[target] = list(reversed(paths[target]))
else:
if target is None:
# Find paths to all nodes accessible from the source.
if method == 'unweighted':
paths = nx.single_source_shortest_path(G, source)
elif method == 'dijkstra':
paths = nx.single_source_dijkstra_path(G,
source,
weight=weight)
else: # method == 'bellman-ford':
paths = nx.single_source_bellman_ford_path(G,
source,
weight=weight)
else:
# Find shortest source-target path.
if method == 'unweighted':
paths = nx.bidirectional_shortest_path(G, source, target)
elif method == 'dijkstra':
paths = nx.dijkstra_path(G, source, target, weight)
else: # method == 'bellman-ford':
paths = nx.bellman_ford_path(G, source, target, weight)
return paths
def _predict(self, seq, runtime=True):
softmax_list = []
aux_softmax_list = []
x_list = []
for entry in seq:
word = entry.word
char_emb, _ = self.character_network.compute_embeddings(
word, runtime=runtime)
import sys
if sys.version_info[0] == 2:
word_emb, found = self.embeddings.get_word_embeddings(
word.decode('utf-8'))
else:
word_emb, found = self.embeddings.get_word_embeddings(word)
if not found:
word_emb = self.unknown_word_embedding[0]
else:
word_emb = dy.inputVector(word_emb)
if sys.version_info[0] == 2:
holistic_word = word.decode('utf-8').lower()
else:
holistic_word = word.lower()
if holistic_word in self.encodings.word2int:
hol_emb = self.holistic_word_embedding[
self.encodings.word2int[holistic_word]]
else:
hol_emb = self.holistic_word_embedding[
self.encodings.word2int['<UNK>']]
proj_emb = self.emb_proj_w.expr(update=True) * word_emb
proj_hol = self.hol_proj_w.expr(update=True) * hol_emb
proj_char = self.char_proj_w.expr(update=True) * char_emb
# x_list.append(dy.tanh(proj_char + proj_emb + proj_hol))
if runtime:
x_list.append(dy.tanh(proj_char + proj_emb + proj_hol))
else:
p1 = random.random()
p2 = random.random()
p3 = random.random()
m1 = 1
m2 = 1
m3 = 1
if p1 < self.config.input_dropout_prob:
m1 = 0
if p2 < self.config.input_dropout_prob:
m2 = 0
if p3 < self.config.input_dropout_prob:
m3 = 0
scale = 1.0
if m1 + m2 + m3 > 0:
scale = float(3) / (m1 + m2 + m3)
m1 = dy.scalarInput(m1)
m2 = dy.scalarInput(m2)
m3 = dy.scalarInput(m3)
scale = dy.scalarInput(scale)
x_list.append(
dy.tanh((proj_char * m1 + proj_emb * m2 + proj_hol * m3) *
scale))
# BDLSTM
rnn_outputs = []
for fw, bw, dropout in zip(self.bdrnn_fw, self.bdrnn_bw,
self.config.layer_dropouts):
if not runtime:
fw.set_dropouts(0, dropout)
bw.set_dropouts(0, dropout)
else:
fw.set_dropouts(0, 0)
bw.set_dropouts(0, 0)
fw_list = fw.initial_state().transduce(x_list)
bw_list = list(
reversed(bw.initial_state().transduce(reversed(x_list))))
x_list = [
dy.concatenate([x_fw, x_bw])
for x_fw, x_bw in zip(fw_list, bw_list)
]
# if runtime:
# x_out = x_list
# else:
# x_out = [dy.dropout(x, dropout) for x in x_list]
rnn_outputs.append(x_list)
# SOFTMAX
mlp_output = []
for x in rnn_outputs[-1]:
pre_softmax = []
for iMLP in range(3):
mlp_w = self.mlps[iMLP][0]
mlp_b = self.mlps[iMLP][1]
inp = x
for w, b, drop, in zip(mlp_w, mlp_b,
self.config.presoftmax_mlp_dropouts):
inp = dy.tanh(
w.expr(update=True) * inp + b.expr(update=True))
if not runtime:
inp = dy.dropout(inp, drop)
pre_softmax.append(inp)
mlp_output.append(pre_softmax)
for softmax_inp, aux_softmax_inp in zip(
mlp_output, rnn_outputs[self.config.aux_softmax_layer - 1]):
softmax_list.append([
dy.softmax(
self.softmax_upos_w.expr(update=True) * softmax_inp[0] +
self.softmax_upos_b.expr(update=True)),
dy.softmax(
self.softmax_xpos_w.expr(update=True) * softmax_inp[1] +
self.softmax_xpos_b.expr(update=True)),
dy.softmax(
self.softmax_attrs_w.expr(update=True) * softmax_inp[2] +
self.softmax_attrs_b.expr(update=True))
])
aux_softmax_list.append([
dy.softmax(
self.aux_softmax_upos_w.expr(update=True) *
aux_softmax_inp +
self.aux_softmax_upos_b.expr(update=True)),
dy.softmax(
self.aux_softmax_xpos_w.expr(update=True) *
aux_softmax_inp +
self.aux_softmax_xpos_b.expr(update=True)),
dy.softmax(
self.aux_softmax_attrs_w.expr(update=True) *
aux_softmax_inp +
self.aux_softmax_attrs_b.expr(update=True))
])
return softmax_list, aux_softmax_list
def _recursive_remove_items_from_tree(item):
for index in reversed(range(item.childCount())):
_recursive_remove_items_from_tree(item.child(index))
topic_name = item.data(0, Qt.UserRole)
del self._tree_items[topic_name]
def __init__(self, configuration, tc):
"""
Initialization, creation of the "Tile Visualization" window and creation of the tile
display in that window.
:param configuration: object containing parameters set by the user
:param tc: TileConstructor object with information on the tesselation
"""
# Initialize instance variables
self.m_diameter = tc.m_diameter
self.phase_angle = tc.phase_angle
self.configuration = configuration
self.tc = tc
# The "active tile" is colored blue. It is just being processed. Unprocessed tiles are
# colored red, processed ones light-blue.
self.active_tile = None
# Get the size of the window from the configuration object and create the figure.
figsize = ((self.configuration.conf.getfloat("Tile Visualization", "figsize horizontal")),
(self.configuration.conf.getfloat("Tile Visualization", "figsize vertical")))
# self.fig = plt.figure(figsize=figsize, frameon=False)
self.fig = plt.figure(figsize=figsize, facecolor=(0., 0., 0., 1))
# Switch on interactive mode.
plt.ion()
# Replace the window location with coordinates stored from a previous run in configuration.
self.mngr = plt.get_current_fig_manager()
(x0, y0, width, height) = self.mngr.window.geometry().getRect()
# look up stored position of upper left window corner:
x0 = self.configuration.conf.getint('Hidden Parameters', 'tile window x0')
y0 = self.configuration.conf.getint('Hidden Parameters', 'tile window y0')
# move the tile visualization window to the stored position:
self.mngr.window.setGeometry(x0, y0, width, height)
self.ax = self.fig.add_subplot(111, facecolor='black')
# Set the coordinate range in x and y. Coordinates are in radians from now on.
fig_half_width = self.m_diameter / 2. + 0.0003 + self.tc.ol_outer
plt.axis(([-fig_half_width, fig_half_width, -fig_half_width, fig_half_width]))
plt.tick_params(axis='both', which='both', bottom=False, top=False, labelbottom=False,
left=False, labelleft=False)
# Compute and show the current outline of the moon phase.
polygon_array = np.array(self.__MoonPhase__())
moon_outline = (Polygon(polygon_array, closed=True, color='#FFD700', alpha=1.))
self.ax.add_patch(moon_outline)
# Draw all tiles. Their color is red (unprocessed).
self.tiles = []
label_fontsize = self.configuration.conf.getint("Tile Visualization", "label fontsize")
label_shift = self.configuration.conf.getfloat("Tile Visualization", "label shift")
for count, t in enumerate(self.tc.list_of_tiles_sorted):
rectangle = Rectangle((t['x_left'], t['y_bottom']), self.tc.im_w, self.tc.im_h,
color='red', alpha=0.5)
self.tiles.append(rectangle)
x_text_pos_col = (t['x_right'] - float(t['column_index'] + 1) / float(
t['column_total'] + 1) * self.tc.im_w)
x_text_pos = (label_shift * x_text_pos_col + (1. - label_shift) * t['x_center'])
plt.text(x_text_pos, t['y_center'], str(count), horizontalalignment='center',
verticalalignment='center', fontsize=label_fontsize)
# Add the tiles in reversed order.
for t in reversed(self.tiles):
self.ax.add_patch(t)
# Initialize the RectangleSelector with which patches of tiles can be selected later.
toggle_selector.RS = RectangleSelector(self.ax, self.line_select_callback, drawtype='box',
useblit=True, button=[1, 3],
# don't use middle button
minspanx=0, minspany=0, spancoords='pixels')
plt.connect('key_press_event', toggle_selector)
# Initialize instance variables.
self.select_rect_x_min = None
self.select_rect_x_max = None
self.select_rect_y_min = None
self.select_rect_y_max = None
# Initialize mouse coordinates for rectangle selector.
self.x1 = -2.
self.x2 = -2.
self.y1 = -2.
self.y2 = -2.
self.selection_rectangle = None
self.reset_selection_rectangle()
self.fig.canvas.set_window_title("MoonPanoramaMaker: Tile Arrangement "
"in normalized orientation (see user "
"guide)")
plt.tight_layout()
self.fig.canvas.manager.show()
def sync(self, entrega_dir: pathlib.Path, rama: str, *, target_subdir: str = None):
"""Importa una entrega a los repositorios de alumnes.
Args:
entrega_dir: ruta en repo externo con los archivos actualizados.
rama: rama en la que actualizar la entrega.
target_subdir: directorio que se debe actuaizar dentro el repositorio.
Si no se especifica, se usa el nombre de la rama (usar la cadena
vacía para actualizar el toplevel).
Raises:
github.UnknownObjectException si el repositorio no existe.
github.GithubException si se recibió algún otro error de la API.
"""
if target_subdir is None:
target_subdir = rama
gh = github.Github(GITHUB_TOKEN)
repo = self.gh_repo or gh.get_repo(self.repo_full)
gitref = repo.get_git_ref(f"heads/{rama}")
ghuser = random.choice(self.github_users) # ¯\_(ツ)_/¯ Only entregas knows.
prefix_re = re.compile(re.escape(target_subdir.rstrip("/") + "/"))
# Estado actual del repo.
cur_sha = gitref.object.sha
# NOTE: como solo trabajamos en un subdirectorio, se podría limitar el uso
# de recursive a ese directorio (si trabajáramos con repos muy grandes).
cur_tree = repo.get_git_tree(cur_sha, recursive=True)
cur_commit = repo.get_git_commit(cur_sha)
# Tree de la entrega en master, para manejar borrados.
baseref = repo.get_git_ref(f"heads/{repo.default_branch}")
base_tree = repo.get_git_tree(baseref.object.sha, recursive=True)
# Examinar el repo de entregas para obtener los commits a aplicar.
entrega_repo = git.Repo(entrega_dir, search_parent_directories=True)
entrega_relpath = entrega_dir.relative_to(entrega_repo.working_dir).as_posix()
pending_commits = []
cur_commit_date = cur_commit.author.date
# La fecha de la API siempre viene en UTC, pero PyGithub no le asigna
# timezone, y se interpretaría en zona horaria local por omisión. Ver
# https://github.com/PyGithub/PyGithub/pull/704.
cur_commit_date = cur_commit_date.replace(tzinfo=timezone.utc)
for commit in entrega_repo.iter_commits(paths=[entrega_relpath]):
if commit.authored_date > cur_commit_date.timestamp():
pending_commits.append(commit)
for commit in reversed(pending_commits):
entrega_tree = commit.tree.join(entrega_relpath)
tree_contents = tree_to_github(entrega_tree, target_subdir, repo)
entrega_files = set(tree_contents.keys())
tree_elements = list(tree_contents.values())
tree_elements.extend(
deleted_files(entrega_files, cur_tree, prefix_re, base_tree)
)
author_date = datetime.fromtimestamp(commit.authored_date).astimezone()
author_info = github.InputGitAuthor(
ghuser, f"{ghuser}@users.noreply.github.com", author_date.isoformat()
)
cur_tree = repo.create_git_tree(tree_elements, cur_tree)
cur_commit = repo.create_git_commit(
commit.message, cur_tree, [cur_commit], author_info
)
# Se necesita obtener el árbol de manera recursiva para tener
# los contenidos del subdirectorio de la entrega.
cur_tree = repo.get_git_tree(cur_tree.sha, recursive=True)
gitref.edit(cur_commit.sha)
def create_feature_extractor(
model: nn.Module,
return_nodes: Optional[Union[List[str], Dict[str, str]]] = None,
train_return_nodes: Optional[Union[List[str], Dict[str, str]]] = None,
eval_return_nodes: Optional[Union[List[str], Dict[str, str]]] = None,
tracer_kwargs: Dict = {},
suppress_diff_warning: bool = False,
) -> fx.GraphModule:
"""
Creates a new graph module that returns intermediate nodes from a given
model as dictionary with user specified keys as strings, and the requested
outputs as values. This is achieved by re-writing the computation graph of
the model via FX to return the desired nodes as outputs. All unused nodes
are removed, together with their corresponding parameters.
Desired output nodes must be specified as a ``.`` separated
path walking the module hierarchy from top level module down to leaf
operation or leaf module. For more details on the node naming conventions
used here, please see the :ref:`relevant subheading <about-node-names>`
in the `documentation <https://pytorch.org/vision/stable/feature_extraction.html>`_.
Not all models will be FX traceable, although with some massaging they can
be made to cooperate. Here's a (not exhaustive) list of tips:
- If you don't need to trace through a particular, problematic
sub-module, turn it into a "leaf module" by passing a list of
``leaf_modules`` as one of the ``tracer_kwargs`` (see example below).
It will not be traced through, but rather, the resulting graph will
hold a reference to that module's forward method.
- Likewise, you may turn functions into leaf functions by passing a
list of ``autowrap_functions`` as one of the ``tracer_kwargs`` (see
example below).
- Some inbuilt Python functions can be problematic. For instance,
``int`` will raise an error during tracing. You may wrap them in your
own function and then pass that in ``autowrap_functions`` as one of
the ``tracer_kwargs``.
For further information on FX see the
`torch.fx documentation <https://pytorch.org/docs/stable/fx.html>`_.
Args:
model (nn.Module): model on which we will extract the features
return_nodes (list or dict, optional): either a ``List`` or a ``Dict``
containing the names (or partial names - see note above)
of the nodes for which the activations will be returned. If it is
a ``Dict``, the keys are the node names, and the values
are the user-specified keys for the graph module's returned
dictionary. If it is a ``List``, it is treated as a ``Dict`` mapping
node specification strings directly to output names. In the case
that ``train_return_nodes`` and ``eval_return_nodes`` are specified,
this should not be specified.
train_return_nodes (list or dict, optional): similar to
``return_nodes``. This can be used if the return nodes
for train mode are different than those from eval mode.
If this is specified, ``eval_return_nodes`` must also be specified,
and ``return_nodes`` should not be specified.
eval_return_nodes (list or dict, optional): similar to
``return_nodes``. This can be used if the return nodes
for train mode are different than those from eval mode.
If this is specified, ``train_return_nodes`` must also be specified,
and `return_nodes` should not be specified.
tracer_kwargs (dict, optional): a dictionary of keywork arguments for
``NodePathTracer`` (which passes them onto it's parent class
`torch.fx.Tracer <https://pytorch.org/docs/stable/fx.html#torch.fx.Tracer>`_).
suppress_diff_warning (bool, optional): whether to suppress a warning
when there are discrepancies between the train and eval version of
the graph. Defaults to False.
Examples::
>>> # Feature extraction with resnet
>>> model = torchvision.models.resnet18()
>>> # extract layer1 and layer3, giving as names `feat1` and feat2`
>>> model = create_feature_extractor(
>>> model, {'layer1': 'feat1', 'layer3': 'feat2'})
>>> out = model(torch.rand(1, 3, 224, 224))
>>> print([(k, v.shape) for k, v in out.items()])
>>> [('feat1', torch.Size([1, 64, 56, 56])),
>>> ('feat2', torch.Size([1, 256, 14, 14]))]
>>> # Specifying leaf modules and leaf functions
>>> def leaf_function(x):
>>> # This would raise a TypeError if traced through
>>> return int(x)
>>>
>>> class LeafModule(torch.nn.Module):
>>> def forward(self, x):
>>> # This would raise a TypeError if traced through
>>> int(x.shape[0])
>>> return torch.nn.functional.relu(x + 4)
>>>
>>> class MyModule(torch.nn.Module):
>>> def __init__(self):
>>> super().__init__()
>>> self.conv = torch.nn.Conv2d(3, 1, 3)
>>> self.leaf_module = LeafModule()
>>>
>>> def forward(self, x):
>>> leaf_function(x.shape[0])
>>> x = self.conv(x)
>>> return self.leaf_module(x)
>>>
>>> model = create_feature_extractor(
>>> MyModule(), return_nodes=['leaf_module'],
>>> tracer_kwargs={'leaf_modules': [LeafModule],
>>> 'autowrap_functions': [leaf_function]})
"""
is_training = model.training
assert any(arg is not None for arg in [return_nodes, train_return_nodes, eval_return_nodes]), (
"Either `return_nodes` or `train_return_nodes` and " "`eval_return_nodes` together, should be specified"
)
assert not ((train_return_nodes is None) ^ (eval_return_nodes is None)), (
"If any of `train_return_nodes` and `eval_return_nodes` are " "specified, then both should be specified"
)
assert (return_nodes is None) ^ (train_return_nodes is None), (
"If `train_return_nodes` and `eval_return_nodes` are specified, " "then both should be specified"
)
# Put *_return_nodes into Dict[str, str] format
def to_strdict(n) -> Dict[str, str]:
if isinstance(n, list):
return {str(i): str(i) for i in n}
return {str(k): str(v) for k, v in n.items()}
if train_return_nodes is None:
return_nodes = to_strdict(return_nodes)
train_return_nodes = deepcopy(return_nodes)
eval_return_nodes = deepcopy(return_nodes)
else:
train_return_nodes = to_strdict(train_return_nodes)
eval_return_nodes = to_strdict(eval_return_nodes)
# Repeat the tracing and graph rewriting for train and eval mode
tracers = {}
graphs = {}
mode_return_nodes: Dict[str, Dict[str, str]] = {"train": train_return_nodes, "eval": eval_return_nodes}
for mode in ["train", "eval"]:
if mode == "train":
model.train()
elif mode == "eval":
model.eval()
# Instantiate our NodePathTracer and use that to trace the model
tracer = NodePathTracer(**tracer_kwargs)
graph = tracer.trace(model)
name = model.__class__.__name__ if isinstance(model, nn.Module) else model.__name__
graph_module = fx.GraphModule(tracer.root, graph, name)
available_nodes = list(tracer.node_to_qualname.values())
# FIXME We don't know if we should expect this to happen
assert len(set(available_nodes)) == len(
available_nodes
), "There are duplicate nodes! Please raise an issue https://github.com/pytorch/vision/issues"
# Check that all outputs in return_nodes are present in the model
for query in mode_return_nodes[mode].keys():
# To check if a query is available we need to check that at least
# one of the available names starts with it up to a .
if not any([re.match(rf"^{query}(\.|$)", n) is not None for n in available_nodes]):
raise ValueError(
f"node: '{query}' is not present in model. Hint: use "
"`get_graph_node_names` to make sure the "
"`return_nodes` you specified are present. It may even "
"be that you need to specify `train_return_nodes` and "
"`eval_return_nodes` separately."
)
# Remove existing output nodes (train mode)
orig_output_nodes = []
for n in reversed(graph_module.graph.nodes):
if n.op == "output":
orig_output_nodes.append(n)
assert len(orig_output_nodes)
for n in orig_output_nodes:
graph_module.graph.erase_node(n)
# Find nodes corresponding to return_nodes and make them into output_nodes
nodes = [n for n in graph_module.graph.nodes]
output_nodes = OrderedDict()
for n in reversed(nodes):
module_qualname = tracer.node_to_qualname.get(n)
if module_qualname is None:
# NOTE - Know cases where this happens:
# - Node representing creation of a tensor constant - probably
# not interesting as a return node
# - When packing outputs into a named tuple like in InceptionV3
continue
for query in mode_return_nodes[mode]:
depth = query.count(".")
if ".".join(module_qualname.split(".")[: depth + 1]) == query:
output_nodes[mode_return_nodes[mode][query]] = n
mode_return_nodes[mode].pop(query)
break
output_nodes = OrderedDict(reversed(list(output_nodes.items())))
# And add them in the end of the graph
with graph_module.graph.inserting_after(nodes[-1]):
graph_module.graph.output(output_nodes)
# Remove unused modules / parameters
graph_module.graph.eliminate_dead_code()
graph_module.recompile()
# Keep track of the tracer and graph so we can choose the main one
tracers[mode] = tracer
graphs[mode] = graph
# Warn user if there are any discrepancies between the graphs of the
# train and eval modes
if not suppress_diff_warning:
_warn_graph_differences(tracers["train"], tracers["eval"])
# Build the final graph module
graph_module = DualGraphModule(model, graphs["train"], graphs["eval"], class_name=name)
# Restore original training mode
model.train(is_training)
graph_module.train(is_training)
return graph_module
def polynomial(z, coefficients): # Horner method
t = complex(0, 0)
for c in reversed(coefficients):
t = t * z + c
return t
def backward_phase(augmented):
for i in reversed(range(1, augmented.shape[0])):
sliced = augmented[:i + 1, :]
rr_up(sliced[:, i:])
augmented[:i + 1, :] = sliced
print_mat(augmented)
def loopingFunction(a=1 * 2):
c = []
f = [c, a]
for a in range(6 or 8):
for b in range(8):
if a == b:
c.append((a, b, True))
elif a < b:
c.append((b, a, False))
else:
c.append((a, b, False))
if a != b:
z = 1
else:
z = 0
if z == 0:
continue
if z == 1 and b == 6:
break
if a == b:
z = 0
print c
f = 1
while f < (10 or 8):
m = 1
f += 1
print "m=", m
x = [u for u in range(8)]
x = [(u, v) for (u, v) in zip(range(8), reversed(range(8)))]
print x
x = [(u if u % 2 == 0 else 0) for u in range(10)]
print x
x = [(u if u % 2 == 0 else 0) for u in (a if cond() else range(9))]
print x
y = [[3 + (l if l else -1) for l in [m, m + 1]]
for m in [f for f in range(2)]]
print "f=", f
print "y=", y
if x:
l = "YES"
else:
l = "NO"
if x:
l = "yes"
else:
if True:
l = "no"
print "Triple and chain"
if m and l and f:
print "OK"
print "Triple or chain"
if m or l or f:
print "Okey"
print "Nested if not chain"
if not m:
if not l:
print "ok"
print "Braced if not chain with 'or'"
if not (m or l):
print "oki"
print "Braced if not chain with 'and'"
if not (m and l):
print "oki"
d = 1
print "Nested if chain with outer else"
if a:
if b or c:
if d:
print "inside nest"
else:
print "outer else"
print x
while False:
pass
else:
print "Executed else branch for False condition while loop"
while True:
break
else:
print "Executed else branch for True condition while loop"
for x in range(7):
pass
else:
print "Executed else branch for no break for loop"
for x in range(7):
break
else:
print "Executed else branch despite break in for loop"
x = iter(range(5))
while next(x):
pass
else:
print "Executed else branch of while loop without break"
def generate_sigstruct(attr, args, mrenclave):
'''Generate Sigstruct.
field format: (offset, type, value)
''' # pylint: disable=too-many-locals
fields = {
'header': (offs.SGX_ARCH_ENCLAVE_CSS_HEADER,
"<4L", 0x00000006, 0x000000e1, 0x00010000, 0x00000000),
'module_vendor': (offs.SGX_ARCH_ENCLAVE_CSS_MODULE_VENDOR, "<L", 0x00000000),
'date': (offs.SGX_ARCH_ENCLAVE_CSS_DATE, "<HBB", attr['year'], attr['month'], attr['day']),
'header2': (offs.SGX_ARCH_ENCLAVE_CSS_HEADER2,
"<4L", 0x00000101, 0x00000060, 0x00000060, 0x00000001),
'hw_version': (offs.SGX_ARCH_ENCLAVE_CSS_HW_VERSION, "<L", 0x00000000),
'misc_select': (offs.SGX_ARCH_ENCLAVE_CSS_MISC_SELECT, "4s", attr['misc_select']),
'misc_mask': (offs.SGX_ARCH_ENCLAVE_CSS_MISC_MASK, "4s", attr['misc_select']),
'attributes': (offs.SGX_ARCH_ENCLAVE_CSS_ATTRIBUTES, "8s8s", attr['flags'], attr['xfrms']),
'attribute_mask': (offs.SGX_ARCH_ENCLAVE_CSS_ATTRIBUTE_MASK,
"8s8s", attr['flags'], attr['xfrms']),
'enclave_hash': (offs.SGX_ARCH_ENCLAVE_CSS_ENCLAVE_HASH, "32s", mrenclave),
'isv_prod_id': (offs.SGX_ARCH_ENCLAVE_CSS_ISV_PROD_ID, "<H", attr['isv_prod_id']),
'isv_svn': (offs.SGX_ARCH_ENCLAVE_CSS_ISV_SVN, "<H", attr['isv_svn']),
}
sign_buffer = bytearray(128 + 128)
for field in fields.values():
if field[0] >= offs.SGX_ARCH_ENCLAVE_CSS_MISC_SELECT:
struct.pack_into(field[1], sign_buffer,
field[0] - offs.SGX_ARCH_ENCLAVE_CSS_MISC_SELECT + 128,
*field[2:])
else:
struct.pack_into(field[1], sign_buffer, field[0], *field[2:])
proc = subprocess.Popen(
['openssl', 'rsa', '-modulus', '-in', args['key'], '-noout'],
stdout=subprocess.PIPE)
modulus_out, _ = proc.communicate()
modulus = bytes.fromhex(modulus_out[8:8+offs.SE_KEY_SIZE*2].decode())
modulus = bytes(reversed(modulus))
proc = subprocess.Popen(
['openssl', 'sha256', '-binary', '-sign', args['key']],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
signature, _ = proc.communicate(sign_buffer)
signature = signature[::-1]
modulus_int = int.from_bytes(modulus, byteorder='little')
signature_int = int.from_bytes(signature, byteorder='little')
tmp1 = signature_int * signature_int
q1_int = tmp1 // modulus_int
tmp2 = tmp1 % modulus_int
q2_int = tmp2 * signature_int // modulus_int
q1 = q1_int.to_bytes(384, byteorder='little') # pylint: disable=invalid-name
q2 = q2_int.to_bytes(384, byteorder='little') # pylint: disable=invalid-name
fields.update({
'modulus': (offs.SGX_ARCH_ENCLAVE_CSS_MODULUS, "384s", modulus),
'exponent': (offs.SGX_ARCH_ENCLAVE_CSS_EXPONENT, "<L", 3),
'signature': (offs.SGX_ARCH_ENCLAVE_CSS_SIGNATURE, "384s", signature),
'q1': (offs.SGX_ARCH_ENCLAVE_CSS_Q1, "384s", q1),
'q2': (offs.SGX_ARCH_ENCLAVE_CSS_Q2, "384s", q2),
})
buffer = bytearray(offs.SGX_ARCH_ENCLAVE_CSS_SIZE)
for field in fields.values():
struct.pack_into(field[1], buffer, field[0], *field[2:])
return buffer
print("Unable to find last downloaded tweet id or reply id for user",
user_id)
return tweet
nextID = sys.argv[1]
while nextID:
tweet = find_tweet(nextID, tweetsDB)
if tweet is None:
# can also be triggered if database is incomplete - make sure you have downloaded all tweets needed
tweets.append("---tweet has been deleted---")
nextID = ''
else:
tweets.append(tweet)
if "in_reply_to_status_id" in tweet.keys():
try:
nextID = tweet["in_reply_to_status_id"]["$numberLong"]
except:
nextID = tweet["in_reply_to_status_id"]
else:
# this is root
nextID = ''
# we print ids from root to leaf
for i in reversed(tweets):
print(i)
def _handle_reunion_packet(self, packet: Packet):
# TODO: don't accept reunion from disconnected peers and its children
parser = ReunionParser(packet)
if not parser.is_valid():
print("Ignoring invalid reunion packet")
return
neighbor = parser.entries[-1]
if not self.is_neighbour(neighbor):
print("Ignoring reunion packet received from non neighbor")
return
if parser.request_type == Packet.REQUEST:
for address in parser.entries:
node = self.graph.find_node(address)
if node:
node.update_last_seen()
resp_packet = PacketFactory.new_reunion_packet(Packet.RESPONSE, self.address, list(reversed(parser.entries)))
self.send_packet(neighbor, resp_packet)
else:
print("Ignoring reunion response packet")
"""
EXPECTING ALTERNATING LIST OF operands AND operators
"""
if isinstance(elements, basestring):
try:
return {"id": int(elements)}
except Exception, e:
Log.error("problem", e)
if isinstance(elements, list) and len(elements) == 1:
if isinstance(elements[0], basestring):
return {"id": int(elements[0])}
return elements[0]
if isinstance(elements, Mapping):
return elements
for i in reversed(range(1, len(elements), 2)):
if elements[i] == ":":
return _parse_key(elements[:i - 1:] + [{"id": int(elements[i - 1]), "source": _parse_key(elements[i + 1]), "type": "aggregation"}] + elements[i + 2::])
for i in range(1, len(elements), 2):
if elements[i] == ".":
return _parse_key(elements[:i - 1:] + [{"id": int(elements[i + 1]), "source": _parse_key(elements[i - 1]), "type": "join"}] + elements[i + 2::])
Log.error("Do not know how to parse")
def etl2key(etl):
if etl.source:
if etl.source.type:
if etl.type == etl.source.type:
if etl.type == "join":
return etl2key(etl.source) + "." + unicode(etl.id)
else:
