async def get_stations(line: str) -> dict:
# line = 'hokkaido/chitose-line'
logger.debug(f'expected: "hokkaido/chitose-line" got: {line}')
response = await request('GET', urljoin(DOMAIN, line))
if response:
tree = Selector(response.text)
return Dict.name_link(tree, XPATH_TO_STATIONS)
async def extract_station(station: str) -> list:
# station = "/hokkaido/chitose_00078-st/list"
logger.debug(f'expected: "/hokkaido/chitose_00078-st/list" got: {station}')
response = await request(
'GET', JSON_BY_STATION.format(Text.extract_station(station)))
if response:
return get_rooms_info(json.loads(response.text))
def received_hello(self, hello_id):
""" Registers the receival of a hello packet by one of the receivers.
If the link is anomalous, then decrease its frequency again.
Args:
hello_id (int): the id of the hello packet
"""
logger.debug(f"Received Hello Packet : {hello_id}")
if hello_id in list(self.pending_hello_pkts):
pkt_info = self.pending_hello_pkts[hello_id]
freq = pkt_info["freq"]
# if hello freq was increased, decrease it after anomalous behavior is no longer observed
if freq < self.hello_interval:
freqLinks = self.fault_freq[freq]
sId = pkt_info["space_switch_id"]
freqLinks.stageOneLinks[sId].discard(pkt_info["in_link"])
freqLinks.stageThreeLinks[sId].discard(pkt_info["out_link"])
decFreq = freq + 1
decFreqLinks = self.fault_freq[decFreq]
decFreqLinks.stageOneLinks[sId].add(pkt_info["in_link"])
decFreqLinks.stageThreeLinks[sId].add(pkt_info["in_link"])
del self.pending_hello_pkts[hello_id]
fault_links = [
(1, pkt_info["in_link"], pkt_info["space_switch_id"]),
(3, pkt_info["space_switch_id"], pkt_info["out_link"])
]
# Reset anomaly counter for the link
for link in fault_links:
if link in self.anomaly_count:
del self.anomaly_count[link]
else:
logger.info(f"Past threshold arrival of Hello Packet : {hello_id}")
pass
async def get_lines(city: str) -> list:
# city = 'https://www.good-monthly.com/okinawa/search/select_line.html'
logger.debug(f'expected: "https://www.good-monthly.com/okinawa/search/select_line.html" got: {city}')
response = await request('GET', city)
if response:
tree = Selector(response.text)
return Dict.get_name_link(tree)
async def get_stations(line: str) -> list:
# line = 'https://www.good-monthly.com/search/select_station.html?rosen_cd=523'
logger.debug(f'expected: "https://www.good-monthly.com/search/select_station.html?rosen_cd=523" got: {line}')
response = await request('GET', line)
if response:
tree = Selector(response.text)
return Dict.get_name_link(tree)
def read_data(self):
result = {}
for sheet_name in self.sheets:
logger.debug("reading %s" % sheet_name)
if sheet_name not in self.sheets_names:
# 不在自己需要的表明则跳出本次循环，不进行数据获取否则会出错
continue
# 选择表单
self.sh = self.wb[sheet_name]
# 按行读取数据转化为列表
rows_data = list(self.sh.rows)
# print(rows_data)
# 获取表单的表头信息
titles = []
for title in rows_data[0]:
titles.append(title.value)
# print(titles)
logger.info("读取到%s标题表头为：%s" % (sheet_name, titles))
# 定义一个空列表用来存储测试用例
cases = []
for case in rows_data[1:]:
# print(case)
data = []
for cell in case:
# 获取一条测试用例数据
data.append(cell.value)
# print(cell.value, type(cell.value))
case_data = dict(list(zip(titles, data)))
cases.append(case_data)
result[sheet_name] = cases
logger.debug("%s : %s" % (sheet_name, cases))
return result
def create_odds(self, season):
""" Create Odds """
for match in SeasonRepository(self.session).get_matches(season):
odds_list = MatchOddsScraper.extract(match)
if bool(odds_list):
fields = {MatchNotation.odds_list(): odds_list}
MatchRepository(self.session).update(match, fields)
logger.debug('Created odds: ' + str(match))
def create_matches(self, season):
matches = SeasonScraper.extract_matches(season)
for match in matches:
try:
MatchRepository(self.session).insert(match)
except DuplicateKeyError as error:
logger.debug(error)
pass
async def get_lines(city: str) -> dict:
# city = '/hokkaido/'
logger.debug(f'expected: "/hokkaido/" got: {city}')
response = await request('GET', LINK_TO_LINES.format(city))
if response:
with open('error.html', 'w') as f:
f.write(response.text)
tree = Selector(response.text)
return Dict.name_link(tree, XPATH_TO_LINES)
def initialize(self):
self.create_indexes()
for champ in ChampionshipUtil.list_championships():
try:
ChampionshipRepository(self.session).insert(champ)
logger.debug('Championship created: ' + str(champ))
except DuplicateKeyError as e:
logger.warning(e)
pass
ChampionshipManager.create_dir(champ)
logger.debug('Championship DIR created: ' + str(champ))
def request(cls, season, replace=False):
""" Request the season file to the site """
logger.debug('request(): ' + str(season))
if not SeasonManager.is_file_exists(season) or replace:
download = False
r = None
while not download:
try:
logger.debug('Requests: ' + cls.get_url(season))
r = requests.get(cls.get_url(season))
download = True
except Exception as e:
logger.exception(e)
SeasonManager.create_file(season, r.content)
async def broadcaster(self) -> None:
while True:
logger.debug(f"Start mailer for chats: {self.ACTIVE_CHATS}")
if not self.GAME_NEWS_SOURCE:
logger.warning(
"Empty game sources, setup a game sources by adding @Mailer.add_news_source() decorator"
)
informers = [informer() for informer in self.GAME_NEWS_SOURCE]
for sheduled_informer in asyncio.as_completed(informers):
updates = await sheduled_informer
for update in updates:
senders = [
self.send_safe_message(chat, update)
for chat in self.ACTIVE_CHATS
]
await asyncio.gather(*senders)
logger.debug(
f"Mailer successfully ended for chats: {self.ACTIVE_CHATS}")
await asyncio.sleep(self.update_frequency)
def initialize(self, initial_year, final_year):
""" Creates seasons """
self.create_indexes()
for champ in ChampionshipRepository(self.session).list():
for year in range(initial_year, final_year):
season = SeasonBusiness.create(champ,year)
try:
SeasonRepository(self.session).insert(season)
logger.debug('Season created: ' + str(season))
except DuplicateKeyError as e:
logger.warning(e)
pass
SeasonManager.create_dir(season)
logger.debug('Season DIR created: ' + str(season))
def construct_selection(self, args: Union[Dict[str, str],
Dict[str, List[str]]]):
"""Create a WHERE selection in normal disjoint form (AND of ORS) and prepare for the final time selection"""
logger.debug("Constructing a selection where query part with [%s]" %
args)
if not args:
return """ WHERE """
# Normalize to lists all the values in the dictionary
converted = {k: [v] for k, v in args.items() if type(v) != list}
query = {**args, **converted}
# constrct all the equivalences
query = [["{} = '{}'".format(k, x) for x in v]
for k, v in query.items()]
# Construct the ORs
query = ["(%s)" % (" OR ".join(v)) for v in query]
# Construct the AND
query = " AND ".join(query)
# Add the final And for the time selection
query += " AND "
return """ WHERE %s""" % query
async def send_safe_message(self,
chat_id: int,
text: str,
disable_notification: bool = False) -> bool:
"""
Safe messages sender
:param chat_id:
:param text:
:param disable_notification:
:return:
"""
try:
await super(Mailer, self).send_message(
chat_id, text, disable_notification=disable_notification)
except exceptions.BotBlocked:
logger.error(f"Target [ID:{chat_id}]: blocked by user")
self._delete_from_chats(chat_id)
except exceptions.ChatNotFound:
logger.error(f"Target [ID:{chat_id}]: invalid user/chat ID")
self._delete_from_chats(chat_id)
except exceptions.RetryAfter as e:
logger.error(
f"Target [ID:{chat_id}]: Flood limit is exceeded. Sleep {e.timeout} seconds."
)
await asyncio.sleep(e.timeout)
return await self.send_safe_message(chat_id, text)
except exceptions.UserDeactivated:
logger.error(f"Target [ID:{chat_id}]: user/chat is deactivated")
self._delete_from_chats(chat_id)
except exceptions.BotKicked:
logger.error(f"Bot was kicked from the group chat: {chat_id}")
self._delete_from_chats(chat_id)
except exceptions.TelegramAPIError:
logger.exception(f"Target [ID:{chat_id}]: failed")
else:
logger.debug(f"Target [ID:{chat_id}]: success")
return True
return False
async def extract_station(station: str) -> list:
# station = 'https://www.good-monthly.com/search/list_eki.html?rosen_eki_cd=483|7758'
logger.debug(f'expected: "https://www.good-monthly.com/search/list_eki.html?rosen_eki_cd=483|7758" got: {station}')
return await Rqst.get_extract_data(station)
def allotSlots(self, slotNumber):
"""When a time slot expires, send dispatch messages for all
scheduled packets.
Args:
slotNumber (int): The time slot for which dispatching
is being done
"""
for i in range(self.n):
# for each space switch in the given slot
sSwitch = self.network.spaceSwitches[i]
data = sSwitch.getSlotData(slotNumber)
finalQueue = sSwitch.queue
# generate a traffic matrix and get the best bipartite matching
for pkt in sSwitch.queue:
gSrc = pkt.src // self.n
gDest = pkt.dest // self.n
data.reqMat[gSrc][gDest] += 1
val, matching = mtchr.Matcher(data.reqMat).solve()
data.finalState = matching
# for each packet in the queue, check if it can be scheduled
for pkt in sSwitch.queue:
# check if packet src/dest matches space switch's config for this timeslot
if pkt.dest // self.n == matching[pkt.src // self.n]:
if pkt.src in data.transmissions.keys():
if pkt.wavelength in data.transmissions[
pkt.src].keys():
trnsmsnCount = data.transmissions[pkt.src][
pkt.wavelength]
else:
data.transmissions[pkt.src][pkt.wavelength] = 0
trnsmsnCount = data.transmissions[pkt.src][
pkt.wavelength]
else:
data.transmissions[pkt.src] = {}
data.transmissions[pkt.src]['count'] = 0
data.transmissions[pkt.src][pkt.wavelength] = 0
trnsmsnCount = data.transmissions[pkt.src][
pkt.wavelength]
if trnsmsnCount < MAX_TRANSMISSION_COUNT:
src = self.network.transmitters[pkt.src]
pkt.dispatchSlot = slotNumber
pkt.schedulingDelay = ((pkt.dispatchSlot + 1) *
self.slot) - pkt.arrivalTime
logger.debug(
f"[Packet {pkt.pktId}] : Wavelength Assigned = {pkt.wavelength}"
)
logger.debug(
f"[Packet {pkt.pktId}] : Space Switch Assigned = {i}"
)
logger.debug(
f"[Packet {pkt.pktId}] : Time Slot Assigned = {slotNumber}"
)
data.transmissions[pkt.src][pkt.wavelength] += 1
data.transmissions[pkt.src]['count'] += 1
src.onSchedule(pkt)
finalQueue.remove(pkt)
# queue with after removing scheduled packets
sSwitch.queue = finalQueue
async def _add_to_active_chat(self, msg: types.Message):
self.ACTIVE_CHATS.add(msg.chat.id)
if not Chats.get_or_none(Chats.recipient == msg.chat.id):
Chats.insert(recipient=msg.chat.id).execute()
logger.debug(f"New subsciber, chat id {msg.chat.id}")
await self._welcome_msg(msg)
