روبوت إكزير

 _{import os  # for first layer}

 

_{# for first layer only}

_{from google.oauth2 import service_account}

 

_{# for both first and second layer}

_{import time}

_{import colorama  # Import the colorama library}

_{from colorama import Fore, Style  # Import the colorama styles}

 

_{# Initialize the colorama library}

_{colorama.init()}

_{# Define the color styles}

_{USER_INPUT_STYLE = Style.BRIGHT + Fore.WHITE}

_{RESPONSE_STYLE = Style.BRIGHT + Fore.CYAN}

_{# end of colorama line}

 

_{import regex}

_{from YkzirRobot_Database_GoogleSheet_V2 import service, SPREADSHEET_ID_old}

_{from def_my_convs_log import simpen_conversation_log, a, ADD_FALN, filter_user_input}

 

_{# Replace the values below with the actual values for your project}

_{SCOPES = ['https://www.googleapis.com/auth/spreadsheets']}

 

_{# the id of the spead sheet. find it from the url}

_{# example}

_{# docs.google.com/spreadsheets/d/1eEUd8Bv7siQd3mOVAYjfkZbfsWpnL2XAYQPJvFivfBw/edit#gid=0}

_{# the id is between the d/ and /edit}

_{# varriable = 'name of the sheet!column:column'}

_{RANGE_NAME = 'RESPONSE_DATA_BASE!A3:B1000'}

_{# the actual JSON content of ykzir robot service account file}

_{import YkzirRobot_Database_GoogleSheet_V2}

 

_{S_ID = YkzirRobot_Database_GoogleSheet_V2.SPREADSHEET_ID_old}

_{JSON = YkzirRobot_Database_GoogleSheet_V2.YKZIR_ROBOT_JSON}

_{# Authenticate using the service account key}

_{creds = service_account.Credentials.from_service_account_info(JSON, scopes=SCOPES)}

_{# Build the Sheets API client}

 

_{# Retrieve the values in the specified range}

_{result = service.spreadsheets().values().get(}

    _{spreadsheetId=S_ID, range=RANGE_NAME).execute()}

_{values = result.get('values', [])}

 

 

_{# end of google sheet authentication}

_{###############################################}

 

_{# this function records the activities of robot ykzir customers and attackers}

_{# *24th1989#+Upgrading2018PC!E15}

_{def update_login_successes(service, SPREADSHEET_ID, username, password):}

    _{# Get the data from the spreadsheet}

    _{result = service.spreadsheets().values().get(}

        _{spreadsheetId=SPREADSHEET_ID,}

        _{range='ykzir_data!A2:D',}

        _{valueRenderOption='UNFORMATTED_VALUE'}

    _).execute()

 

    _{for row in result.get('values', []):}

        _{if len(row) >= 2 and row[0] == username and row[1] == password:}

            _{login_successes = int(row[2]) + 1 if len(row) > 2 else 1}

            _{login_failures = int(row[3]) if len(row) > 3 else 0}

            _{# Update the login success count}

            _{result = service.spreadsheets().values().update(}

                _{spreadsheetId=SPREADSHEET_ID,}

                _{range=f'ykzir_data!C{result["values"].index(row) + 2}:D{result["values"].index(row) + 2}',}

                _{valueInputOption='RAW',}

                _{body={'values': [[login_successes, login_failures]]}}

            _).execute()

            _{return True}

 

    _{# If no matching username and password found, add a new row with login failure}

    _{login_successes = 0}

    _{login_failures = 1}

    _{result = service.spreadsheets().values().append(}

        _{spreadsheetId=SPREADSHEET_ID,}

        _{range='ykzir_client_database_record!A:D',}

        _{valueInputOption='RAW',}

        _{insertDataOption='INSERT_ROWS',}

        _{body={'values': [[username, password, login_successes, login_failures]]}}

    _).execute()

    _{return False}

 

 

_{# end of login activities record function}

 

_{# linux input style}

_{def parrot_input(prompt):}

    _{# Format the prompt to look like the Parrot OS terminal prompt}

    _{formatted_prompt = f"\033[0;32m┌─[\033[0;33m{prompt}\033[0;32m]─[\033[0;36m~\033[0;32m]\n└──╼ \033[0m"}

 

    _{# Print the prompt one character at a time with a small delay}

    _{for char in formatted_prompt:}

        _{print(char, end='', flush=True)}

        _{time.sleep(0.02)}

 

    _{# Wait for user input and return the input}

    _{return input()}

 

 

_{# Example usage:}

_{# prompt = parrot_input("user@parrot")}

_{# print(f"User input: {user_input}")}

 

_{enter_mlebu = """}

 

 

        _{▀▀█▀▀ █▀▀ █░█ █▀▀█ █▀▀▄}  

        _{░▒█░░ █▀▀ █▀▄ █▄▄█ █░░█}  

        _{░▒█░░ ▀▀▀ ▀░▀ ▀░░▀ ▀░░▀} 

 

        _{▒█▀▀▀ █▀▀▄ ▀▀█▀▀ █▀▀ █▀▀█} 

        _{▒█▀▀▀ █░░█ ░░█░░ █▀▀ █▄▄▀} 

        _{▒█▄▄▄ ▀░░▀ ░░▀░░ ▀▀▀ ▀░▀▀}

 

_"""

 

_{access_granted = False}

_{while not access_granted:}

    _{# clearing the screen if the login page failed}

    _{def clear_screen():}

        _{os.system('cls' if os.name == 'nt' else 'clear')}

 

 

    _{clear_screen()}

 

    _{from def_pesan import pesan_welcome}

    _{username, password = pesan_welcome()}

 

    _{# Call the Sheets API to retrieve data from the spreadsheet}

    _{result = service.spreadsheets().values().get(spreadsheetId=S_ID, range='ykzir_data!A2:B300').execute()}

 

    _{# Check if the provided username and password match the ones stored in the spreadsheet}

    _{for row in result.get('values', []):}

        _{if len(row) == 2 and row[0] == username and row[1] == password:}

            _{access_granted = True}

            _break

 

    _{# Grant access if the username and password match}

    _{if access_granted:}

        _{update_login_successes(service, S_ID, username, password)}

        _{os.system('cls')}

        _{access_granted = """𝔸𝕔𝕔𝕖𝕤𝕤 𝔾𝕣𝕒𝕟𝕥𝕖𝕕 \n}

        _{𝕋𝔼ℝℍ𝕌𝔹𝕌ℕ𝔾 \n     𝔻𝔼ℕ𝔾𝔸ℕ\n   ℝ𝕆𝔹𝕆𝕋}

        _"""

        _{print(access_granted)}

        _{time.sleep(2)}

        _{input(enter_mlebu)}

 

 

        _{###################################################}

        _{# head of second layer(jantung program ykzir robot)#}

        _{###################################################}

        _{# input("akhir dari program login test" + ",program berhasil pites enter nutup terminal")}

 

        _{###################################################}

        _{# head of second layer(jantung program ykzir robot)#}

        _{###################################################}

        _{# head of second layer}

        _{def type_out_response(response_text):}

            _{# Function to simulate typing animation}

            _{for char in response_text:}

                _{time.sleep(0.02)  # Change the delay time as desired}

                _{print(char, end="", flush=True)}

            _print()

 

        _{def clear_screen():}

            _{os.system('cls' if os.name == 'nt' else 'clear')}

 

        _{clear_screen()}

 

        _{# place for robot ykzir 1-the hearth.py}

        _{import argparse}

        _{import re}

        _{import time}

 

        _{import os}

        _{import colorama  # Import the colorama library}

        _{import httplib2}

        _{from colorama import Fore, Style  # Import the colorama styles}

 

        _{from def_pesan import type_out_response}

        _{from def_pesan import play_audio}

 

        _{import googleapiclient.errors}

        _{import openai}

 

        _{# Initialize the colorama library}

        _{colorama.init()}

        _{# Define the color styles}

        _{USER_INPUT_STYLE = Style.BRIGHT + Fore.WHITE}

        _{RESPONSE_STYLE = Style.BRIGHT + Fore.CYAN}

 

 

        _{# end of colorama line}

 

        _{def clear_screen():}

            _{os.system('cls' if os.name == 'nt' else 'clear')}

 

 

        _{clear_screen()}

 

        _{from def_pesan import pesan1}

 

        _pesan1()

 

 

        _{# """Argparse The argparse module allows developers to write user-friendly command-line interfaces for their scripts.}

        _{# In this script, the argparse.ArgumentParser() method is used to create a new ArgumentParser object.}

        _{# Then, add_argument() method is called on the parser object to define six command-line arguments:"""}

        _{def main():}

            _{global mrw_menjawab, mrwmemberitahukan, response_ai_source, result, url, response}

            _{parser = argparse.ArgumentParser()}

            _{parser.add_argument("--model", type=str, default="text-davinci-003", help="OpenAI GPT-3 model engine")}

            _{parser.add_argument("--max-tokens", type=int, default=3500,}

                                _{help="Maximum number of tokens to generate in the response")}

            _{parser.add_argument("--temperature", type=float, default=0.3,}

                                _{help="Controls the 'creativity' of the generated response")}

            _{parser.add_argument("--top-p", type=float, default=1.0,}

                                _{help="Controls the diversity of the generated response")}

            _{parser.add_argument("--frequency-penalty", type=float, default=0.0,}

                                _{help="Adjusts the frequency of words used in the generated response")}

            _{parser.add_argument("--presence-penalty", type=float, default=0.0,}

                                _{help="Adjusts the presence of words used in the generated response")}

            _{args = parser.parse_args()}

 

            _{openai.api_key = "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"}

            _{model_engine = args.model}

            _{max_tokens = args.max_tokens}

            _{temperature = args.temperature}

            _{top_p = args.top_p}

            _{frequency_penalty = args.frequency_penalty}

            _{presence_penalty = args.presence_penalty}

 

            _{# the main program of robot ykzir}

            _{# loop this block, until the user type "exit"}

            _{while True:}

                _{import random}

                _{# The function takes two arguments: input_str,}

                _{# which is the user input, and sheet_values, which is the result of result.get('values', []).}

                _{def find_matching_phrase(input_str, sheet_values):}

                    _{Indonesian_Knowledges = None}

 

                    _{for i, row in enumerate(sheet_values):}

                        _{if len(row) == 2:}

                            _{Indonesian_cell_phrases = row[0].split("~ ")}

                            _{for phrase in Indonesian_cell_phrases:}

                                _{if phrase == input_str:}

                                    _{Indonesian_Knowledges_options = row[1].split("~ ")}

                                    _{Indonesian_Knowledges = random.choice(Indonesian_Knowledges_options)}

                                    _{Indonesian_Knowledges_options.remove(Indonesian_Knowledges)}

                                    _break

 

                    _{if Indonesian_Knowledges is not None:}

                        _{return Indonesian_Knowledges}

                    _'''else:

                        _{return "No answer found." - '''}

 

                _try:

                    _{# (clear and exit) command, file handling commnad. question to the AI, are taken from this block}

                    _{# using one user input that's called prompt}

                    _{from def_pesan import parrot_input}

                    _{prompt = parrot_input("User Bertanya" + USER_INPUT_STYLE + ":" + Style.RESET_ALL)}

                    _{# the re.sub() method to remove any occurrence of ? or ! characters at the end of the input.}

                    _{prompt = re.sub(r'[ <>/,?!]+$', '', prompt)}

                    _{while True:}

                        _{line = input()}

                        _{if line == '' and prompt[-1] == '\\':}

                            _{prompt = prompt[:-1] + '\n'}

                        _{elif line == '':}

                            _break

                        _else:

                            _{prompt += line + '\n'}

                _{except KeyboardInterrupt:}

                    _{from def_pesan import pesan_ctrl_c}

                    _{pesan_ctrl_c()}

                    _continue

 

                _{import sys}

                _{sys.path.append('wildzanybayanat.py')}

 

                _{import wildzanybayanat}

                _{import webbrowser}

                _{from googleapiclient.discovery import build}

 

                _{# Enter your API key and CX value here}

                _{api_key = "AIzaSyB21CPp4vXscQ3oQeKYG-ejrd8-uOf-JPs"}

                _{cx = "e66d3331cd75849ea"}

 

                _{def google_search(query):}

                    _{service = build("customsearch", "v1", developerKey=api_key)}

                    _{res = service.cse().list(q=query, cx=cx).execute()}

                    _{return res['items']}

 

                _{data_A = wildzanybayanat.awaamir}

                _{data_B = wildzanybayanat.asmaa2}

                _{data_C = wildzanybayanat.jar_majruur}

                _{suffixes = wildzanybayanat.i09aafah}

 

                _{data_D = []}

                _{for b in data_B:}

                    _{for s in suffixes:}

                        _{data_D.append(b + s)}

 

                _{data_D = list(set(data_C))}

                _{data_D.sort()}

                _{# print(data_C)}

 

                _{sart_wa_jawabu_sart_data2 = wildzanybayanat.sart_wa_jawabu_sart_data2}

                _{prompt2 = prompt}

                _{question_keys = prompt2.split()}

 

                _{matches_A = [key for key in question_keys if key in data_A]}

                _{matches_B = [key for key in question_keys if key in data_B]}

                _{matches_C = [key for key in question_keys if key in data_C]}

 

                _##########

 

                _{# explaination}

                _{# checking condition, what kind of typing the user does}

                _{# 1. basic command (clear and exit) 2. office command (to handle / to deal with office file)}

                _{# 3. if none of the above are True, the user input is transfered to openAI}

                _{# here M RIZKY WILDZANY used "google sheet" to store the dictionary data"}

                _try:

                    _{from YkzirRobot_Database_GoogleSheet_V2 import res_old_values}

                    _{Indonesian_list_cell = res_old_values}

                    _{Indonesian_Knowledges = find_matching_phrase(prompt, Indonesian_list_cell)}

                    _{if Indonesian_Knowledges:}

                        _{from def_pesan import response1}

                        _{response1(Indonesian_Knowledges)}

                    _{elif len(matches_A) > 0 and len(matches_C) > 0:}

 

                        _{query_list = question_keys}

                        _{query = ''}

                        _{words_to_remove = set(matches_A + matches_C)}

 

                        _{while any(word in query_list for word in words_to_remove):}

                            _{for word_to_remove in words_to_remove:}

                                _{if word_to_remove in query_list:}

                                    _{query_list.remove(word_to_remove)}

                            _{query = ' '.join(query_list)}

                            _{url = f"https://www.bing.com/search?q={query}"  # https://www.bing.com/images/search?q=}

                            _{# results = google_search(query)}

 

                        _{if url:}

                            _{# print(query_list)}

                            _{# print(matches_B)}

                            _{webbrowser.open_new(url)}

                            _{from def_pesan import pesan_web}

                            _{pesan_web(query)}

 

                        _else:

                            _{from def_pesan import pesan_else_web}

                            _{pesan_else_web(query)}

                    _{elif len(matches_A) > 0 and len(matches_B) > 0:}

                        _{# lek userinput subset e valuene var matches_A_B lakonono iki,}

                        _{# lek guduk subset e, lalekno perintah ndik isor iki}

                        _{# find key that contains 'matches_B'}

                        _{matches_A_B = set(matches_A + matches_B)}

                        _{if set(question_keys).issubset(matches_A_B):}

                            _{for match in matches_B:}

                                _{for key, value in sart_wa_jawabu_sart_data2.items():}

                                    _{if match in value:}

                                        _{from def_pesan import pesan_open_folder}

                                        _{pesan_open_folder()}

                                        _{webbrowser.open_new_tab(key)}

                                        _{break  # stop searching once the key is found}

 

                    _{elif prompt.lower() in ['ykzir crawler']:}

                        _{crawler_memberitahukan = "M Rizky Wildzany Memberitahukan"}

                        _print(

                            _{f"\n\033[0;32m┌─[\033[0;34m{crawler_memberitahukan}\033[0;32m]─[\033[0;36m~\033[0;32m]\n└──╼ \033[0m")}

                        _{type_out_response("Ykzir-Robot-Crawler dimunculkan !!")}

                        _{time.sleep(1)}

                        _{from def_crawler import search_and_display}

                        _{search_and_display()}

                        _print(

                            _{f"\n\033[0;32m┌─[\033[0;34m{crawler_memberitahukan}\033[0;32m]─[\033[0;36m~\033[0;32m]\n└──╼ \033[0m")}

                        _{type_out_response("Ykzir-Robot-Crawler ditutup !!")}

                    _{elif prompt.lower() in ['exit']:}

                        _{# close the program}

                        _break

                    _{elif prompt.lower() == 'clear':}

                        _{clear_screen()}

                        _continue

                    _{elif prompt.lower() in ["simpenen dadi file docx"]:}

                        _{from def_pesan import pesan_docx}

                        _{from def_docx import create_docx_file_with_dialog}

                        _{create_docx_file_with_dialog(response.choices[0].text.strip())}

 

                    _{elif sum(word in a for word in prompt.split()) >= 2:}

                        _{x = filter_user_input(a, prompt)}

                        _{xs = regex.findall(r'"[^"]*"|[^"\s]+', x)}

                        _{ADD_FALN(service, SPREADSHEET_ID_old, username, password, prompt,}

                                 _{response.choices[0].text.strip(), xs[0],}

                                 _{xs[1], xs[2],}

                                 _xs[3])

                        _{from def_pesan import pesan_log_saved}

                        _{pesan_log_saved()}

 

                    _{elif prompt.lower() in ["ib7ath 3an sha59"]:}

                        _{from tracking import data_parser}

                        _{data_parser()}

 

                    _{elif prompt == "almusaa3adaat":}

                        _{from def_pesan import kalimat_almurur}

                        _{kalimat_almurur()}

                        _{x = input("::::")}

 

                        _{if x == "show me the commands":}

                            _{from def_pesan import show_commands}

                            _{show_commands()}

                        _else:

                            _pass

 

                    _else:

                        _{# the main openai program}

                        _{response = openai.Completion.create(}

                            _{model=model_engine,}

                            _{prompt=prompt,}

                            _{temperature=temperature,}

                            _{max_tokens=max_tokens,}

                            _{top_p=top_p,}

                            _{frequency_penalty=frequency_penalty,}

                            _{presence_penalty=presence_penalty}

                        ₎

                        _{from def_pesan import response_ai}

                        _{response_ai_source = response_ai(response)}

                        _{simpen_conversation_log(service, SPREADSHEET_ID_old, username, password, prompt,}

                                                _{response.choices[0].text.strip())}

 

 

                _{# Error communicating with OpenAI. Retrying in 3 seconds}

                _{except openai.error.APIConnectionError:}

                    _{mrwmemberitahukan = r"M Rizky Wildzany - Memberitahukan"}

                    _{mrw_warning = "maaf system sibuk, menyambungkan kembali dalam 3 detik"}

                    _{mrw_warning_display = type_out_response(mrw_warning)}

                    _{play_audio("ykzir_robotic_glitch2.wav")}

                    _print(

                        _{f"\n\033[0;32m┌─[\033[0;34m{mrwmemberitahukan}\033[0;32m]─[\033[0;36m~\033[0;32m]\n└──╼ \033[0m{mrw_warning_display}")}

                    _{time.sleep(3)}

                    _continue

                _{except httplib2.error.ServerNotFoundError:}

                    _{from def_pesan import pesan_no_internet}

                    _{pesan_no_internet()}

                    _break

                _{except KeyboardInterrupt:}

                    _{from def_pesan import pesan_ctrl_c}

                    _{pesan_ctrl_c()}

                    _continue

                _{except NameError:}

                    _{from def_pesan import pesan_NameError}

                    _NameError()

                    _continue

                _{except googleapiclient.errors.HttpError as error:}

                    _{if error.resp.status == 429:}

                        _{from def_pesan import ex_google_limit}

                        _{ex_google_limit()}

                    _else:

                        _{print(f"An error occurred: {error}")}

                _{# End of robot ykzir program}

 

 

        _{if __name__ == "__main__":}

            _{# argparse fucntion}

            _main()

 

        _{# Here#}

 

    _{# end of the login page layer}

    _else:

        _{logosalah = """}

 

_{─█▀▀█ ░█─▄▀ ░█─░█ ░█▄─░█ 　 ░█▀▀▀} 

_{░█▄▄█ ░█▀▄─ ░█─░█ ░█░█░█ 　 ░█▀▀▀} 

_{░█─░█ ░█─░█ ─▀▄▄▀ ░█──▀█ 　 ░█▄▄▄} 

 

 

_{░█▀▀▀█ ─█▀▀█ ░█─── ─█▀▀█ ░█─░█ 　 █} 

_{─▀▀▀▄▄ ░█▄▄█ ░█─── ░█▄▄█ ░█▀▀█ 　 ▀} 

_{░█▄▄▄█ ░█─░█ ░█▄▄█ ░█─░█ ░█─░█ 　 ▄}

 

_"""

        _{print(logosalah)}

        _{time.sleep(1)}

        _{# record the failed login}

        _{update_login_successes(service, S_ID, username, password)}

        _{# Clear the terminal}

        _{if os.name == 'nt':  # check if Windows}

            _{os.system('cls')}

        _{else:  # any other OS (Linux, macOS, etc.)}

            _{os.system('clear')}