def __init__(self, carte):
"""Avec un robot en stand alone"""
assert isinstance(
carte,
Carte) # astuce pour ide pour intellisence---pff longue recherche
self.carte = carte
self._chemin = os.path.join("cartes", (self.carte.nom + "pre"))
self.robots = Robots()
self.partie_commencee = False
self.precedent_position = PrecentePosition(" ")
self.dernier_joueur = ""
class SiteReader:
def __init__(self, site):
self._site = site
self._pages = []
self._robot = Robots(site)
def read(self):
if not self._robot.can_view('/'):
raise ConnectionError("You are not allowed to scrape this site.")
page = Page()
request = requests.get(self._site)
page.set_request(request)
page.set_html(request.text)
soup = BeautifulSoup(page.get_html(), 'html.parser')
for link in (item['href'] for item in soup.find_all('a', href=True)
if item['href'] and item['href'] != "#"
and item['href'] != '/'):
if self._robot.can_view(link) and link not in page.get_links():
if link[0] == "/":
link = f"{self._site}{link}"
page.add_link(link)
self.add_page(page)
return page
# This is a TEST method - it is ONLY designed to crawl the first page of the main sites linked pages.
def crawl(self):
if len(self._pages) > 0:
crawler = Crawler(self._pages[0].get_links())
for result in crawler.begin_crawl():
page = Page(site=self._site)
page.set_url(result["url"])
page.set_html(result["data"])
page.parse_page(self._robot)
print(f'{page.get_url()} has {len(page.get_links())} links')
self.add_page(page)
# print(self._pages)
def add_page(self, page):
self._pages.append(page)
def remove_page(self, page):
self._pages.remove(page)
def get_pages(self):
return self._pages
def crawl_control(self):
file_io.initialize_log()
current_wave = 0
while True:
# if empty, move to next wave
if self.frontier.is_empty():
self.frontier.change_wave(current_wave + 1)
# if still empty, finished
if self.frontier.is_empty():
self.finish()
return "Finished"
current_wave, score, url = self.frontier.frontier_pop()
# get protocol, domain
domain = self.canonicalizer.get_domain(url)
# check robots.txt
if domain not in self.robots:
try:
robots = Robots("http://" + domain + "/robots.txt")
self.robots[domain] = robots
if robots.delay > self.time_out:
self.robots_delay[domain] = self.time_out
else:
self.robots_delay[domain] = robots.delay
self.robots_timer[domain] = datetime.now()
except Exception as e:
error = "Read robots.txt error:\n{0}\nError: {1}\n\n".format(
"http://" + domain + "/robots.txt", e)
file_io.write_error_info(error)
continue
delay = self.robots_delay[domain]
# check if can fetch
if not self.robots[domain].can_fetch(url):
not_allowed = "Not Allowed: {}\n".format(url)
print(not_allowed)
file_io.write_not_allowed(not_allowed)
continue
else:
# politeness
since_last_crawl = datetime.now() - self.robots_timer[domain]
if since_last_crawl.total_seconds() < delay:
time.sleep(delay - since_last_crawl.total_seconds())
print("Current: " + url)
file_io.write_current_link(url)
# print time interval
# print((datetime.now() - self.robots_timer[domain]).total_seconds())
# get page header
try:
url_head = self.get_head(url)
if url_head.status_code == 404:
error = "Status error:\n{0}\nError code: {1}\n\n".format(
url, url_head.status_code)
file_io.write_error_info(error)
continue
except Exception as e:
error = "Read head error:\n{0}\nError: {1}\n\n".format(
url, e)
file_io.write_error_info(error)
self.robots_timer[domain] = datetime.now()
continue
header = dict(url_head.headers)
# get content type
if "content-type" in url_head.headers:
content_type = url_head.headers["content-type"]
else:
content_type = "text/html"
# crawl html type
if "text/html" not in content_type:
continue
else:
# read page
try:
soup, raw_html, base_url, lang = self.get_page(url)
self.robots_timer[domain] = datetime.now()
# whether we should crawl, language, black list
if not self.page_should_crawl(base_url, lang):
continue
# multiple redirected url
if base_url in self.crawled_links:
self.frontier.objects[base_url].in_links.update(
self.frontier.objects[url].in_links)
error = "Multiple redirected URL:\nURL: {0}\nRedirected URL: {1}\n\n".format(
url, base_url)
file_io.write_error_info(error)
continue
else:
self.crawled_links.add(base_url)
frontier_item = FrontierItem(base_url)
frontier_item.in_links = self.frontier.objects[
url].in_links
self.frontier.objects[base_url] = frontier_item
self.redirected_map[url] = base_url
except Exception as e:
error = "Read page error:\n{0}\nError: {1}\n\n".format(
url, e)
file_io.write_error_info(error)
self.robots_timer[domain] = datetime.now()
continue
raw_out_links = self.get_out_links(soup)
out_links = []
# write as ap format
text = self.extract_text(soup)
if len(soup.select("title")) != 0:
title = soup.select("title")[0].get_text()
else:
title = None
file_io.write_ap(base_url, text, header, title)
file_io.write_raw_html({base_url: raw_html})
for link in raw_out_links:
processed_link = self.canonicalizer.canonicalize(
base_url, domain, link)
file_io.write_canonicalization(link, processed_link)
# if link is not empty
if len(processed_link) != 0:
out_links.append(processed_link)
if processed_link not in self.all_links:
# new frontier item
frontier_item = FrontierItem(
processed_link, link)
frontier_item.update_in_links(base_url)
self.frontier.frontier_put(
frontier_item, current_wave + 1)
self.all_links.add(processed_link)
else:
# update in links
if processed_link in self.redirected_map:
redirected = self.redirected_map[
processed_link]
self.frontier.frontier_update_inlinks(
redirected, base_url)
else:
self.frontier.frontier_update_inlinks(
processed_link, base_url)
file_io.write_all_out_links({base_url: out_links})
self.count += 1
print(self.count, current_wave, url, score)
file_io.write_log(self.count, current_wave, url, score)
file_io.write_final_info(len(self.crawled_links),
len(self.all_links))
if self.count == self.total_count:
self.finish()
print("Finished")
return
def __init__(self, local_folder_name, url_list, user_agent):
self.queue = url_list
self.local_folder = local_folder_name
self.robot_parser = Robots(user_agent)
self.backlinks = {}
class Crawler:
def __init__(self, local_folder_name, url_list, user_agent):
self.queue = url_list
self.local_folder = local_folder_name
self.robot_parser = Robots(user_agent)
self.backlinks = {}
def add_to_backlinks(self, link, reference):
if link in self.backlinks.keys():
self.backlinks[link].append(reference)
else:
self.backlinks[link] = list()
def is_absolute(self, url):
return bool(urlparse(url).netloc)
def get_root(self, url):
return urlparse(url).scheme + "://" + urlparse(url).netloc
def process_queue(self):
count = 0
while self.queue and count < 2000:
link = self.queue.pop(0)
print(link)
if not self.is_visited(link):
count = count + 1
try:
root = self.get_root(link)
if root != self.robot_parser.get_url():
self.robot_parser.set_url(root)
if self.robot_parser.check_robots_txt():
if self.robot_parser.can_parse_file(link):
html_page = urllib.request.urlopen(
link).read().decode('utf-8')
if self.robot_parser.can_parse_page(
html_page, "nofollow"):
self.save_page(html_page, link)
self.parse_page(html_page, link)
except Exception as ex:
print('Exception occurred at file ' + link)
print(ex)
print(self.backlinks)
backlinks_file = open("backlinks.json", "w+")
backlinks_file.write(json.dumps(self.backlinks))
backlinks_file.close()
def is_visited(self, link):
if not os.path.exists(self.local_folder + "/" +
link.replace("://", "/")):
return False
return True
def parse_page(self, page, link):
doc = PyQuery(page)
hrefs = doc.find('a[href]')
for href in hrefs:
href_attr = PyQuery(href).attr("href")
href_no_qs = href_attr.split("?")[0]
if href_no_qs not in self.queue:
if not self.is_absolute(href_attr):
self.queue.append(urljoin(link, href_no_qs))
self.add_to_backlinks(link, urljoin(link, href_no_qs))
else:
self.queue.append(href_no_qs)
self.add_to_backlinks(link, href_no_qs)
def save_page(self, page, link):
local_folder = self.local_folder
path_folders = link.replace("://", "/").split("/")
path_folders = [i for i in path_folders if i]
actual_folder = local_folder + "/"
for x in range(len(path_folders) - 1):
if len(path_folders[x]) > 0:
actual_folder = actual_folder + "/" + path_folders[x]
if not os.path.exists(actual_folder):
os.mkdir(actual_folder)
actual_folder = actual_folder + "/" + path_folders[len(path_folders) -
1]
if not os.path.exists(actual_folder):
f = open(actual_folder + ".html", "w+", encoding="utf-8")
f.write(page)
f.close()
def __init__(self, site):
self._site = site
self._pages = []
self._robot = Robots(site)
class Labyrinthe:
"""Ce module contient la classe Jeux et mouvement."""
clear = lambda: os.system(
'cls') #clear console peut être creer une classe outil
#Ce sont les différents status après le mouvement du robot pour le ruturn
#de la méthode _move
_STATUS_Mouvement = {0:'Bientôt arrivé Courage',\
1:'Vous ne pouvez pas aller là bas',\
2:'Félicitations ! Vous avez gagné !',\
3:'A Bientôt, la partie a été savegardé pour plus tard',\
4:'Ce n\'est pas la bonne valeur',\
5:'(C) Commencer la partie\n'\
'(A) afficher carte ou refraichir\n'
'(N+) déplacer vers le nord\n'\
'(E+) déplacer vers l''est\n'\
'(S+) déplacer vers le sud\n'\
'(O+) déplacer vers l\'ouest\n'\
'(Q) quitter\n'\
'(P*) percer une porte a la place d''un mur\n'\
'(M*) construire un mur a la place porte\n'\
'* cardinalité NESO ie: ME or PS\n'
'+ nombre de pas se 1 à 10 ie: N4, O1'}
def __init__(self, carte):
"""Avec un robot en stand alone"""
assert isinstance(
carte,
Carte) # astuce pour ide pour intellisence---pff longue recherche
self.carte = carte
self._chemin = os.path.join("cartes", (self.carte.nom + "pre"))
self.robots = Robots()
self.partie_commencee = False
self.precedent_position = PrecentePosition(" ")
self.dernier_joueur = ""
def get_help(self):
"""obtenir l'aide"""
return Labyrinthe._STATUS_Mouvement.get(5)
def ajouter_robot(self, symbole, joueur, thread_name):
""" Ajourter un robot """
x, y = self.carte.robot_random_position(
symbole) #make a random posisition
self.robots.ajouter_robot(
Robot.construct_by_position(x, y, symbole, joueur, thread_name))
def enlever_robot(self, joueur):
""""Remove robot"""
self.carte.grille[self.robots.get_robot_name(joueur).position_y][
self.robots.get_robot_name(joueur).position_x] = ' '
self.robots.enlever_robot(joueur)
def porte_en_mur(self, step_x, step_y, joueur):
""""transforme porte en mur"""
#check if porte
if self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x] \
== Obstacle.collection_obstacle.get(".").symbole:
self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x] \
= Obstacle.collection_obstacle.get("O").symbole
def mur_en_porte(self, step_x, step_y, joueur):
""""transforme mur en porte """
#check if mur
if self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x] \
== Obstacle.collection_obstacle.get("O").symbole:
self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x] \
= Obstacle.collection_obstacle.get(".").symbole
def move(self, step_x, step_y, joueur):
""" to expose the methode mouvement (pour conserver le code d
origine)
"""
return self._move(step_x, step_y, joueur)
def _move(self, step_x, step_y, joueur):
""" mouvement du robot """
try:
if len(self.carte.grille) > ( self.robots.get_robot_name(joueur).position_y + step_y) \
and (self.robots.get_robot_name(joueur).position_y + step_y) >= 0: #test is on est toujours dans la grille
if len(self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y]) >\
(self.robots.get_robot_name(joueur).position_x + step_x) \
and (self.robots.get_robot_name(joueur).position_x + step_x) >= 0:
if Obstacle.collection_obstacle.get( \
self.carte.grille[self.robots.get_robot_name(joueur).position_y+ step_y][self.robots.get_robot_name(joueur).position_x + step_x]).fin:
#test si la partie est finieS
return 2 #on retourne c'est fini voir _STATUS_Mouvement
else:
pass
if not Obstacle.collection_obstacle.get(\
self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x]).bloquant:
# restauration du précédent symbole
self.carte.grille[self.robots.get_robot_name(joueur).position_y][self.robots.get_robot_name(joueur).position_x] \
= self.robots.get_robot_name(joueur).prev_symbole
# sauvegarde du symbole qui va être écrasé par le robot (X)
self.robots.get_robot_name(joueur).prev_symbole \
= self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x]
#mettre le robot a sa nouvelle place avec le symbole dans la collection
self.carte.grille[self.robots.get_robot_name(joueur).position_y + step_y][self.robots.get_robot_name(joueur).position_x + step_x] \
= self.robots.get_robot_name(joueur).symbole #Obstacle.collection_obstacle['X'].symbole
#self.carte.coord_debut_x, self.carte.coord_debut_y \
# = self.robots.get_robot_name(joueur).position_x + step_x, self.robots.get_robot_name(joueur).position_y + step_y
self.robots.get_robot_name(joueur).position_x, self.robots.get_robot_name(joueur).position_y \
= self.robots.get_robot_name(joueur).position_x + step_x, self.robots.get_robot_name(joueur).position_y + step_y
#self.carte.enregistre_partie()
#self.enregistrer_labyrinthe()
return 0 # on retourne on continue voir _STATUS_Mouvement
else:
return 1 #on retourne on continue voir _STATUS_Mouvement
else:
return 1 #on retourne on continue voir _STATUS_Mouvement
else:
return 1 #on retourne on continue voir _STATUS_Mouvement
except Exception:
e = sys.exc_info()[0]
print("aie aie encore un insecte électrocuté\n{}".format(e))
def afficher_carte_robot(self, joueur):
""" affichage de la carte avec le robot du joueur de la thread """
#copie de la grille
grille = copy.deepcopy(self.carte.grille)
#vision courrante du joueur
#mettre un grand X pour son propre Robot
grille[self.robots.get_robot_name(joueur).position_y][
self.robots.get_robot_name(joueur).position_x] = 'X'
return '\n'.join(map(''.join, grille))
def enregistrer_labyrinthe(self):
"""Enregistrer le status du labyrinthe"""
with open(self._chemin, 'wb') as fichier:
mon_pickler = pickle.Pickler(fichier)
mon_pickler.dump(self)
def restaurer_labyrinthe(self):
"""Restaurer le status du labyrinthe"""
with open(self._chemin, 'rb') as fichier:
mon_depickler = pickle.Unpickler(fichier)
# Lecture des objets contenus dans le fichier...
ret = mon_depickler.load()
return ret
def main():
game = Robots()
game.set_object()
game.print_map()
while True:
game.move_player()
game.move_enemy()
if game.check():
game.print_map()
if game.game_over():
game.__init__()
game.set_object()
game.print_map()
else:
break
else:
game.print_map()