def find(self, p: [str], d: collections.defaultdict):
if d is None:
return None
if len(p) == 1:
return d.get(p[0])
return self.find(p[1:], d.get(p[0]))
def clear_chat_data_stonk(chat_data: defaultdict) -> bool:
stonks = chat_data.get(conf.INTERNALS['stock'], None)
daily = get_daily_dict(chat_data)
cleared = False
if stonks and len(stonks) > 0:
chat_data[conf.INTERNALS['stock']] = factory_defaultdict()
cleared = True
if daily and len(daily) > 0:
rise = daily.get(conf.JOBS['check_rise_fall_day']['dict']['rise'],
None)
fall = daily.get(conf.JOBS['check_rise_fall_day']['dict']['fall'],
None)
if rise:
if len(rise) > 0:
chat_data[conf.JOBS['check_rise_fall_day']['dict']
['daily']][conf.JOBS['check_rise_fall_day']['dict']
['rise']] = factory_defaultdict()
cleared = True
if fall:
if len(fall) > 0:
chat_data[conf.JOBS['check_rise_fall_day']['dict']
['daily']][conf.JOBS['check_rise_fall_day']['dict']
['fall']] = factory_defaultdict()
cleared = True
return cleared
def procedure_grille(length: int, inds: tuple, industrie: defaultdict,
bdd: sqlite3.Cursor):
i = 0
while True:
if inds == (0, 0):
id1 = (inds[0] + 1, inds[1])
id2 = (inds[0], inds[1] + 1)
[industrie[id1].reception.put(x) for x in industrie[inds].memoire]
[industrie[id2].reception.put(x) for x in industrie[inds].memoire]
else:
print("lecture:", inds, file=sys.stderr)
grille = industrie[inds].reception.get()
print(type(grille))
for grid in industrie.get(inds).memooire:
calcul = add(grille, grid)
if calcul is not None:
id1 = (inds[0] + 1, inds[1])
id2 = (inds[0], inds[1] + 1)
industrie[id1].reception.put(calcul)
industrie[id2].reception.put(calcul)
if inds == (length, length):
grille = industrie[inds].reception.get()
print(grille)
i += 1
cmd = "INSERT INTO Mokrwaze(mo_num, ligne) VALUES (?, ?)"
bdd.executemany(cmd, ["".join(x) for x in grille])
def __init__(self, metadata_list: List[AudioClipMetadata],
label_map: defaultdict, **kwargs):
super().__init__(**kwargs)
self.metadata_list = metadata_list
self.label_map = label_map
self.vocab = {v: k for k, v in label_map.items()}
self.vocab[label_map.get(None)] = NEGATIVE_CLASS
def find_users(users: defaultdict, city_id, cities, needed_cities):
response = pool.get_next_api().users.search(city = city_id
, count = 1000
, v="5.44"
)
count = response["count"]
if count == 0:
print ("no users")
return
# Если города ещё нет в базе пользователей
if users.get(city_id) == None:
users[city_id] = defaultdict()
users[city_id]["users"] = set()
users[city_id]["count"] = 0
# Если скачано меньше 95% людей из этого города.
if abs(count - len(users[city_id]["users"])) * 100 / count > 5:
print( "percent: " , abs(count - len(users[city_id]["users"])) * 100 / count)
# Если в базе есть люди из этого города
if len(users[city_id]["users"]) != 0:
users_before = set(users[city_id]["users"])
else:
users_before = set()
# Добавляем людей, полученных в результате запроса в базу и в users_before
for item in response["items"]:
users_before.add(item["id"])
users[city_id]["users"].add(item["id"])
for user_id in users_before:
try:
response = pool.get_next_api().friends.get( user_id = user_id
, order = "random"
, fields = "city"
, v="5.44")
except vk.exceptions.VkAPIError as err:
print(err)
users[city_id]["users"].discard(user_id)
continue
add_users(users, response["items"], needed_cities)
print("users in ", cities[city_id]["title"], " now: ", len(users[city_id]["users"]))
# print(response["items"])
dumpData(users,usersFile)
if (abs(count - len(users[city_id]["users"])) * 100 / count < 5) or (len(users[city_id]["users"]) > count):
print("less then 3% ")
break
sleep(randint(1,3))
else:
print ("City is exists")
def get_childs(comments_dict: defaultdict, id_: int, tree: dict) -> dict:
list_ = comments_dict.get(id_, '')
if not list_:
return {}
z = {}
for i in list_:
z = {
**z,
**{
i.id: (i.text, i.created_at.timestamp(),
Comment.get_childs(comments_dict, i.id, tree))
}
}
return z
def make_sentences_vectors(pre_processed_sentences: list,
embeddings: defaultdict,
embedding_dim: int) -> list:
"""
:param pre_processed_sentences:
:param embeddings:
:param embedding_dim:
:return:
"""
sentences_vectors = []
for sent in pre_processed_sentences:
if len(sent) > 0:
v = sum([
embeddings.get(word, np.zeros(embedding_dim, ))
for word in sent.split()
]) / (len(sent.split()) + 0.001)
else:
v = np.zeros(embedding_dim, )
sentences_vectors.append(v)
return sentences_vectors
class KVS(object):
'''Get/Put/View implements a client-server key value store. If no
value is associated with a given key, clients will block on get or
view until a value is available. Multiple values may be associated
with any given key.
This is, by design, a very simple, lightweight service that only
depends on standard Python modules.
'''
def __init__(self, getIndex=0, viewIndex=-1):
self.getIndex, self.viewIndex = getIndex, viewIndex #TODO: Add sanity checks?
self.key2mon = DD(lambda:DD(set)) # Maps a normal key to keys that monitor it.
self.monkeys = set() # List of monitor keys.
# store and waiters are mutually exclusive, and could be kept in the same place
self.store = DD(list)
self.waiters = DD(list)
self.opCounts = {b'get': 0, b'put': 0, b'view': 0, b'wait': 0}
self.ac, self.rc = 0, 0
def _doMonkeys(self, op, k):
# Don't monitor operations on monitor keys.
if k in self.monkeys: return
#DEBUGOFF logger.debug('doMonkeys: %s %s %s', op, k, repr(self.key2mon[True][op] | self.key2mon[k][op]))
for p in (True, k):
for mk in self.key2mon[p][op]:
self.put(mk, (b'ASTR', repr((op, k))))
def dump(self):
'''Utility function that returns a snapshot of the KV store.'''
def vrep(v):
t = v[0].tobytes()
# Omit or truncate some values, in which cases add the original length as a third value
if v == b'JSON' or t == b'HTML': return (t, v[1].tobytes())
if t != b'ASTR': return (t, None, len(v[1]))
if v[1][:6].tobytes().lower() == '<html>': return (t, v[1].tobytes()) # for backwards compatibility only
if len(v[1]) > 50: return (t, v[1][:24].tobytes() + '...' + v[1][-23:].tobytes(), len(v[1]))
return (t, v[1].tobytes())
return PDS(([self.opCounts[b'get'], self.opCounts[b'put'], self.opCounts[b'view'], self.opCounts[b'wait'], self.ac, self.rc], [(k, len(v)) for k, v in self.waiters.items() if v], [(k, len(vv), vrep(vv[-1])) for k, vv in self.store.items() if vv]))
def wait(self, waiter):
'''Atomically (remove and) return a value associated with key k. If
none, block.'''
#DEBUGOFF logger.debug('wait: %s, %s', repr(waiter.key), repr(waiter.op))
self._doMonkeys(waiter.op, waiter.key)
vv = self.store.get(waiter.key)
if vv:
if waiter.delete:
v = vv.pop(self.getIndex)
if not vv: self.store.pop(waiter.key)
else:
v = vv[self.viewIndex]
self.opCounts[waiter.op] += 1
#DEBUGOFF logger.debug('_gv (%s): %s => %s (%d)', waiter.op, waiter.key, repr(v[0]), len(v[1]))
waiter.handler(v)
else:
self.waiters[waiter.key].append(waiter)
self.opCounts[b'wait'] += 1
self._doMonkeys(b'wait', waiter.key)
#DEBUGOFF logger.debug('(%s) %s acquiring', repr(waiter), repr(s))
self.ac += 1
def cancel_wait(self, waiter):
ww = self.waiters.get(waiter.key)
if ww:
try:
ww.remove(waiter)
except ValueError:
pass
if not ww: self.waiters.pop(waiter.key)
def monkey(self, mkey, v):
'''Make Mkey a monitor key. Value encodes what events to monitor and
for which key:
Key:Events
Whenever a listed event occurs for "Key", a put will be done
to "Mkey" with the value "<event> <key>". If 'Key' is empty,
the events listed will be monitored for all keys. 'Events' is
some subset of 'g', 'p', 'v' and 'w' (get, put, view and
wait). Monitoring of any event *not* listed is turned off for
the specified key.
'''
#DEBUGOFF logger.debug('monkey: %s %s', mkey, v)
if b':' not in v: return #TODO: Add some sort of error handling?
self.monkeys.add(mkey)
k, events = v.rsplit(b':', 1)
if not k: k = True
for e, op in [(b'g', b'get'), (b'p', b'put'), (b'v', b'view'), (b'w', b'wait')]:
if e in events:
self.key2mon[k][op].add(mkey)
else:
try: self.key2mon[k][op].remove(mkey)
except KeyError: pass
#DEBUGOFF logger.debug('monkey: %s', repr(self.key2mon))
def put(self, k, v):
'''Add value v to those associated with the key k.'''
#DEBUGOFF logger.debug('put: %s, %s', repr(k), repr(v))
self.opCounts[b'put'] += 1
ww = self.waiters.get(k) # No waiters is probably most common, so optimize for
# that. ww will be None if no waiters have been
# registered for key k.
consumed = False
if ww:
while ww:
waiter = ww.pop(0)
#DEBUGOFF logger.debug('%s releasing', repr(waiter))
self.rc += 1
self.opCounts[waiter.op] += 1
waiter.handler(v)
if waiter.delete:
consumed = True
break
if not ww: self.waiters.pop(k)
if not consumed: self.store[k].append(v)
self._doMonkeys(b'put', k)
def __init__(self, label_map: defaultdict, *args, **kwargs):
super().__init__(*args, **kwargs)
self.label_map = label_map
self.vocab = {v: k for k, v in label_map.items()}
self.vocab[label_map.get(None)] = NEGATIVE_CLASS
def usingGraphs(self, d: defaultdict):
print(" graph is defaultdict -> ", d)
print(" keys -> ", type(d.keys()), " d.get(a) -> ", d.get('a'))
# get the edges
for key in d.keys():
print(" graph key -> ", key, "graphs edges -> ", d[key])
def _create_tree_recursive(self, root_id: str,
parent_to_child_map: defaultdict, tree: Tree):
for child_id in parent_to_child_map.get(root_id, []):
tree.create_node(child_id, child_id, parent=root_id)
self._create_tree_recursive(child_id, parent_to_child_map, tree)
