def pretty_fmt_diff(diff, file1=None, file2=None):
def iter_changed(changed):
try:
for (p, r, a) in changed:
yield ((p, r), '-')
yield ((p, a), '+')
except ValueError:
for (p, c) in changed:
yield ((p, c), '>')
removed = itertools.izip_longest(diff['removed'], [], fillvalue='-')
added = itertools.izip_longest(diff['added'], [], fillvalue='+')
changed = iter_changed(diff['changed'])
combined = sorted(itertools.chain(added, removed, changed), key=lambda ((p, n), pre): (p, 127-ord(pre), n))
ret = []
if file1 is not None:
ret.append('--- %s' % file1)
if file2 is not None:
ret.append('+++ %s' % file2)
if file1 is not None or file2 is not None:
ret.append('')
for ((plist, node), prefix) in combined:
if node is not None:
ret.append('%s %s: %s' % (prefix, '->'.join(plist), dumps_json(node)))
else:
ret.append('%s %s' % (prefix, '->'.join(plist)))
return '\n'.join(ret)
def runUpdateDaemon(restartTimerFunc):
updateDao = dao.dao()
for userID in daemonMap.keys():
if not userID in onlineFriends:
onlineFriends[userID] = set([])
friendListUpdate = set([])
friendListOffline = set([])
fullFriendList = updateDao.getFriends(userID)
for (_, friendID) in fullFriendList:
if friendID in onlineClients:
friendListUpdate.add(friendID)
else:
friendListOffline.add(friendID)
# Build lists (actually sets) of friends who went offline or online
# Offline: Friend exists in old list but not in new one
# Online: Friend exists in new list but not in old one
offlinelist = onlineFriends[userID] & friendListOffline
onlinelist = friendListUpdate - (onlineFriends[userID] & friendListUpdate)
# Creating the actual data to send -- this uses some craziness with mapping functions
# Basically, the first line does the offline list, and the second does the online one
payload = ''.join(starmap(upFormat.pack, list(izip_longest(offlinelist, '', fillvalue=0))))
payload = payload + ''.join(starmap(upFormat.pack, list(izip_longest(onlinelist, '', fillvalue=1))))
onlineFriends[userID] = onlinelist
sock = daemonMap[userID]
sock.send(padToSize(pktFormat.pack(0, r_status_update, len(payload)) + payload, BUFSIZE))
del updateDao
restartTimerFunc()
def thin_fasta(fasta, l, a, p, c, b, positions):
if not positions:
for fasta_file in fasta:
with open(fasta_file, 'r') as f:
for tag, sequence in itertools.izip_longest(f, f, fillvalue=None):
if (
(not l or l in tag) and
(not a or a in tag) and
(not p or p in tag) and
(not c or c in tag) and
(not b or b in tag)
):
sys.stdout.write(tag)
sys.stdout.write(sequence)
else:
for fasta_file in fasta:
with open(fasta_file, 'r') as f:
for tag, sequence in itertools.izip_longest(f, f, fillvalue=None):
seq_list = list(sequence)
for i, aa in enumerate(seq_list):
if i not in positions:
seq_list[i] = '-'
sequence = ''.join(seq_list)
sys.stdout.write(tag)
sys.stdout.write('{0}\n'.format(sequence))
def load_from_files(self, tileset_name, tilesize):
import tile
ss = spritesheet(tileset_name + ".png", tilesize)
types = None
names = None
with open(tileset_name + ".types", 'r') as types_f:
types = types_f.readlines()
with open(tileset_name + ".names", 'r') as names_f:
names = names_f.readlines()
if types is None:
raise ValueError("Could not open types definition, {0}.types".format(tileset_name))
for x, rows in enumerate(izip_longest(types, names)):
type_row, name_row = rows
type_row_tmp = type_row.strip().split(',')
type_row = []
for i in type_row_tmp:
typ, sep, num = i.partition("*")
if sep != "":
for n in xrange(int(num)):
type_row.append(getattr(tile, typ.strip()))
else:
type_row.append(getattr(tile, typ.strip()))
if name_row is not None:
name_row = name_row.strip().split(',')
else:
name_row = []
for y, cols in enumerate(izip_longest(type_row, name_row)):
type_col, name_col = cols
typ = type_col(ss.image_pos((y, x)))
self.tiles[x][y] = typ
if name_col is not None:
self.aliases[name_col.strip()] = (x, y)
def itersplit_to_fields(str_,
fsep=DEFAULT_FSEP,
revtuple=None,
fields=[],
preparse=None):
"""
Itersplit a string into a (named, if specified) tuple.
Args:
str_ (str): string to split
fsep (str): field separator (delimiter to split by)
revtuple (object): namedtuple (or class with a ``._fields`` attr)
(optional)
fields (list of str): field names (if revtuple is not specified)
preparse (callable): function to parse str with before itersplitting
Returns:
tuple or revtuple: fields as a tuple or revtuple, if specified
"""
if preparse:
str_ = preparse(str_)
_fields = itersplit(str_, fsep)
if revtuple is not None:
try:
values = (t[1] for t in izip_longest(revtuple._fields, _fields))
return revtuple(*values)
except:
log.error(revtuple)
log.error(_fields)
raise
return tuple(izip_longest(fields, _fields, fillvalue=None))
def ps_mult_karatsuba(M, N, kthresh=40):
m = len(M)
n = len(N)
# Classical Multiplication is faster until a certain point.
if m < kthresh or n < kthresh:
return ps_mult_classical(M, N)
# The algorithm works best when we split into halves
k = max(m, n) // 2
# write M = f1*x^k + f0, N = g1*x^k + g0
f0 = M[0:k]
f1 = M[k:]
g0 = N[0:k]
g1 = N[k:]
# We want to compute MN = (f1*x^k + f0)(g1*x^k + g0).
# We let z0 = f0*g0, z2 = f1*g1
z0 = ps_mult_karatsuba(f0, g0, kthresh)
z2 = ps_mult_karatsuba(f1, g1, kthresh)
f1_f0 = [sum(e) for e in itertools.izip_longest(f1, f0, fillvalue=0)]
g1_g0 = [sum(e) for e in itertools.izip_longest(g1, g0, fillvalue=0)]
xxyy = ps_mult_karatsuba(f1_f0, g1_g0, kthresh)
z1 = [e[0] - e[1] - e[2] for e in itertools.izip_longest(xxyy, z2, z0, fillvalue=0)]
t2 = [0] * (2 * k) + z2
t1 = [0] * (k) + z1
xy = [sum(e) for e in itertools.izip_longest(t2, t1, z0, fillvalue=0)]
return xy
def translation_surface_cmp(s1, s2):
r"""
Compare two finite surfaces.
The surfaces will be considered equal if and only if there is a translation automorphism
respecting the polygons and the base_labels.
"""
if not s1.is_finite() or not s2.is_finite():
raise NotImplementedError
lw1=s1.walker()
lw2=s2.walker()
from itertools import izip_longest
for p1,p2 in izip_longest(lw1.polygon_iterator(), lw2.polygon_iterator()):
if p1 is None:
# s2 has more polygons
return -1
if p2 is None:
# s1 has more polygons
return 1
ret = polygon_compare(p1,p2)
if ret != 0:
return ret
# Polygons are identical. Compare edge gluings.
for pair1,pair2 in izip_longest(lw1.edge_iterator(), lw2.edge_iterator()):
l1,e1 = s1.opposite_edge(pair1)
l2,e2 = s2.opposite_edge(pair2)
num1 = lw1.label_to_number(l1)
num2 = lw2.label_to_number(l2)
ret = cmp(num1,num2)
if ret!=0:
return ret
ret = cmp(e1,e2)
if ret!=0:
return ret
return 0
def count_possib(block, isLast=False):
"""
Подсчитывает вероятности равенства 0 для пары Alpha/Betta
"""
_alpha = range(1, 16)
_betta = dict(itertools.izip_longest(range(1, 8), '', fillvalue=0))
if isLast:
_betta = dict(itertools.izip_longest(range(1, 4), '', fillvalue=0))
possib = dict([(item, _betta.copy()) for item in _alpha])
# print possib
for alpha in possib.keys():
# print '*'*50
# print "alpha = %d" % alpha
for betta in possib[alpha].keys():
# print '-'*50
# print "Betta = %d" % betta
for x_XOR_k in block.keys():
left = (x_XOR_k & alpha)
right = (block[x_XOR_k] & betta)
Q = (
bin(left)[2:].zfill(4) + bin(right)[2:].zfill(3)
).count('1') % 2
if not Q:
possib[alpha][betta] += 1
# print "(a, x_k) = %d * %d = %d" % (x_XOR_k, alpha, left)
# print "(b, y) = %d * %d = %d" % (block[x_XOR_k], betta, right)
# print "Q = %d ^ %d = %d" % (left, right, Q)
return possib
def format_output(counts, out_base, created_w_bed_fname):
if out_base == None:
for count in itertools.izip_longest(*counts):
print "\t".join(str(i) for i in count)
else:
created_w_bed_fname = os.getcwd() + "/" + created_w_bed_fname
# Chunk to write first column of the text file
first_col = []
first_col.append("segment")
for line in open(created_w_bed_fname).readlines():
line = line.strip()
line = line.replace("\t", "_")
first_col.append(line)
out_mat = out_base + ".matrix"
out_txt = out_base + ".txt"
out1 = open(out_mat, "w")
out2 = open(out_txt, "w")
# Writing matrix
for count in itertools.izip_longest(*counts):
out1.write("\t".join(str(i) for i in count) + "\n")
out1.close()
# Writing text
counts.insert(0, first_col)
for count in itertools.izip_longest(*counts):
out2.write("\t".join(str(i) for i in count) + "\n")
out2.close()
return None
def test_iter_confusion_matrices(self):
expected = """\
tp=5, fp=4, fn=0, tn=0
tp=5, fp=3, fn=0, tn=1
tp=5, fp=2, fn=0, tn=2
tp=5, fp=1, fn=0, tn=3
tp=4, fp=1, fn=1, tn=3
tp=4, fp=0, fn=1, tn=4
tp=3, fp=0, fn=2, tn=4
tp=2, fp=0, fn=3, tn=4
tp=1, fp=0, fn=4, tn=4
tp=0, fp=0, fn=5, tn=4"""
expected = ["BinaryConfusionMatrix(%s)" % line \
for line in dedent(expected).split("\n")]
for (threshold, matrix), expected in \
izip_longest(self.data.iter_confusion_matrices(), expected):
self.assertEqual(repr(matrix), expected)
self.assertEqual(matrix, self.data.get_confusion_matrix(threshold))
expected = """\
tp=5, fp=4, fn=0, tn=0
tp=5, fp=2, fn=0, tn=2
tp=4, fp=1, fn=1, tn=3
tp=2, fp=0, fn=3, tn=4
tp=0, fp=0, fn=5, tn=4"""
expected = ["BinaryConfusionMatrix(%s)" % line \
for line in dedent(expected).split("\n")]
for (threshold, matrix), expected in \
izip_longest(self.data.iter_confusion_matrices(4), expected):
self.assertEqual(repr(matrix), expected)
self.assertEqual(matrix, self.data.get_confusion_matrix(threshold))
def tableify(data, headers=None):
from itertools import izip_longest
'''ASCII table for a list of strings'''
if not isinstance(data, list):
return ''
table = []
columns = izip_longest(*data, fillvalue='')
widths = []
for column in columns:
new_row = []
max_len = len(max(column, key=len))
max_len = max(max_len, Colors.red*2)
widths.append(max_len)
for item in column:
new_row.append(item.ljust(max_len, ' '))
table.append(new_row)
table = izip_longest(*table)
result = []
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
result.append('| ' + ' | '.join(table.next()) + ' |')
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
for row in table:
result.append('| ' + ' | '.join(row) + ' |')
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
return result
def compare_cluster_conf(conf1, conf2):
"""
return: list of differences between conf1 and conf2 in the form of tuple(key, v1, v2)
"""
diffs = []
cluster_name = conf1['clusterName']
diffs.extend(compare_dict(conf1['clusterData'], conf2['clusterData']))
# Gateway
for x, y in itertools.izip_longest(conf1['gwList'], conf2['gwList']):
diffs.extend(map(lambda t: ('%s.gw.%d.%s' % (cluster_name, x['gwId'], t[0]), t[1], t[2]),
compare_dict(x, y)))
# PG
for x, y in itertools.izip_longest(conf1['pgList'], conf2['pgList']):
diffs.extend(map(lambda t: ('%s.pg.%d.%s' % (cluster_name, x['pgId'], t[0]), t[1], t[2]),
compare_dict(x, y, ['master_Gen_Map', 'pgs_ID_List'])))
# PGS
for x, y in itertools.izip_longest(conf1['pgsList'], conf2['pgsList']):
diffs.extend(map(lambda t: ('%s.pgs.%d.%s' % (cluster_name, x['pgsId'], t[0]), t[1], t[2]),
compare_dict(x, y, ['stateTimestamp', 'smr_Role', 'old_SMR_Role', 'master_Gen'])))
# Gateway lookup
for x, y in itertools.izip_longest(conf1['gwLookup'], conf2['gwLookup']):
diffs.extend(map(lambda t: ('%s.gwLookup.%d.%s' % (cluster_name, x['gwId'], t[0]), t[1], t[2]),
compare_dict(x, y)))
return diffs
def _recursive_etree(dictionary):
"""
Helper function to create a list of etree elements from a dict.
"""
from collections import OrderedDict
import itertools
contents = []
for key, value in dictionary.iteritems():
if key == "relaxation_parameter_list":
# Wild iterator to arrive at the desired etree. If somebody else
# ever reads this just look at the output and do it some other
# way...
contents.append(E.relaxation_parameter_list(
*[getattr(E, i[0])(str(i[1][1]), number=str(i[1][0]))
for i in itertools.chain(*itertools.izip(
itertools.izip_longest(
[], enumerate(value["tau"]), fillvalue="tau"),
itertools.izip_longest(
[], enumerate(value["w"]), fillvalue="w")))]
))
continue
if isinstance(value, OrderedDict):
contents.append(getattr(E, key)(*_recursive_etree(value)))
continue
if value is True:
value = "true"
elif value is False:
value = "false"
contents.append(getattr(E, key)(str(value)))
return contents
def writerow(self, row, sep=None, *args, **kwargs):
"""
Write General Data row to file
"""
if not self.has_header: # Write basic header for raw data
self.file.write(self.encode.write_header() + '\n')
self.has_header = True
if sep is None:
sep = self.default_sep
if sep not in [',', ';', '|', ':']:
raise AdtmError('Invalid Row Value Seperator ("{0:s}") provided, '
'must be ( "," | ";" | "|" | ":" )'.format(sep))
self.offset += 1
if self.offset - self.last_headerrow == 5*5:
self.file.write("#" + sep.join((string.center(h, w) for h, w in
izip_longest(self.headers,
self.col_width,
fillvalue=0)))[1:]
+ "\n")
self.last_headerrow = self.offset
self.last_seprow = self.offset
self.offset += 1
elif self.offset - self.last_seprow == 5:
self.file.write("#" + sep.join((string.center(" ", w) for w in
self.col_width))[1:]
+ "\n")
self.last_seprow = self.offset
self.offset += 1
self.file.write(sep.join((string.center(self.encode(i), w) for i, w in
izip_longest(row,
self.col_width,
fillvalue=0)))
+ "\n")
def sent_message(sender, **kwargs):
msg = kwargs["message"]
resp = kwargs["response"]
for recipient in (
list(izip_longest(msg["To"].split(","), [], fillvalue='to')) +
list(izip_longest(msg.get("Cc", "").split(","), [], fillvalue='cc')) +
list(izip_longest(msg.get("Bcc", "").split(","), [], fillvalue='bcc'))):
if not recipient[0]:
continue
timestamp, tz = resp["SubmittedAt"].rsplit("+", 1)
tz_offset = int(tz.split(":", 1)[0])
tz = timezone("Etc/GMT%s%d" % ("+" if tz_offset >= 0 else "-", tz_offset))
submitted_at = tz.localize(datetime.strptime(timestamp[:26], POSTMARK_DATETIME_STRING)).astimezone(pytz.utc)
emsg = EmailMessage(
message_id=resp["MessageID"],
submitted_at=submitted_at,
status=resp["Message"],
to=recipient[0],
to_type=recipient[1],
sender=msg["From"],
reply_to=msg.get("ReplyTo", ""),
subject=msg["Subject"],
tag=msg.get("Tag", ""),
text_body=msg["TextBody"],
html_body=msg.get("HtmlBody", ""),
headers=msg.get("Headers", ""),
attachments=msg.get("Attachments", "")
)
emsg.save()
def sent_message(sender, **kwargs):
msg = kwargs["message"]
resp = kwargs["response"]
for recipient in (
list(izip_longest(msg["To"].split(","), [], fillvalue="to"))
+ list(izip_longest(msg.get("Cc", "").split(","), [], fillvalue="cc"))
+ list(izip_longest(msg.get("Bcc", "").split(","), [], fillvalue="bcc"))
):
if not recipient[0]:
continue
emsg = EmailMessage(
message_id=resp["MessageID"],
submitted_at=iso8601.parse_date(resp["SubmittedAt"]),
status=resp["Message"],
to=recipient[0],
to_type=recipient[1],
sender=msg["From"],
reply_to=msg.get("ReplyTo", ""),
subject=msg["Subject"],
tag=msg.get("Tag", ""),
text_body=msg["TextBody"],
html_body=msg.get("HtmlBody", ""),
headers=msg.get("Headers", ""),
attachments=msg.get("Attachments", ""),
)
emsg.save()
def merge(self, other):
if self == other:
return self
if self.shape == other.shape and self.shape != UNDEFINED and self.name == other.name and not self.dependent and not other.dependent and not self.has_missing and not other.has_missing:
return self
redim_cache = self._getRedimCache()
key = (self,other)
if not key in redim_cache:
if(self.shape == UNDEFINED or other.shape == UNDEFINED) or self.shape != other.shape:
rshape = UNDEFINED
ndep = tuple([ldep or rdep for ldep, rdep in itertools.izip_longest(self.dependent, other.dependent,fillvalue=False)])
if not ndep:
ndep = (True,) #FIXME, maybe more than 1 dependent dimension?
else:
rshape = self.shape
ndep = tuple([ldep or rdep for ldep, rdep in itertools.izip_longest(self.dependent, other.dependent,fillvalue=False)])
if(self.name == other.name):
nname = self.name
else:
nname = self.name + "_" + other.name
ndim = Dim(rshape, ndep, self.has_missing or other.has_missing, name=nname)
redim_cache[key] = ndim
return redim_cache[key]
def test_vtx_iterator():
#use vanilla izip as we"ll test using non-equal-length iterators
izip = itertools.izip
sm = Mesh(structured=True,
structured_coords =[range(10,15), range(21,25), range(31,34)])
it = sm.structured_set.iterate(iBase.Type.vertex, iMesh.Topology.point)
# test the default order
for (it_x, sm_x) in itertools.izip_longest(it,
sm.structured_iterate_vertex("zyx")):
assert_equal(it_x,sm_x)
# Do the same again, but use an arbitrary kwarg to structured_iterate_vertex
# to prevent optimization from kicking in
it.reset()
for (it_x, sm_x) in itertools.izip_longest(it,
sm.structured_iterate_vertex("zyx", no_opt=True)):
assert_equal(it_x,sm_x)
it.reset()
for (it_x, sm_x) in izip(it,
sm.structured_iterate_vertex("yx",z=sm.dims[2])):
assert_equal(it_x,sm_x)
it.reset()
for (it_x, sm_x) in izip(it, sm.structured_iterate_vertex("x")):
assert_equal(it_x,sm_x)
def diff(self, n):
"""Print the differences between the two files
"""
if os.path.isfile(n[:-4]):
diff1 = Utils().read_file(n[:-4]).splitlines()
if os.path.isfile(n):
diff2 = Utils().read_file(n).splitlines()
lines, l, c = [], 0, 0
for a, b in itertools.izip_longest(diff1, diff2):
l += 1
if a != b:
for s1, s2 in itertools.izip_longest(str(a), str(b)):
c += 1
if s1 != s2:
break
print("@@ -{0},{1} +{2},{3} @@\n".format(l, c, l, c))
for line in lines[-3:]:
print("{0}".format(line))
if a is None:
a = ""
print("{0}{1}{2}{3}".format(self.red, "-", self.endc, a))
if b is None:
b = ""
print("{0}{1}{2}{3}".format(self.green, "+", self.endc, b))
lines = []
c = 0
else:
lines.append(a)
def compare_zone_conf(servers, zone_conf1, zone_conf2):
"""
return: list of differences between zone_conf1 and zone_conf2 in the form of tuple(key, v1, v2)
"""
diffs = []
# Confmaster
for x, y in itertools.izip_longest(zone_conf1['cm']['leader'], zone_conf2['cm']['leader']):
diffs.extend(map(lambda t: ('confmaster.leader.%s' % t[0], t[1], t[2]), compare_dict(x, y)))
for x, y in itertools.izip_longest(zone_conf1['cm']['follower'], zone_conf2['cm']['follower']):
diffs.extend(map(lambda t: ('confmaster.follower.%s' % t[0], t[1], t[2]), compare_dict(x, y)))
for x, y in itertools.izip_longest(zone_conf1['cm']['heartbeat'], zone_conf2['cm']['heartbeat']):
diffs.extend(map(lambda t: ('confmaster.heartbeat.%s' % t[0], t[1], t[2]), compare_dict(x, y)))
# Cluster
if len(zone_conf1['cluster']) != len(zone_conf2['cluster']):
return [('cluster.count', len(zone_conf1['cluster']), len(zone_conf2['cluster']))]
conf1 = sorted(zone_conf1['cluster'], lambda x: x['clusterName'])
conf2 = sorted(zone_conf2['cluster'], lambda x: x['clusterName'])
for i in xrange(len(conf1)):
diffs.extend(compare_cluster_conf(conf1[i], conf2[i]))
# PM
if len(zone_conf1['pm']) != len(zone_conf2['pm']):
return [('pm.count', len(zone_conf1['pm']), len(zone_conf2['pm']))]
for i in xrange(len(zone_conf1['pm'])):
diffs.extend(compare_pm_conf(zone_conf1['pm'][i], zone_conf2['pm'][i]))
return diffs
def sent_message(sender, **kwargs):
msg = kwargs["message"]
resp = kwargs["response"]
for recipient in (
list(izip_longest(msg["To"].split(","), [], fillvalue='to')) +
list(izip_longest(msg.get("Cc", "").split(","), [], fillvalue='cc')) +
list(izip_longest(msg.get("Bcc", "").split(","), [], fillvalue='bcc'))):
if not recipient[0]:
continue
submitted_at = dateutil.parser.parse(resp["SubmittedAt"]).astimezone(pytz.utc)
if POSTMARK_USE_TZ == False:
submitted_at = submitted_at.replace(tzinfo=None)
emsg = EmailMessage(
message_id=resp["MessageID"],
submitted_at=submitted_at,
status=resp["Message"],
to=recipient[0],
to_type=recipient[1],
sender=msg["From"],
reply_to=msg.get("ReplyTo", ""),
subject=msg["Subject"],
tag=msg.get("Tag", ""),
text_body=msg["TextBody"],
html_body=msg.get("HtmlBody", ""),
headers=msg.get("Headers", ""),
attachments=msg.get("Attachments", "")
)
emsg.save()
def zip_fn(srs):
a=srs.pop()
if type(a) in [ListType,StringType]:
b=srs.pop()
srs.push(map(list,[filter(lambda x:x is not None,zlist) for zlist in itertools.izip_longest(a,b)]))
else:
lists = [srs.pop() for i in range(a)]
srs.push(map(list,[filter(lambda x:x is not None,zlist) for zlist in itertools.izip_longest(*lists)]))
def iter_by_weekdays(self):
week1, week2 = AppendedWeeks(
Subject.objects.iter_by_weekdays(week=1, semester=self.semester),
Subject.objects.iter_by_weekdays(week=2, semester=self.semester)
).get()
result = [list(izip_longest(w1, w2)) for w1, w2 in
list(izip_longest(week1, week2))]
return zip(WEEKDAYS, result)
def student(request,dept_code):
try:
dept = Department.objects.get(dept_code = dept_code)
context_dict['Department'] = dept
except:
raise Http404
try:
btech = Student.objects.filter(dept = dept_code, degree = 1).values('year_of_admission')
idd = Student.objects.filter(dept = dept_code, degree = 2).values('year_of_admission')
btech_years = list()
idd_years = list()
for i in btech: btech_years.append(i['year_of_admission'])
for i in idd: idd_years.append(i['year_of_admission'])
btech_years = sorted(list(OrderedDict.fromkeys(btech_years)),reverse=True)
idd_years = sorted(list(OrderedDict.fromkeys(idd_years)),reverse=True)
students_list_btech = list()
counter = 0
for i in btech_years:
students_list_btech.append(Student.objects.filter(dept = dept_code, degree = 1, year_of_admission = btech_years[counter]).order_by('roll_no'))
counter += 1
students_list_idd = list()
counter = 0
for i in idd_years:
students_list_idd.append(Student.objects.filter(dept = dept_code, degree = 2, year_of_admission = idd_years[counter]).order_by('roll_no'))
counter += 1
headings_btech = [ "B.Tech Part - I",
"B.Tech Part - II",
"B.Tech Part - III",
"B.Tech Part - IV" ]
headings_idd = [ "IDD Part - I",
"IDD Part - II",
"IDD Part - III",
"IDD Part - IV",
"IDD Part - V" ]
#Every value in each counter needs to be different.
counter1 = [1,2,3,4]
counter2 = [11,22,33,44,55]
full_list_btech = izip_longest(
counter1,
headings_btech,
students_list_btech )
full_list_idd = izip_longest(
counter2,
headings_idd,
students_list_idd )
context_dict['full_list_btech'] = full_list_btech
context_dict['full_list_idd'] = full_list_idd
except:
raise Http404
return render(request,'student.html',context_dict)
def init_queue(self, specs):
sections = OrderedDict()
for s in specs:
if s.section_id not in sections:
sections[s.section_id] = []
sections[s.section_id].append(s)
specs = [s for section_specs in izip_longest(*sections.values()) for s in section_specs if s]
jobs = [[RunnerJob(s) for _ in xrange(s.number_of_iterations)] for s in specs]
self.job_queue = [j for spec_jobs in izip_longest(*jobs) for j in spec_jobs if j]
def filt_func(c1, c2):
print "c1,c2",c1,c2,c1[0] > c2[0]
if c1[0] > c2[0]:
return False
print "c1,c2,izip",sorted(c1),sorted(c2),izip_longest(sorted(c1), sorted(c2))
for a in izip_longest(sorted(c1), sorted(c2)): print a
R = reduce(lambda x, y: x and (y[0] < y[1]), izip_longest(sorted(c1), sorted(c2))) #, True)
print "R", R
return not R
def generate_files_for_editing():
my_files = [f for f in os.listdir(u'./QA_files') if re.search(u'^Chapter\d+_data\.csv$', f)]
chapters = []
for f in my_files:
cnumber = int(re.search(u'^Chapter(\d+)_data\.csv$', f).group(1))
with open(u'./QA_files/{}'.format(f)) as fpointer:
cfile = CSVChapter(fpointer, cnumber)
chapters.append(cfile)
chapters.sort(key=lambda x: x.number)
start, end = -1, -1
rows = []
for chapter in chapters:
if chapter.number % 50 == 1:
start = chapter.number
for num, (en_seg, he_seg) in enumerate(izip_longest(chapter.english_segments, chapter.hebrew_segments, fillvalue=u''), 1):
rows.append({
u'Chapter': chapter.number,
u'Segment #': num,
u'English': en_seg,
u'Hebrew': he_seg
})
if chapter.number % 50 == 0 or chapter.number == chapters[-1].number:
end = chapter.number
with open('./manual_editing/Likutei_Moharan_{}-{}.csv'.format(start, end), 'w') as fp:
writer = unicodecsv.DictWriter(fp, [u'Chapter', u'Segment #', u'English', u'Hebrew'])
writer.writeheader()
writer.writerows(rows)
rows = []
my_files = [f for f in os.listdir(u'./QA_files') if re.search(u'Part2_Chapter\d+_data\.csv$', f)]
chapters = []
for f in my_files:
cnumber = int(re.search(u'^Part2_Chapter(\d+)_data\.csv$', f).group(1))
with open(u'./QA_files/{}'.format(f)) as fpointer:
cfile = CSVChapter(fpointer, cnumber, part2=True)
chapters.append(cfile)
chapters.sort(key=lambda x: x.number)
start, end = -1, -1
rows = []
for chapter in chapters:
if chapter.number % 50 == 1:
start = chapter.number
for num, (en_seg, he_seg) in enumerate(
izip_longest(chapter.english_segments, chapter.hebrew_segments, fillvalue=u''), 1):
rows.append({
u'Chapter': chapter.number,
u'Segment #': num,
u'English': en_seg,
u'Hebrew': he_seg
})
if chapter.number % 50 == 0 or chapter.number == chapters[-1].number:
end = chapter.number
with open('./manual_editing/Likutei_Moharan_Part2_{}-{}.csv'.format(start, end), 'w') as fp:
writer = unicodecsv.DictWriter(fp, [u'Chapter', u'Segment #', u'English', u'Hebrew'])
writer.writeheader()
writer.writerows(rows)
rows = []
def msgSplit(self, msg, keywordLen):
# separate the message into tuples of every keywordLen letters
split = itertools.izip_longest(*[iter(list(msg))]*keywordLen)
# transpose the result into columns
transposed = map(list, itertools.izip_longest(*split))
# if the message was uneven, the above method of splitting and
# transposing will add None values to even out the columns
# the below filter will remove those None values
return [filter(lambda a: a is not None, column) for column in transposed]
def check_fragments(oligo_file, design_fasta):
design_aa_list = []
with open(design_fasta, 'r') as f:
for pdb, seq in izip_longest(f, f, fillvalue=None):
if '4AC0' and 'B0' in pdb:
block = seq[77:117]
elif '4AC0' and 'B1' in pdb:
block = seq[99:138]
elif '2uxo' and 'B0' in pdb:
block = seq[62:100]
elif '2uxo' and 'B1' in pdb:
block = seq[136:176]
else:
raise Exception('Unrecognized design name')
design_aa_list.append(block)
fragment_list = []
with open(oligo_file, 'r') as o:
for pdb, seq in izip_longest(o, o, fillvalue=None):
if '4AC0' and 'B0' in pdb:
seq_lower = seq.lower()
seq_no_5p = seq_lower.split('gtgacccgtccctgggtctcaagat')[1]
fragment = seq_no_5p.split('gccttgagaccgggcagaggtcgac')[0]
elif '4AC0' and 'B1' in pdb:
seq_lower = seq.lower()
seq_no_5p = seq_lower.split('tgcccgctgtcttcaggtctcaagta')[1]
fragment = seq_no_5p.split('catttgagacctgtagcccggcagtg')[0]
elif '2uxo' and 'B0' in pdb:
seq_lower = seq.lower()
seq_no_5p = seq_lower.split('cgatcgtgcccacctggtctccactg')[1]
fragment = seq_no_5p.split('gttctgagaccagttggagcccgcac')[0]
elif '2uxo' and 'B1' in pdb:
seq_lower = seq.lower()
seq_no_5p = seq_lower.split('ctggtgcgtcgtctggtctctggat')[1]
fragment = seq_no_5p.split('cgttggagaccggcgaacacttccc')[0]
else:
raise Exception('Unrecognized oligo name')
fragment_list.append(fragment)
missing_list = []
for item in fragment_list:
aa_fragment = Seq.translate(item)
if aa_fragment in design_aa_list:
design_aa_list.remove(aa_fragment)
else:
missing_list.append(aa_fragment)
if missing_list:
sys.stderr.write('Error: The following oligo sequences do not match a design amino acid sequence\n')
for miss in missing_list:
sys.stderr.write('{0}\n'.format(miss))
if design_aa_list:
sys.stderr.write('Error: The following design sequences do not match an oligo sequence\n')
for design in design_aa_list:
sys.stderr.write('{0}\n'.format(design))
sys.stdout.write('done\n')
def tableify(data, headers=None):
'''ASCII table for a list of strings
Args:
data (list of lists): List of lists for each row of data
headers (list) optional: List of column names
Return:
None
'''
from itertools import izip_longest
if not isinstance(data, list):
return ''
if headers and not isinstance(headers, list):
headers = [headers]
if headers:
data = [headers] + data
# Example color in order to pad for colors
red = "\x1b[31m"
table = []
columns = []
for curr_row in data:
x = izip_longest(*[wrap_string(item) for item in curr_row], fillvalue='')
columns.extend(list(x))
columns = izip_longest(*columns, fillvalue='')
widths = []
for column in columns:
new_row = []
# Need to be a string in order to get length
# column = [str(item) for item in column]
max_len = len(max(column, key=len))
max_len = max(max_len, len(red)*2)
widths.append(max_len)
for item in column:
new_row.append(item.ljust(max_len, ' '))
table.append(new_row)
table = izip_longest(*table)
result = []
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
result.append('| ' + ' | '.join(table.next()) + ' |')
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
for row in table:
result.append('| ' + ' | '.join(row) + ' |')
result.append('+' + '+'.join(['-' * (width+2) for width in widths]) + '+')
for line in result:
print line
def set_pan_lights(self, lights):
for strip, light in izip_longest(self._channel_strips, lights or []):
strip.pan_light.set_control_element(light)
def set_solo_buttons(self, buttons):
for strip, button in izip_longest(self._channel_strips, buttons or []):
if button:
button.set_on_off_values('Mixer.SoloOn', 'Mixer.SoloOff')
strip.set_solo_button(button)
def test_order(iter1, iter2):
for i1, i2 in itertools.izip_longest(iter1, iter2):
assert_equal(i1, i2)
def addStrings2(self, num1, num2):
z = itertools.izip_longest(num1[::-1], num2[::-1], fillvalue='0')
return (i[0] for i in z)
def grouper(iterable, n, fillvalue=None):
"Collect data into fixed-length chunks or blocks"
# grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
args = [iter(iterable)] * n
return izip_longest(fillvalue=fillvalue, *args)
def compareVersion5(self, version1, version2):
splits = (map(int, v.split('.')) for v in (version1, version2))
return cmp(*zip(*itertools.izip_longest(*splits, fillvalue=0)))
def allocate_ip_address(self,
context,
new_addresses,
net_id,
port_id,
reuse_after,
segment_id=None,
version=None,
ip_addresses=None,
subnets=None,
**kwargs):
elevated = context.elevated()
subnets = subnets or []
ip_addresses = ip_addresses or []
ipam_log = kwargs.get('ipam_log', None)
LOG.info("Starting a new IP address(es) allocation. Strategy "
"is {0} - [{1}]".format(
self.get_name(),
utils.pretty_kwargs(network_id=net_id,
port_id=port_id,
new_addresses=new_addresses,
ip_addresses=ip_addresses,
subnets=subnets,
segment_id=segment_id,
version=version)))
def _try_reallocate_ip_address(ipam_log, ip_addr=None):
new_addresses.extend(
self.attempt_to_reallocate_ip(context,
net_id,
port_id,
reuse_after,
version=version,
ip_address=ip_addr,
segment_id=segment_id,
subnets=subnets,
**kwargs))
def _try_allocate_ip_address(ipam_log, ip_addr=None, sub=None):
for retry in xrange(CONF.QUARK.ip_address_retry_max):
attempt = None
if ipam_log:
attempt = ipam_log.make_entry("_try_allocate_ip_address")
LOG.info("Allocating new IP attempt {0} of {1}".format(
retry + 1, CONF.QUARK.ip_address_retry_max))
if not sub:
subnets = self._choose_available_subnet(
elevated,
net_id,
version,
segment_id=segment_id,
ip_address=ip_addr,
reallocated_ips=new_addresses)
else:
subnets = [
self.select_subnet(context,
net_id,
ip_addr,
segment_id,
subnet_ids=[sub])
]
LOG.info("Subnet selection returned {0} viable subnet(s) - "
"IDs: {1}".format(
len(subnets),
", ".join([str(s["id"]) for s in subnets if s])))
try:
self._allocate_ips_from_subnets(context, new_addresses,
net_id, subnets, port_id,
reuse_after, ip_addr,
**kwargs)
except q_exc.IPAddressRetryableFailure:
LOG.exception("Error in allocating IP")
if attempt:
LOG.debug("ATTEMPT FAILED")
attempt.failed()
remaining = CONF.QUARK.ip_address_retry_max - retry - 1
if remaining > 0:
LOG.info("{0} retries remain, retrying...".format(
remaining))
else:
LOG.info("No retries remaing, bailing")
continue
finally:
if attempt:
attempt.end()
break
ip_addresses = [
netaddr.IPAddress(ip_address) for ip_address in ip_addresses
]
if ip_addresses:
for ip_address in ip_addresses:
_try_reallocate_ip_address(ipam_log, ip_address)
else:
_try_reallocate_ip_address(ipam_log)
if self.is_strategy_satisfied(new_addresses):
return
else:
LOG.info("Reallocated addresses {0} but still need more addresses "
"to satisfy strategy {1}. Falling back to creating "
"IPs".format(new_addresses, self.get_name()))
if ip_addresses or subnets:
for ip_address, subnet in itertools.izip_longest(
ip_addresses, subnets):
_try_allocate_ip_address(ipam_log, ip_address, subnet)
else:
_try_allocate_ip_address(ipam_log)
if self.is_strategy_satisfied(new_addresses, allocate_complete=True):
self._notify_new_addresses(context, new_addresses)
LOG.info(
"IPAM for port ID {0} completed with addresses "
"{1}".format(port_id,
[a["address_readable"] for a in new_addresses]))
return
ipam_log.failed()
raise ip_address_failure(net_id)
def __eq__(self, other):
if isinstance(other, Sequence):
return all(a == b for (
a,
b) in it.izip_longest(self, other, fillvalue=fluid.UNDEFINED))
return NotImplemented
return
#*********************************************************************************************
if __name__ == "__main__":
arg_names = [
'me', 'LOG_DIR', 'python_test_name', 'cloudShutdownIsError',
'sandboxIgnoreErrors', 'verbose'
]
# https://docs.python.org/2/library/itertools.html
# Nice..Learning itertools stuff:
# izip_longest: Make an iterator that aggregates elements from each of the iterables.
# If the iterables are of uneven length, missing values are filled-in with fillvalue.
# Iteration continues until the longest iterable is exhausted.
args = dict(itertools.izip_longest(arg_names, sys.argv))
# if you're running this from the command line, remove any existing doneToLine markers
if not args['LOG_DIR']:
LOG_DIR = './sandbox'
else:
LOG_DIR = args['LOG_DIR']
if os.path.exists(LOG_DIR):
print "Checking for any marker files to remove first.. (multi-test cloud log scrape uses and we always leave the droppings)"
for f in glob.glob(LOG_DIR + '/*doneToLine*'):
print "cleaning marker file:", f
os.remove(f)
# if you call from the command line, we'll just pass the first two positionally.
# here's a low budget argsparse :) (args are optional!)
errorMessage = check_sandbox_for_errors(
def set_volume_controls(self, controls):
for control, channel_strip in izip_longest(controls or [],
self._channel_strips):
if channel_strip:
channel_strip.set_volume_control(control)
#!/usr/bin/env python
import sys
from itertools import izip_longest
args = [iter([int(x) for x in line.split()] for line in sys.stdin)] * 3
print sum(
sum(y[0] + y[1] > y[2] for y in [sorted(tri) for tri in zip(*x)])
for x in izip_longest(*args))
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ['ABC', 'DEF', 'Gxx']"
args = [iter(iterable)] * n
return [''.join(x) for x in izip_longest(fillvalue=fillvalue, *args)]
def _calc_maxes(self):
array = [self.header] + self.rows + [self.footer]
return [
max(self._unicode_width(s) for s in ss)
for ss in izip_longest(*array, fillvalue='')
]
import itertools
dna = 'CTGAAATGTTCCGCGAGCCGAACCGATTCACCGCCTAGAAACGTATTGTGCTGGTGTGCGGCGGTTAGAGATATTAGGTAGCGCCGTTACTCTAACATTTCGAATCAACCTTTCAGGGGAGTCACTGCCATCGTAAGTAGAGTACTTAGCATCGATGGCCATGCCTACTAATTACAGGCTGAATGACACTAAACCTTAGTTCACTGACCCGTTTTGTCATGTACTCTTGTGGTATGGGTCTTCAAATTGATCTGATTGGGAAGATAGAAAAACGGCTCTATCCTGGGTCGAGCCTCCCATGAAGCAGTCAAGGGGCCGCGAGGACTTCGATACTTGCCCTGCTCGAGCACATTTTAAAGCTTATTCCACATACTAGACTTACCCCCCGGCGTGTCGTACTGGAAGGTTAAACCTCTTGAGTTGATCTGACAACCTAGACGCGTGCCACGTTGTGTGGGATAGGTCACTCTCATTTCCACGAGGGACCAGAACCTTTGGCAATCCAGTTATTCTGCACTCGTGGCCGCCTCTCCTGGCAGGGGACCGGTAAGTTTGCGTATTCGCCGGGGAGTGGAGACGGATCGTCGTACACTGTTTCGAAAATTTTTGAGGATGGAGAGCAGAGCTATTGGATAAACGCTTGTACAGGTTCAATACTATTAGCAACGTGCCACCGGCACAGCTATCTCTGTTTCGCATGAAAGAGCCGTTAATCACGACGTTTAATCGAAACACATACCGATGGTCTACGAATATTATATCCGATACTAAGTCGGCCGCCGCAGTCCAGACGCCATATCGCTTTGAAGACCCCAAGGCGAACATTAACCGGTACGAGCAACTGCGGAGTGCCCTGCAATAGTCCGTCTGTAAAGGGCCCAGGCTAGGGCAAATAGTCCCTAAAACTAGAGATGGTCAACCGCTATGTGGGGCATTCTCCGTGAGACTCAGCCGTATTACAGTGAGCGTATTCCCAAACTCCCCTTCTGTGTATGACCAGTGTCGCTGCAAATGGACCGAGCAG'
codons = ['A', 'T', 'C', 'G']
p = list(itertools.permutations(['00', '01', '10', '11']))
def decode_binary_string(s):
return ''.join(chr(int(s[i * 8:i * 8 + 8], 2)) for i in range(len(s) // 8))
f = open('bins.txt', 'wb')
for i in p:
k = list(itertools.izip_longest(codons, i))
print k
cp = '%s' % dna
for (c, r) in k:
cp = cp.replace(c, r)
print cp
f.write(cp)
f.write('\n')
f.close()
def _ast_to_dictsql(self, input_ast):
"""
"""
# Add implicit AND operator between expressions if there is no explicit
# operator specified.
ast = []
for token, lookahead in izip_longest(input_ast, input_ast[1:]):
if token.getName() == "boolean":
# only add boolean operator if it is NOT the last token
if lookahead is not None:
ast.append(token)
continue
else:
# add non-boolean token
ast.append(token)
# if next token is boolean, continue so it can be added
if lookahead is None or lookahead.getName() == "boolean":
continue
# if next token is NOT a boolean, add implicit AND
ast.append(ParseResults('and', 'boolean'))
# dictSql stack
dss = {'operator': None, 'val1': None, 'val2': None}
success = True
dse = None
for part, lookahead in izip_longest(ast, ast[1:]):
self._logger.debug("part: %s %s" % (part, part.getName()))
# handle operators joining together expressions
if part.getName() == 'boolean':
op = part[0].lower()
dss['operator'] = op
dss['interpretation'] = {
'interpretation': op,
'operator': op,
'error': False
}
continue
# string expr that we expand to dictsql expression
elif part.getName() == 'expression':
if part.operator in self.match_operators:
tmp_success, dse = self._parse_expr(part)
success = success and tmp_success
else:
tmp_success, dse = self._ast_to_dictsql(part)
success = success and tmp_success
elif part.getName() == 'nested':
tmp_success, dse = self._ast_to_dictsql(part)
success = success and tmp_success
elif part.getName() in ('ipv6_prefix', 'ipv6_address', 'word',
'tag', 'vrf_rt', 'quoted_string'):
# dict sql expression
dse = self._string_to_dictsql(part)
self._logger.debug('string part: %s => %s' % (part, dse))
else:
raise ParserError("Unhandled part in AST: %s %s" %
(part, part.getName()))
if dss['val1'] is None:
self._logger.debug('val1 not set, using dse: %s' %
unicode(dse))
dss['val1'] = dse
else:
self._logger.debug(
"val1 is set, operator is '%s', val2 = dst: %s" %
(dss['operator'], unicode(dse)))
dss['val2'] = dse
if lookahead is not None:
if dss['val1'] is not None and dss['val2'] is not None:
dss = {'operator': None, 'val1': dss, 'val2': None}
# special handling when AST is only one expression, then we overwrite
# the dss with dse
if len(ast) == 1:
dss = dse
if len(ast) == 0:
dss = self._string_to_dictsql(ParseResults('', 'word'))
# return the final composed stack of dictsql expressions
return success, dss
def seek(self, offset, whence=None, partition=None):
"""
Alter the current offset in the consumer, similar to fseek
Arguments:
offset: how much to modify the offset
whence: where to modify it from, default is None
* None is an absolute offset
* 0 is relative to the earliest available offset (head)
* 1 is relative to the current offset
* 2 is relative to the latest known offset (tail)
partition: modify which partition, default is None.
If partition is None, would modify all partitions.
"""
if whence is None: # set an absolute offset
if partition is None:
for tmp_partition in self.offsets:
self.offsets[tmp_partition] = offset
else:
self.offsets[partition] = offset
elif whence == 1: # relative to current position
if partition is None:
for tmp_partition, _offset in self.offsets.items():
self.offsets[tmp_partition] = _offset + offset
else:
self.offsets[partition] += offset
elif whence in (0, 2): # relative to beginning or end
reqs = []
deltas = {}
if partition is None:
# divide the request offset by number of partitions,
# distribute the remained evenly
(delta, rem) = divmod(offset, len(self.offsets))
for tmp_partition, r in izip_longest(self.offsets.keys(),
repeat(1, rem),
fillvalue=0):
deltas[tmp_partition] = delta + r
for tmp_partition in self.offsets.keys():
if whence == 0:
reqs.append(OffsetRequestPayload(self.topic, tmp_partition, -2, 1))
elif whence == 2:
reqs.append(OffsetRequestPayload(self.topic, tmp_partition, -1, 1))
else:
pass
else:
deltas[partition] = offset
if whence == 0:
reqs.append(OffsetRequestPayload(self.topic, partition, -2, 1))
elif whence == 2:
reqs.append(OffsetRequestPayload(self.topic, partition, -1, 1))
else:
pass
resps = self.client.send_offset_request(reqs)
for resp in resps:
self.offsets[resp.partition] = \
resp.offsets[0] + deltas[resp.partition]
else:
raise ValueError('Unexpected value for `whence`, %d' % (whence,))
# Reset queue and fetch offsets since they are invalid
self.fetch_offsets = self.offsets.copy()
self.count_since_commit += 1
if self.auto_commit:
self.commit()
self.queue = queue.Queue()
def zeroPadding(l, fillvalue=PAD_token):
return list(itertools.izip_longest(*l, fillvalue=fillvalue))
#!coding=utf-8
"""
同时迭代多个序列
"""
# 想同时迭代多个序列，每次分别从一个序列中取一个元素。
# 可以使用zip()函数
xpts = [1, 5, 4, 2, 10, 7]
ypts = [101, 78, 37, 15, 62, 99]
for x, y in zip(xpts, ypts): # 迭代的长度和最短序列长度一致
print x, y
# 如果不像迭代的长度和最短序列一致，可以使用itertools.zip_longest()
from itertools import izip_longest
a = [1, 2, 3]
b = ['w', 'x', 'y', 'z']
for i in izip_longest(a, b, fillvalue=0): # 默认填充的是Nonne
print i
# 可以使用zip()打包生成一个字典
headers = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]
s = dict(zip(headers, values))
print s
# 虽然不常见，但是 zip() 可以接受多于两个的序列的参数。 这时候所生成的
# 结果元组中元素个数跟输入序列个数一样。
# 最后强调一点就是， zip() 会创建一个迭代器来作为结果返回。 如果你需要将
# 结对的值存储在列表中，要使用 list() 函数
def __iter__(self):
return itertools.izip_longest(self.X, self.y)
def grouper(n, iterable, padvalue=None):
"""grouper(3, 'abcdefg', 'x') -->
('a','b','c'), ('d','e','f'), ('g','x','x')"""
return izip_longest(*[iter(iterable)]*n, fillvalue=padvalue)
def grouper(iterable, n, fillvalue=None):
args = [iter(iterable)] * n
return izip_longest(*args, fillvalue=fillvalue)
def grouper(iterable, n, fillvalue=None):
args = [iter(iterable)] * n
return (filter(None, values)
for values in izip_longest(fillvalue=fillvalue, *args))
def test_equal(ijk_list, miter):
for ijk, i in itertools.izip_longest(ijk_list, miter):
assert_equal(sm.structured_get_hex(*ijk), i)
def handle_data():
string_to_search = request.form['searchstring']
file_path = request.form['filepath']
x_percentage = request.form['xpercentage']
column_numbers = request.form['column_numbers']
column_numbers = map(int, column_numbers.split(','))
x_percentage=float(x_percentage)
c=0
corpus=[]
response = urllib2.urlopen(file_path)
reader = csv.reader(response, dialect=csv.excel_tab, skipinitialspace=True, delimiter=',', quotechar='"')
header =[]
for row in reader:
st=''
if c!=0:
if row[column_numbers[0]].startswith('INC') :
i=0
while( i< len(column_numbers)):
st = st + row[column_numbers[i]]+';;;'
i +=1
corpus.append(st)
else:
header = row
c = c+1
st = string_to_search
corpus.insert(0,st)
# Removing special characters
new_header=[]
for i in column_numbers:
element = header[i]
new_header.append(element)
lower_case_corpus=[]
for sentence in corpus:
lower_case_corpus.append(sentence.lower())
corpus_without_stopwords = []
i=0
l=len(lower_case_corpus)
while i < l:
lower_case_corpus[i] = lower_case_corpus[i].encode('utf-8')
i+=1
corpus_without_punctuation = remove_punctuation(lower_case_corpus)
corpus_without_stopwords, my_stop_words = remove_stop_words(corpus_without_punctuation)
my_stop_words = set(my_stop_words)
# corpus_without_stopwords is corpus without punctuation also
# corpus_without_stopwords is Array Of Sets
# Add to every set their own 2 and 3 every subsets.
new_corpus_without_stopwords = []
for word, word_with_stopwords in itertools.izip_longest( corpus_without_stopwords, corpus_without_punctuation ):
# s in notebook is now word in our proj
#lower_case_corpus is a list of strings
#and word_with_stopwords is a string
word_to_string = word_with_stopwords
# Replacing punctuation marks with whitespace
#word_to_string is a string
BagOf2words = ConsecutiveBagOfWords(word_to_string, 2)
BagOf3words = ConsecutiveBagOfWords(word_to_string, 3)
BagOf2words = '-' + BagOf2words
BagOf3words = '-' + BagOf3words
pat = r'(?<=\-).+?(?=\-)'
Array2 = re.findall(pat, BagOf2words)
Array3 = re.findall(pat, BagOf3words)
for word2,word3 in itertools.izip_longest(Array2,Array3):
if word2 !=None:
word2=word2.strip()
setWord2 = set(word2.split(' '))
if len(setWord2 & my_stop_words) == 0:
word.append(word2)
if word3 !=None and len(word_to_string.split(' '))!=2:
word3 = word3.strip()
setWord3 = set(word3.split(' '))
if len(setWord3 & my_stop_words) == 0:
word.append(word3)
new_corpus_without_stopwords.append(word)
if not new_corpus_without_stopwords[0]:
return render_template('NotFound.html')
values = BagOfWords(new_corpus_without_stopwords)
final_output_dict = FinalOutput(values, corpus, x_percentage, st )
dict_copy_list = list(final_output_dict)
dict_new_copy_list = []
for item in dict_copy_list:
arr = item.split(';;;')
dict_new_copy_list.append(arr)
if not dict_copy_list:
return render_template('NotFound.html')
else:
return render_template('print.html',dict_copy_list = dict_new_copy_list,st=st,header = new_header,column_numbers=column_numbers)
def line_pairs(lines):
return itertools.izip_longest(
lines, itertools.islice(lines, 1, None), fillvalue=None)
def grouper(size, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * size
return itertools.izip_longest(fillvalue=fillvalue, *args)
def set_track_select_buttons(self, buttons):
for strip, button in izip_longest(self._channel_strips, buttons or []):
if button:
button.set_on_off_values('Mixer.TrackSelected',
'Mixer.TrackUnselected')
strip.set_select_button(button)
def object_info(**kw):
"""Make an object info dict with all fields present."""
infodict = dict(izip_longest(info_fields, [None]))
infodict.update(kw)
return infodict
def _get_printable_row(self, row, maxes):
return '| ' + \
' | '.join([self._format(r, m)
for r, m in izip_longest(row, maxes, fillvalue='')]) + ' |'
def grouper(n, iterable, fillvalue=None):
"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
args = [iter(iterable)] * n
return izip_longest(fillvalue=fillvalue, *args)
