def react_to(self, request):
"""
-----------------------------------------------------------------------------------
Bi.react_to(self,request):
# Params: request là đoạn text
# Chức năng: phân tích đoạn text để gọi chức năng thực hiện phù hợp
# Trả về:
+ thành công: dữ liệu trả về của chức năng đã thực hiên
+ exception: dữ liệu trả về khi xảy ra exception trong chức năng đã thực hiện
-----------------------------------------------------------------------------------
"""
request=request.lower()
if request=='':
return
if 'bi ơi' in request:
return self.multiprocess_speak('Mình đây, bạn cần gì')
elif 'làm được gì' in request or 'có thể làm gì' in request:
return self.multiprocess_speak('Tôi có thể trò chuyện, làm toán tiểu học, tìm kiếm, mở video, thay đổi hình nền và trả lời những câu hỏi của bạn')
elif "tạm biệt bạn" == request or "tạm biệt" == request:
return self.multiprocess_speak('Bái bai')
elif "hiện tại" in request or "mấy giờ" in request or 'bây giờ là' in request:
response='Bây giờ là '+self.get_time()
self.multiprocess_speak(response)
return response
elif 'hôm nay là' in request or 'ngày mấy' in request:
response='Hôm nay là '+self.get_date()
self.multiprocess_speak(response)
return response
elif 'tìm' in request:
if request.split(' ').index('tìm')==0:
return self.search_google(request.replace('tìm',''))
return self.search_google(request.split(" tìm ",1)[1])
elif 'mở' in request or 'phát' in request:
return self.play_youtube(request)
elif 'gửi mail' in request or 'gởi mail' in request:
self.speak('Bạn muốn gửi mail cho ai')
destination=self.listen()
self.speak('Bạn muốn đặt tiêu đề là gì')
subject=self.listen()
self.speak('Nội dung của mail là gì')
content=self.listen()
return self.send_email(destination,subject,content)
elif 'đổi ảnh' in request or 'thay ảnh' in request or 'đổi hình' in request or 'thay hình' in request or 'đổi nền' in request or 'thay nền' in request:
return self.change_random_walpaper()
elif 'thời tiết' in request:
return self.wheather_forecast()
elif ('là gì' in request or 'là ai' in request) and 'bạn là ai' not in request:
return self.define(request.replace('là gì','').replace('là ai',''))
else:
return self.multiprocess_speak(str(self.brain.get_response(request)))
def path_in_cache(self, request):
if self.cache_folder is None:
return (None)
else:
if self.cache_organizer is None:
return (self.cache_folder + request.replace("/", ""))
else:
path_within_cache = self.cache_organizer(request) + "/"
if not os.path.exists(self.cache_folder + path_within_cache):
Path(self.cache_folder +
path_within_cache).mkdir(parents=True)
return (self.cache_folder + path_within_cache +
request.replace("/", ""))
def process_response(self, request, response, spider):
"""Interesting to check cached page"""
# Check if Ip has been banned
is_ban = getattr(spider, 'response_is_ban')
ban = is_ban(request, response)
# If Ip has been banned
if ban:
# Get url or redirected url
url = request.meta.get(
'redirect_urls',
[request.url])[0] if request.meta else request.url
self.set_proxy(request)
request.meta[NEUKOLLN_META_BANNED_KEY] = ban
request.meta[
NEUKOLLN_META_REFRESH_CACHE_KEY] = True # refresh cache!!!
request.dont_filter = True # DON'T FILTER!!!
request = request.replace(url=url)
# [INFO] Alert user
logger.info(
"[STORMPROXIES_MIDDLEWARE][PROCESS_RESPONSE][NEUKOLLN] Response has been detected as banned; response.url: %s; retry this url: %s; request: %s"
% (response.url, url, str(request)))
return request
# Return response and process it
return response
def update(self, request):
#Update the catalog server
self.safetyLock.acquire()
count = 0
#If there are no active instances return false
if len(self.instances) <= 0:
print("No instances registered")
return "False"
#Send request to all instances
for instance in self.instances:
instance.update_queue.append(request)
for instance in self.instances:
request = instance.update_queue.pop()
request = request.replace(" ", "/")
endpoint = instance.returnInstance()
request_final = endpoint + request
logging.info(request_final)
print(request_final)
val = urllib.request.urlopen(request_final).read().decode()
if val == "True":
count += 1
#Handling case where no server could perform the update
if count > 0:
self.safetyLock.release()
return "True"
else:
self.safetyLock.release()
return "False"
def modifyBitrate(request, fd, bitrate, fd_to_tp):
logging.info("modifying birate")
if request.find(b'-Frag') != -1:
''' this is a chunk request'''
logging.info("this is a chunk request")
if len(bitrate) == 0:
logging.debug("ERROR: bitrate is not ready yet;")
return request
br_client = 0
if fd in fd_to_tp:
# maximum bitrate for this client
br_client = fd_to_tp[fd][0] * 2 / 3
br_chosen = 0
for br in bitrate:
if br <= br_client and br > br_chosen:
br_chosen = br
if br_chosen < bitrate[0]:
""" maintain the mininal bitrate """
br_chosen = bitrate[0]
logging.info("client tp: {}, chosen tp: {}".format(br_client, br_chosen))
old_chunk = re.search(b'/[0-9]+Seg', request).group()
new_chunk = "/{}Seg".format(br_chosen).encode('utf-8')
logging.info("from {} to {}".format(old_chunk, new_chunk))
request = request.replace(old_chunk, new_chunk)
return request
def apply_updates(self, instance):
while len(instance.update_queue) != 0:
request = instance.update_queue.pop()
request = request.replace(" ", "/")
endpoint = instance.returnInstance()
request_final = endpoint + request
print(request_final)
val = urllib.request.urlopen(request_final).read().decode()
def _reset_request(self, request, response=None):
meta = request.meta
failed_times = meta.get('failed_times', 0)
logger.warning('raquest failed %s times' % failed_times)
if failed_times > self.failed_times_limit:
return response
# raise IgnoreRequest
meta['failed_times'] = failed_times + 1
return request.replace(url=self.reset_url, dont_filter=True, meta=meta)
def modifyF4M(request):
""" modify the f4m client request """
if request.find(b"/big_buck_bunny.f4m") != -1:
logging.info("this is a f4m")
request = request.replace(
b'big_buck_bunny.f4m',
b'big_buck_bunny_nolist.f4m'
)
return request
def process_response(self, request, response, spider):
if response.status == 403:
logger.info("process_response抓到403")
self.__class__.proxy_tool.move_to_black_list(request.meta["proxy"])
#self.__class__.proxy_tool.fresh()
self.__class__.proxy_tool.fetch_one_proxy_from_list()
meta = request.meta
meta["proxy"] = self.__class__.proxy_tool.current_proxy.proxy_url
return request.replace(meta=meta, dont_filter=True)
return response
def request(self, request):
print("Entered load balancer request")
self.safetyLock.acquire()
endpoint = self.getEndpoint()
request = request.replace(" ", "/", 1)
request = request.replace(" ", "%20")
request_final = endpoint + request
request_final = request_final.strip()
print("Request is:", request_final)
# fault handling
try:
val = urllib.request.urlopen(request_final).read().decode()
except socket.error:
endpoint = self.getEndpoint()
request_final = endpoint + request
val = urllib.request.urlopen(request_final).read().decode()
print(val)
self.safetyLock.release()
return val
def request(self, request):
print("Entered load balancer request")
self.safetyLock.acquire()
endpoint = self.getEndpoint()
request = request.replace(" ", "/", 1)
request = request.replace(" ", "%20")
request_final = endpoint + request
request_final = request_final.strip()
logging.info("Making a request to: " + request_final)
print("Request is:", request_final)
# fault tolerance if 1 server is down and it hasn't been detected by the load balancer.
try:
val = urllib.request.urlopen(request_final).read().decode()
except socket.error:
endpoint = self.getEndpoint()
request_final = endpoint + request
logging.info("Making a second request to: " + request_final)
val = urllib.request.urlopen(request_final).read().decode()
print(val)
self.safetyLock.release()
return val
def requested_url(self, request):
request = request.replace(' ', '%20') # Change spaces to '%20'
url_request = f'https://www.biedronka.pl/pl/searchhub,query,{request}'
page = urllib.request.urlopen(
url_request) # Go to url with user's request
soup = bs.BeautifulSoup(page, 'lxml')
for divs in soup.find_all('div', {"class": "productsimple-default"}):
for a in divs.find_all('a'):
self.link = a.get(
'href'
) # Take first link of the page with requested products
break
break
def process_response(self, request, response, spider):
"""Interesting to check cached page"""
# Check if Ip has been banned
is_ban = getattr(spider, 'response_is_ban')
ban = is_ban(request, response)
# If Ip has been banned
if ban:
# Get url or redirected url
url = request.meta.get(
'redirect_urls',
[request.url])[0] if request.meta else request.url
# [INFO] Alert user
logger.info(
"[LUMINATI_ROTATE_IP_MIDDLEWARE][PROCESS_RESPONSE][NEUKOLLN] Response has been detected as banned; "
"response.url: %s; retry this url: %s;" % (response.url, url))
# Retrieve session_id if exists else random e.g. reset session each time: 1 request = 1 proxy
session_id = request.meta.get('luminati_session_id',
random.random())
# Random user agent
j = int(session_id * len(self.user_agents))
request.headers['user-agent'] = self.user_agents[j]
# Set proxy
_proxy = self.url % (self._username, session_id, self._password,
self.port)
request.meta['proxy'] = _proxy
# Reset Proxy-Authorization
try:
del request.headers['Proxy-Authorization']
except:
pass
request.meta[NEUKOLLN_META_BANNED_KEY] = ban
request.meta[
NEUKOLLN_META_REFRESH_CACHE_KEY] = True # refresh cache!!!
request.dont_filter = True # DON'T FILTER!!!
request = request.replace(url=url)
return request
# Return response and process it
return response
def update(self, request):
#Update the catalog server
self.safetyLock.acquire()
#Send update request to all of the instances
for instance in self.instances:
instance.update_queue.append(request)
for instance in self.instances:
request = instance.update_queue.pop()
request = request.replace(" ", "/")
endpoint = instance.returnInstance()
request_final = endpoint + request
print(request_final)
val = urllib.request.urlopen(request_final).read().decode()
self.safetyLock.release()
return "True"
def str_parsing(s):
u = s
while True:
for i in range(len(u)):
# find consecutive Chinese numbers
if u[i] in num.keys():
j = i + 1
while j < len(u) and u[j] in num.keys():
j += 1
u_number = u[i:j]
number = '%s' % chinese2arabic(u_number)
u = u.replace(u_number, number)
break
else:
# no more Chinese numbers
return u
def plsongrequest(self, request, user):
request = request.replace("\r", "")[1:]
# LINKS
# DETERMINE LINK TYPE
if validators.url(request):
if "youtu" in request:
try:
title = YouTube(request).title
except Exception: return user + " >> Unable to use that video for some reason."
key = getytkey(request)
if not key: return user + " >> Something is wrong with your Youtube link."
# Check the queue to see if the song is already in there.
self.db = sqliteread('''SELECT id, count(*) FROM playlist WHERE key="{0}"'''.format(key))
if self.db[1] > (MAX_DUPLICATE_SONGS - 1):
return user + " >> That song is already in the playlist. ID: " + str(self.db[0])
sqlitewrite('''INSERT INTO playlist(song, key) VALUES("{request}", "{key}");'''.format(request=(request.replace('"', "'")), key=(key.replace('"', "'"))))
return user + " >> Added: " + title + " to the playlist (YT). ID: " + str(sqliteread('SELECT id FROM playlist ORDER BY id DESC LIMIT 1')[0])
else: # OTHER MP3 REQUESTS <<<<<<<
sqlitewrite('''INSERT INTO playlist(song, key) VALUES("{request}", "{request}");'''.format(request=(request.replace('"', "'"))))
return user + " >> Added that link to the playlist. ID: " + str(sqliteread('SELECT id FROM playlist ORDER BY id DESC LIMIT 1')[0])
else: # GOOGLE PLAY MUSIC STUFF
try:
top_song_result = songtitlefilter(request, 0)
key = top_song_result['storeId']
songtitle = str(top_song_result['artist'] + " - " + top_song_result['title'])
# If theres an error (its unable to find the song) then announce it, otherwise write the song data to the db
except IndexError:
return user + " >> No results found for that song. Please try a different one."
else:
# Test if the song is already in the playlist
self.db = sqliteread('''SELECT id, count(*) FROM playlist WHERE key="{0}"'''.format(key))
if self.db[1] > (MAX_DUPLICATE_SONGS - 1):
return user + " >> That song is already in the playlist. ID: " + str(self.db[0])
# Add song to the playlist
sqlitewrite('''INSERT INTO playlist(song, key) VALUES("{request}", "{key}");'''.format(request=(songtitle.replace('"', "'")), key=(key.replace('"', "'"))))
return user + " >> Added: " + songtitle + " to the playlist. ID: " + str(sqliteread('SELECT id FROM playlist ORDER BY id DESC LIMIT 1')[0])
def buy(self, request):
endpoint = self.getEndpoint()
request = request.replace(" ", "/")
request_final = endpoint+request
print(request_final)
return urllib.request.urlopen(request_final).read().decode()
# Api key AIzaSyBERGmPpGvlPq24uFaXV7sAS6-pIMl7o30
import urllib.request
import json
import webbrowser
import googlemaps
api_key = 'AIzaSyC7gEiJi2eQKs64JWnRCl0c64cBMLfrw2g'
request = input("What's Your Location?: ")
request = request.replace(' ','+')
gmaps = googlemaps.Client(key='AIzaSyC7gEiJi2eQKs64JWnRCl0c64cBMLfrw2g')
geocode_result = gmaps.geocode(request)
strgeocode_result = str(geocode_result)
sensor = False
print(geocode_result)
for result in geocode_result:
try:
lat = result['geometry']['location']['lat']
lng = result['geometry']['location']['lng']
address = result['formatted_address']
except KeyError:
lat = None
lng = None
address = None
endpoint = 'https://maps.googleapis.com/maps/api/geocode/json?address='+request+'&sensor=False''&key='+api_key+''
response = urllib.request.urlopen(endpoint).read()
tests = json.loads(response)
resp_json_payload = tests
#latlng = (lat,lng)
strlat = str(lat)
strlng = str(lng)
url = ("https://www.google.com/maps/search/?api=1&query="+address)
strurl = str(url)
def songrequest(self, request, user):
if request == "\r": # Send a message if they request nothing
return user + " >> " + DEFAULT_SR_MSG
# Check for songs already in the queue
if sqliteread('''SELECT count(*) FROM songs WHERE name="{0}"'''.format(user))[0] > (MAX_REQUESTS_USER - 1):
return user + " >> You already have " + str(MAX_REQUESTS_USER) + " songs in the queue."
request = request.replace("\r", "")[1:]
# LINKS
# DETERMINE LINK TYPE
if validators.url(request):
if "youtu" in request:
key = getytkey(request)
if not key: return "Something is wrong with your Youtube link."
# Check the queue to see if the song is already in there.
self.db = sqliteread('''SELECT id, count(*) FROM songs WHERE key="{0}"'''.format(key))
if self.db[1] > (MAX_DUPLICATE_SONGS - 1):
return user + " >> That song is already in the queue."
try:
self.video = YouTube(request)
except:
return user + " >> That video is unavailable, it's probably age restricted."
songtime = self.getsongtime(request, key)
if songtime > (MAXTIME * 60000):
return user + " >> That song exceeds the maximum length of " + str(MAXTIME) + " minutes."
title = self.video.title
sqlitewrite('''INSERT INTO songs(name, song, key, time) VALUES("{user}", "{request}", "{key}", "{time}");'''.format(user=user, request=(request.replace('"', "'")), key=(key.replace('"', "'")), time=songtime))
removetopqueue()
return user + " >> Added: " + title + " to the queue (YT). ID: " + getnewentry()
else: # OTHER MP3 REQUESTS <<<<<<<
if not MEDIA_FILE_ENABLE:
return user + " >> Online Media Links are disabled by the streamer, you'll need to request something else."
songtime = self.getsongtime("Online", request)
if songtime > (MAXTIME * 60000):
return user + " >> That song exceeds the maximum length of " + str(MAXTIME) + " minutes."
sqlitewrite('''INSERT INTO songs(name, song, key, time) VALUES("{user}", "{request}", "{request}", "{time}");'''.format(user=user, request=(request.replace('"', "'")), time=songtime))
removetopqueue()
return user + " >> Added that link to the queue. ID: " + getnewentry()
elif GPM_ENABLE: # GOOGLE PLAY MUSIC STUFF
try:
top_song_result = songtitlefilter(request, 0)
key = top_song_result['storeId']
songtitle = str(top_song_result['artist'] + " - " + top_song_result['title'])
# If theres an error (its unable to find the song) then announce it, otherwise write the song data to the db
except IndexError:
if YT_IF_NO_RESULT:
return self.youtubesr(request, user)
else:
return user + " >> No results found for that song. Please try a different one."
else:
# Test if the song is already in the queue
self.db = sqliteread('''SELECT id, count(*) FROM songs WHERE key="{0}"'''.format(key))
if self.db[1] > (MAX_DUPLICATE_SONGS - 1):
return user + " >> That song is already in the queue."
songtime = self.getsongtime(None, key)
if songtime > (MAXTIME * 60000):
return user + " >> That song exceeds the maximum length of " + str(MAXTIME) + " minutes."
# Add song to the queue
sqlitewrite('''INSERT INTO songs(name, song, key, time) VALUES("{user}", "{request}", "{key}", "{time}");'''.format(user=user, request=(songtitle.replace('"', "'")), key=(key.replace('"', "'")), time=songtime))
removetopqueue()
return user + " >> Added: " + songtitle + " to the queue. ID: " + getnewentry()
else:
return self.youtubesr(request, user)
def process(update):
request = str(update['message']['text']) if 'text' in update['message'] else "$$"
global chat_id
chat_id = update['message']['chat']['id']
global message_id
message_id = update['message']['message_id']
user_id = update['message']['from']['id']
username = update['message']['from']['username'] if 'username' in update['message']['from'] else False
first_name = update['message']['from']['first_name'] if 'first_name' in update['message']['from'] else False
last_name = update['message']['from']['last_name'] if 'last_name' in update['message']['from'] else False
name = (first_name + " ") if first_name else ""
name += last_name if last_name else ""
global requester
requester = username if username else name
message_timestamp = update['message']['date']
# update stats
for chat_var in [Chats, SessionChats]:
if chat_id in chat_var:
if user_id in chat_var[chat_id]:
chat_var[chat_id][user_id].new_message(message_timestamp)
else:
chat_var[chat_id][user_id] = UserStat([username, first_name, last_name], timestamp=message_timestamp)
else:
chat_var[chat_id] = {user_id: UserStat([username, first_name, last_name], timestamp=message_timestamp)}
# process received commands
if request.startswith(botprefix):
request = request.split(botprefix, 1)[1]
if request:
if "@" in request:
target = request.split("@", 1)[1].split(" ")
if target[0] != bot_username:
return
else:
request = request.replace("@" + bot_username, "")
else:
return
try:
request = shlex.split(request)
except ValueError:
return
switcher = {
"": dummy,
"help": build_help,
"quote": build_quote,
"stats_alltime": build_alltime_stats,
"stats_daily": build_daily_stats,
"about": build_about,
"uptime": build_uptime,
"list_users": list_users,
"save_stats": save_stats,
"reset_daily": reset_daily_stats,
"remember": build_remember_link,
"forget": build_forget_link,
"recall": build_recall_link,
"search": build_search_link,
"getpic": build_imgur_pic,
"memegen": build_meme_gen,
"search_meme": build_search_memes,
"login_imgur": login_imgur,
"logout_imgur": logout_imgur,
"imgur_status": login_status_imgur
}
log("Request - " + str(request))
response = switcher[request[0]](request) if request[0] in switcher else False
log("Response - " + str(response))
if response:
send_message(response)