Test.py

# Test.py

# Import the "importlib" module
import importlib

import re
from urllib.parse import urlparse, parse_qs
import validators
from googleapiclient import discovery

class Main():
	def __init__(self):
		# Import the classes
		self.Import_Classes()

		# Define the folders of the module
		self.folders = self.Define_Folders(object = self).folders

		# Define the basic variables of the class
		self.Define_Basic_Variables()

		# Get the methods of the class
		self.Get_Methods()

	def Import_Classes(self):
		# Define the list of modules to be imported
		modules = [
			"Define_Folders",
			"JSON"
		]

		# Iterate through the list of modules
		for module_title in modules:
			# Import the module
			module = importlib.import_module("." + module_title, "Utility")

			# Get the sub-class
			sub_class = getattr(module, module_title)

			# If the module title is not "Define_Folders"
			if module_title != "Define_Folders":
				# Run the sub-class to define its variable
				sub_class = sub_class()

			# Add the sub-class to the current module
			setattr(self, module_title, sub_class)

		# ---------- #

		# Define the "Language" class as the same class inside the "JSON" class
		self.Language = self.JSON.Language

	def Define_Basic_Variables(self):
		# Get the dictionary of modules
		self.modules = self.JSON.To_Python(self.folders["Python"]["Modules"]["Modules"])

		# ---------- #

		# Create a list of the modules that will not be imported
		remove_list = [
			"Define_Folders",
			"Modules",
			"Language",
			"JSON"
		]

		# Iterate through the list of utility modules
		for module_title in self.modules["Utility"]["List"]:
			# If the module title is not inside the remove list
			if module_title not in remove_list:
				# Import the module
				module = importlib.import_module("." + module_title, "Utility")

				# Get the sub-class of the module
				sub_class = getattr(module, module_title)

				# Add the sub-class to the current class
				setattr(self, module_title, sub_class())

		# ---------- #

		# Get the switches dictionary from the "Global Switches" class
		self.switches = self.Global_Switches.switches["Global"]

		# ---------- #

		# Import some variables from the "Language" class

		# Import the "languages" dictionary
		self.languages = self.Language.languages

		# Import the "language" dictionary
		self.language = self.Language.language

		# Import the "separators" dictionary
		self.separators = self.Language.separators

		# ---------- #

		# Import the "folders" dictionary from the "Folder" class
		self.folders = self.Folder.folders

		# ---------- #

		# Import the "Sanitize" method from the "File" class
		self.Sanitize = self.File.Sanitize

	def Get_Methods(self):
		import inspect
 
		# Get the methods
		members = inspect.getmembers(self, predicate = inspect.ismethod)

		# Define a list of methods to remove
		remove_list = [
			"__init__",
			"Define_Basic_Variables",
			"Define_Texts",
			"Import_Classes",
			"Get_Methods",
			"Get_ID"
		]

		# Iterate through the tuples in the members
		for tuple_ in members.copy():
			# Get the member (method) name
			member = tuple_[0]

			# If the member is in the remove list
			if member in remove_list:
				# Remove it
				members.remove(tuple_)

		# Create the dictionary of methods
		methods = {}

		# Create the list of method names
		method_names = []

		# Iterate through the members, create their dictionaries, and add them to the methods dictionary
		for member in members:
			# Define the key as the method name
			key = member[0]

			# Replace the underlines in the key with spaces and capitalize it to create the edited method name
			method_name = key.replace("_", " ").capitalize()

			# Add it to the list of method names
			method_names.append(method_name)

			# Get the method (second item in the tuple)
			method = member[1]

			# Add the method to the methods dictionary
			methods[key] = method

		# List the method names
		names = list(methods.keys())

		# Define a local selected method variable
		selected_method = ""

		# If the selected method is an empty string
		if selected_method == "":
			# Ask the user to select a method
			selected_method = self.Input.Select(names, language_options = method_names)["Option"]["Original"]

		# Get the method using the method name
		method = methods[selected_method]

		# Show a five dash space separator
		print()
		print(self.separators["5"])
		print()

		# Show the method name
		print("Method:")
		print(selected_method)

		# Run the selected method
		method()

	def Create_Text(self):
		# Show a five dash space separator
		print()
		print(self.separators["5"])

		# Define the user input as an empty string
		user_input = ""

		# Define a local number
		number = 1

		# Define a text template
		text_template = "# {}."

		# While the user input is empty
		while user_input == "":
			# Format the text template with the number to create the text
			text = text_template.format(number)

			# Copy the text
			self.Text.Copy(text)

			# Add one to the local number
			number += 1

			# Wait for user input before continuing
			user_input = self.Input.Type(self.Language.language_texts["continue, title()"])

	def Convert_Date(self):
		# Define the date as an empty string
		date = ""

		# While the date is not "f"
		while date != "f":
			# Show a ten dash space separator
			print()
			print(self.separators["10"])

			# Ask for the date
			date = self.Input.Type("Paste the date", accept_enter = False, next_line = True)

			# Convert it into a date dictionary
			date = self.Date.From_String(date, "%H:%M %d/%m/%Y")

			# Define the date format
			date_format = "YYYY-MM-DDTHH:MM:SSZ"

			# Get the date in that format
			selected_date = date["UTC"]["DateTime"]["Formats"][date_format]

			# Copy the date
			self.Text.Copy(selected_date)

	def Enumerate_Lines(self):
		# Ask the user to press Enter to get the clipboard
		self.Input.Type("Press Enter to get the clipboard")

		# Get the lines from the clipboard
		lines = self.Text.Get_Clipboard().splitlines()

		# Get the number of lines
		number_of_lines = len(lines)

		# Define the "i" number
		i = 1

		# Define a list of new lines
		new_lines = []

		# Iterate through the list of lines
		for line in lines:
			# Add the "i" number to the line
			line = str(i) + ". " + line
			
			# Add the line to the list of new lines
			new_lines.append(line)

			# Add one to the "i" number
			i += 1

		# Convert the list of new lines into a text
		text = self.Text.From_List(new_lines)

		# Copy the text to the clipboard
		self.Text.Copy(text)

	def Test_Processes(self):
		import psutil

		# Define the local list of attributes to get
		attributes = [
			"pid",
			"name",
			"status",
			"username",
			"exe",
			"cmdline",
			"create_time",
			"memory_info",
			"cpu_percent",
			"num_threads",
			"open_files"
		]

		# Iterate through the list of processes
		for process in psutil.process_iter(attrs = attributes):
			# Show the process name
			print(process.info["name"])

	def Make_Dual_Audio_Of_Media(self):
		import os
		import subprocess

		print()
		print(self.separators["5"])
		print()

		# Define the media type and title
		media_type = "Animes"
		media_title = "Yuru Camp△"

		# Define the file of titles
		titles_file = "C:/Mega/Bloco De Notas/Redes de Dados/Mídia Audiovisual/Informações de mídia/{}/{}/Temporadas/Season 2/Títulos/Português.txt".format(media_type, media_title)

		titles_file = self.File.Sanitize(titles_file)

		# Define the root folder
		root_folder = "C:/Mídias/{}/{}/Season 2/".format(media_type, media_title)

		root_folder = self.Folder.Sanitize(root_folder)

		# Define the command parameters
		command_parameters = {
			"Video input": 'i "{Root folder}/Legendado/{}.mkv"',
			"Input timestamp offset": "itsoffset 1",
			"Audio input": 'i "{Root folder}/Português/MP3/{}.mp3"',
			"Map external subtitle": 'map 0:s "{Root folder}/Legendas/{}.ass"',
			"Map all": "map 0",
			"Remove subtitles from original file": "map -0:s",
			"Remove attachments from original file": "map -0:t",
			"Map first audio input to second audio stream": "map 1:a",
			"Make first audio the default audio": "disposition:a:1 default",
			"Remove disposition from the first audio": "disposition:a:0 0",
			"Copy streams from original video": "c copy",
			"Add the title of the episode": 'metadata title="{}"',
			"Add the language and title of the Japanese audio": 'metadata:s:a:0 title="Japanese (Japonês)" -metadata:s:a:0 language=ja -metadata:s:a:0 lang=ja -metadata:s:a:0 handler_name=ja',
			"Add the language and title of the Portuguese audio": 'metadata:s:a:1 title="Portuguese (Português)" -metadata:s:a:1 language=pt -metadata:s:a:1 lang=pt -metadata:s:a:1 handler_name=pt',
			"Output file": '"{Root folder}/{}.mp4"'
		}

		# Replace the root folder template with the real root folder
		for key, value in command_parameters.items():
			if "{Root folder}" in value:
				value = value.replace("{Root folder}", root_folder[:-1])

				command_parameters[key] = value

		# Define the command templates
		command_types = {
			"Normal": {
				"Name": "Normal",
				"Remove": [
					#"Input timestamp offset",
					"Map external subtitle",
					"Remove subtitles from original file",
					"Remove attachments from original file"
				]
			},
			"Add external subtitles": {
				"Name": "Add external subtitles",
				"Remove": []
			}
		}

		# Select the command type
		command_type = command_types["Normal"]

		# Define the default command template
		command_template = "ffmpeg -y ^" + "\n"

		# Define the list of keys
		keys = list(command_parameters.keys())

		# Iterate through the command parameters in the dictionary to make the command template
		for key, parameter in command_parameters.items():
			# If the key is not in the "Remove" list of the command type
			if key not in command_type["Remove"]:
				# If the key is not "Output file"
				if key != "Output file":
					# Add a dash to the command template
					command_template += "-"

				# Add the parameter
				command_template += parameter

				# If the key is not the last one
				if key != keys[-1]:
					# Add a break line symbol and a line break symbol
					command_template += " ^" + "\n"

		# Get the list of titles
		titles = self.File.Contents(titles_file)["lines"]

		# Iterate through the titles
		for title in titles:
			# Define the title dictionary with the encoded quotes and no quotes version of the title
			title = {
				"Normal": media_title + " " + title,
				"Encoded": media_title + " " + title.replace('"', '\\"'),
				"No quotes": title.replace('"', ""),
				"Original": title
			}

			# Define the list of items to use to format the command template
			items = [
				title["No quotes"],
				title["No quotes"]
			]

			# If the command type is "Normal"
			if command_type["Name"] == "Normal":
				# Add the encoded title
				items.append(title["Encoded"])

			# If the command type is "Add external subtitles"
			if command_type["Name"] == "Add external subtitles":
				# Add the "No quotes" title
				items.append(title["No quotes"])

				# Add the encoded title
				items.append(title["Encoded"])

			# Add the "No quotes" title
			items.append(title["No quotes"])

			# Sanitize the items
			i = 0
			for item in items:
				item = self.File.Sanitize(item, restricted_characters = True)

				items[i] = item

				i += 1

			# Format the command template with the list of items, making the command
			command = str(command_template.format(*items))

			# If the title is not the first one
			if title["Original"] != titles[0]:
				# Show some space separators
				print()
				print(self.separators["5"])
				print()

			# Show the title
			print(title["Normal"])

			# Copy the command to the clipboard for the user to run it
			self.Text.Copy(command)

			# If the title is not the last one
			if title["Original"] != titles[-1]:
				# Ask for user input before continuing
				self.Input.Type(self.Language.language_texts["continue, title()"])

	def Download_Minecraft_Assets(self):
		# Import the "requests" module
		import requests

		# Define the "Download" dictionary
		self.download = {
			"Folders": {
				"root": self.folders["User"]["AppData"]["Roaming"]["root"] + ".minecraft/",
				"Downloads": {
					"root": self.folders["User"]["Downloads"]["root"] + "Minecraft/"
				}
			},
			"Versions": [],
			"Version": "",
			"Link": "https://resources.download.minecraft.net/"
		}

		# Define the folders
		folders = [
			"Assets"
		]

		for folder in folders:
			self.download["Folders"][folder] = {
				"root": self.download["Folders"]["root"] + folder + "/"
			}

			self.Folder.Create(self.download["Folders"][folder]["root"])

		# Define the sub-folders
		folders = [
			"Indexes",
			"Objects"
		]

		for folder in folders:
			self.download["Folders"]["Assets"][folder] = {
				"root": self.download["Folders"]["Assets"]["root"] + folder + "/"
			}

			self.Folder.Create(self.download["Folders"]["Assets"][folder]["root"])

		# Get the Minecraft versions
		self.download["Versions"] = self.Folder.Contents(self.download["Folders"]["Assets"]["Indexes"]["root"])["file"]["names"]

		self.download["Versions (options)"] = self.download["Versions"]

		i = 0
		for version in self.download["Versions"]:
			if "." not in version:
				version = version[0] + "." + version[1]

				if len(version) == 3:
					version += "0"

				self.download["Versions (options)"][i] = version

			i += 1

		# Select the Minecraft version
		self.download["Version"] = self.Input.Select(self.download["Versions"], language_options = self.download["Versions (options)"])["option"]

		# Create the "Minecraft" folder
		self.Folder.Create(self.download["Folders"]["Downloads"]["root"])

		# Update the "Minecraft" folder with the selected version
		self.download["Folders"]["Downloads"]["root"] += self.download["Version"] + "/"
		self.Folder.Create(self.download["Folders"]["Downloads"]["root"])

		# Define the other folders
		for folder in ["Extracted"]:
			self.download["Folders"]["Downloads"][folder] = {
				"root": self.download["Folders"]["Downloads"]["root"] + folder + "/"
			}

			#self.Folder.Create(self.download["Folders"]["Downloads"][folder]["root"])

		# Define the indexes file name
		file_name = self.download["Version"]

		if "." in file_name:
			split = self.download["Version"].split(".")

			file_name = split[0] + "." + split[1]

		# Get the indexes file
		self.download["Indexes file"] = self.download["Folders"]["Assets"]["Indexes"]["root"] + file_name + ".json"

		# Read the indexes file and get the indexes
		self.download["Indexes"] = self.JSON.To_Python(self.download["Indexes file"])["objects"]

		# Iterate through the indexes in the Indexes dictionary
		i = 1
		length = len(self.download["Indexes"].keys())

		for key, index in self.download["Indexes"].items():
			# Get the hash and mini-hash
			hash = index["hash"]

			mini_hash = hash[0] + hash[1]

			# Create the mini-hash folder
			assets_folder = self.download["Folders"]["Assets"]["Objects"]["root"] + mini_hash + "/"
			self.Folder.Create(assets_folder)

			# Create the "Extracted" folder
			extracted_folder = self.download["Folders"]["Downloads"]["Extracted"]["root"]

			# Get the sub-folders
			sub_folders = key.split("/")
			sub_folders.pop(-1)

			# Create the sub-folders
			for folder in sub_folders:
				extracted_folder += folder + "/"
				#self.Folder.Create(extracted_folder)

			# Define the extracted file
			extracted_file = extracted_folder + key.split("/")[-1]

			# Define the link to download the object file
			link = self.download["Link"] + mini_hash + "/" + hash

			# Define the file path
			file = assets_folder + hash

			if self.File.Exist(file) == False:
				# Show a five dash separator
				print()
				print(self.separators["5"])
				print()

				# Show the current asset number and total number
				print(self.Language.language_texts["number, title()"] + ":")
				print("[" + str(i) + "/" + str(length) + "]")
				print()

				# Show the asset key
				print(self.Language.language_texts["key, title()"] + ":")
				print("[" + key + "]")
				print()

				# Show the folder
				print(self.Language.language_texts["folder, title()"] + ":")
				print("[" + assets_folder + "]")
				print()

				# Show the link
				print(self.Language.language_texts["link, title()"] + ":")
				print("[" + link + "]")
				print()

				# Show the asset object file
				print(self.Language.language_texts["file, title()"] + ":")
				print("[" + file + "]")
				print()

				# Show the extracted and converted file
				print(self.Language.language_texts["file, title()"] + " (2)" + ":")
				print("[" + extracted_file + "]")

				# Download the object file
				response = requests.get(link)

				# Define the content variable
				content = response.content

				# Save the files
				open(file, "wb").write(content)

				#if self.File.Exist(extracted_file) == False:
				#	open(extracted_file, "wb").write(content)

				# Get the status code
				code = response.status_code

				# Show the code
				print()
				print(self.Language.language_texts["code, title()"] + ":")
				print("[" + str(code) + "]")

				# If the code is not "200"
				if code != 200:
					input()

			i += 1

	def Notepad_Theme(self):
		self.System.Close("notepad++")

		self.folders["notepad++"] = {
			"root": self.folders["appdata"]["roaming"]["root"] + "Notepad++/"
		}

		self.folders["notepad++"]["themes"] = {
			"root": self.folders["notepad++"]["root"] + "themes/"
		}

		self.folders["notepad++"]["config"] = self.folders["notepad++"]["root"] + "config.xml"

		config = self.File.Contents(self.folders["notepad++"]["config"])["string"]

		themes = [
			"Littletato",
			"Littletato (Brown)",
			"SpaceLiving"
		]

		new_theme = self.Input.Select(themes)["option"]

		new_theme_config = self.File.Contents(self.folders["notepad++"]["themes"]["root"] + new_theme + ".txt")["string"]

		template = 'name="DarkMode" enable="yes" colorTone="32" '
		dark_theme_name = ' darkThemeName="{}.xml"'.format(new_theme)

		config = re.sub(template + '.*darkThemeName=".*\.xml"', template + new_theme_config + dark_theme_name, config)

		self.File.Edit(self.folders["notepad++"]["config"], config, "w")

		self.Date.Sleep(1)

		notepad = self.folders["Root"]["Program Files"]["root"] + "Notepad++/notepad++.exe"

		self.System.Open(notepad)

	def Time_Difference(self):
		# Define the before time
		before = self.Date.Now()

		# Show it
		print(before["Timezone"]["DateTime"]["Formats"]["HH:MM DD/MM/YYYY"])

		# Test parameters
		# Parâmetros de teste
		hours = 1
		minutes = 30
		seconds = 4

		# Define the list of differences to test
		differences = [
			self.Date.Relativedelta(hours = hours),
			self.Date.Relativedelta(minutes = minutes),
			self.Date.Relativedelta(seconds = seconds),
			self.Date.Relativedelta(hours = hours, minutes = minutes),
			self.Date.Relativedelta(hours = hours, seconds = seconds),
			self.Date.Relativedelta(minutes = minutes, seconds = seconds),
			self.Date.Relativedelta(hours = hours, minutes = minutes, seconds = seconds)
		]

		# Iterate through the differences
		for diff in differences:
			# Define the after, with the before time and the current difference
			after = self.Date.Now(before["Object"] + diff)

			# Calculate the time difference between the before and after times
			difference = self.Date.Difference(before, after)

			# Show a five dash space separator
			print()
			print(self.separators["5"])
			print()

			# Get the time difference unit text
			unit_text = str(diff).split("(")[1].split(")")[0]
			unit_text = unit_text.capitalize().replace("=+", " + ")

			# Show it
			print(unit_text + ":")

			# Show the difference texts in all languages
			for item in difference["Text"].values():
				print(item)

	def XML(self):
		folder = self.Folder.Sanitize(self.Input.Type(self.Folder.language_texts["folder, title()"]))
		files = self.Folder.Contents(folder, add_sub_folders = False)["file"]["list"]

		titles_file = self.Folder.Sanitize(self.Input.Type(self.File.language_texts["file, title()"] + " " + self.Language.language_texts["genders, type: dict"]["of"] + " " + self.Language.language_texts["titles, title()"].lower()))
		titles = self.File.Contents(titles_file)["lines"]

		from xml.dom.minidom import getDOMImplementation
		import xml.dom.minidom as md

		implementation = getDOMImplementation()

		document = implementation.createDocument(None, "playlist", None)
		playlist = document.documentElement

		playlist.setAttribute("xmlns", "http://xspf.org/ns/0/")
		playlist.setAttribute("xmlns:vlc", "http://www.videolan.org/vlc/playlist/ns/0/")
		playlist.setAttribute("version", "1")

		# Create title element
		title = document.createElement("title")
		text = document.createTextNode(folder.split("/")[-2])
		title.appendChild(text)
		playlist.appendChild(title)

		# Create trackList element
		trackList = document.createElement("trackList")
		playlist.appendChild(trackList)

		# Create extension element
		extension = document.createElement("extension")
		extension.setAttribute("application", "http://www.videolan.org/vlc/playlist/0")
		playlist.appendChild(extension)

		accepted_extensions = [
			"mp4",
			"mkv",
			"webm"
		]

		i = 0
		for title in titles:
			print()
			print(self.separators["5"])
			print()
			print(str(i + 1) + "/" + str(len(titles)) + ":")
			print(title)

			sanitized_title = self.File.Sanitize(title, restricted_characters = True)

			if sanitized_title != title:
				print(sanitized_title)

			file = ""

			for item in files:
				if sanitized_title in item:
					extensions_list = []

					for ext in accepted_extensions:
						if (
							"." + ext in item and
							item.split(".")[-1] == ext
						):
							file = item

			if file == "":
				input()

			if file != "":
				print()
				print(self.File.language_texts["file, title()"] + ":")
				print(file)

				track = document.createElement("track")

				for item in ["location", "title", "duration", "extension"]:
					element = document.createElement(item)

					if item == "location":
						from requests.utils import requote_uri

						url = self.File.Name(file) + "." + file.split(".")[-1]
						url = url.replace("#", "%23")

						media_folder = file.replace(folder, "")
						media_folder = media_folder.replace(self.File.Name(file), "")
						media_folder = media_folder.split(".")[0]

						url = media_folder + url

						text = document.createTextNode("file:///./" + url)
						element.appendChild(text)

						print()
						print("URL:")
						print("./" + url)

					if item == "title":
						text = document.createTextNode(self.File.Name(file))
						element.appendChild(text)

					if item == "duration":
						from pymediainfo import MediaInfo
						media_info = MediaInfo.parse(file)
						duration = media_info.tracks[0].duration

						text = document.createTextNode(str(duration))
						element.appendChild(text)

					if item == "extension":
						element.setAttribute("application", "http://www.videolan.org/vlc/playlist/0")

						id_element = document.createElement("vlc:id")
						id = document.createTextNode(str(i))
						id_element.appendChild(id)

						element.appendChild(id_element)

					track.appendChild(element)

				element = document.createElement("vlc:item")
				element.setAttribute("tid", str(i))
				extension.appendChild(element)

				trackList.appendChild(track)

			i += 1

		export = document.toprettyxml(indent = "\t", newl = "\n")
		export = export[:-1]

		playlist_file = folder + "Playlist.xspf"
		self.File.Create(playlist_file)
		self.File.Edit(playlist_file, export)

		print()
		print(self.separators["5"])
		print()
		print(self.Language.language_texts["playlist, title()"] + ":")
		print(playlist_file)

	def Remove_Dots_From_String(self):
		type = ""

		while type != "exit":
			type = self.Input.Type()

			if type != "exit":
				clipboard = self.Text.Get_Clipboard().splitlines()

				i = 0
				for line in clipboard:
					if line != "" and line[-1] == "." and line[-3] + line[-2] + line[-1] != "...":
						clipboard[i] = clipboard[i][:-1]

					i += 1

				self.Text.Copy(self.Text.From_List(clipboard, next_line = True))

	def Remove_Line_Of_Files(self):
		folder = self.Folder.Sanitize(self.Input.Type("Folder"))

		contents = self.Folder.Contents(folder, add_sub_folders = True)["file"]["list"]

		i = 0
		for file in contents.copy():
			if i > 5:
				contents.remove(file)

			i += 1

		files = []

		for file in contents:
			for text in ["Games", "Categories", "Time spent", "Times"]:
				if text in file:
					files.append(file)

		file_lines = self.File.Contents(files[1])["lines"]
		file_lines.append("[Finish]")

		self.JSON.Show(files)

		dictionary = {
			"option": ""
		}

		while dictionary["option"] != "[Finish]":
			dictionary = self.Input.Select(file_lines)
			number = dictionary["number_backup"]

			print(number)

			if dictionary["option"] != "[Finish]":
				file_lines.pop(number)

				for file in files:
					lines = self.File.Contents(file)["lines"]
					lines.pop(number)

					self.File.Edit(file, self.Text.From_List(lines, next_line = True))

	def Add_Line_To_Files(self):
		folder = self.Folder.Sanitize(self.Input.Type("Folder"))

		contents = self.Folder.Contents(folder, add_sub_folders = False)["file"]["list"]

		i = 0
		for file in contents.copy():
			if i > 5:
				contents.remove(file)

			i += 1

		files = {}

		for file in contents:
			for text in ["Games", "Categories", "Times", "Time spent"]:
				if text in file:
					files[text] = file

		file_lines = self.File.Contents(list(files.values())[2])["lines"]
		file_lines.append("[Finish]")

		self.JSON.Show(files)

		dictionary = {
			"option": ""
		}

		while dictionary["option"] != "[Finish]":
			if len(file_lines) == 1:
				file_lines.insert(0, "First line")

			dictionary = self.Input.Select(file_lines)
			number = dictionary["number"]

			if dictionary["option"] != "[Finish]":
				for file_name in files:
					file = files[file_name]

					lines = self.File.Contents(file)["lines"]

					text = self.Input.Type(file_name)

					lines.insert(number + 1, text)

					if file_name == "Episodes":
						print()
						print("[" + str(number + 2) + "]:")

					print("\t" + "[" + text + "]")

					self.File.Edit(file, self.Text.From_List(lines, next_line = True))

					if file == list(files.values())[2]:
						file_lines = self.File.Contents(list(files.values())[2])["lines"]
						file_lines.append("[Finish]")

	def Replace_Lines(self):
		lines = list(self.Text.Get_Clipboard().splitlines())

		i = 0
		for line in lines:
			if "msgstr" not in line:
				lines.remove(line)

			i += 1

		string = self.Text.From_List(lines, next_line = True)

		self.Text.Copy(string, verbose = False)

	def Reverse_Lines(self):
		lines = self.Text.Get_Clipboard().splitlines()

		list_ = []

		i = 0
		for line in lines:
			print()
			print(line)
			print(line.split(" ")[0])
			print(line.split(" - "))
			print(line.split(" - ")[0].split(" "))
			second = line.split(" - ")[0].split(" ")
			second.pop(0)
			second = " ".join(second)

			line = line.split(" ")[0] + " " + line.split(" - ")[1] + " - " + second

			lines[i] = line

			i += 1

		self.Text.Copy(self.Text.From_List(lines, next_line = True))

	def Copy_Folder_Names(self):
		# Ask for the folder
		folder = self.Folder.Sanitize(self.Input.Type("Folder"))

		# Get the folder names
		names = self.Folder.Contents(folder, add_sub_folders = False)["folder"]["names"]

		# Transform them into a text
		names = self.Text.From_List(names, next_line = True)

		# Copy the text
		self.Text.Copy(names)

	def Parse_Link(self, link, id_parameter):
		# Define the dictionary of ID parameters to find the correct ID
		id_parameters_map = {
			"Playlist": "list", # For playlists
			"Video": "v", # For videos
			"Comment": "lc" # For comments
		}

		# If the "youtube" text is inside the link
		if "youtube" in link:
			# Import some useful functions from the "urllib.parse" module
			from urllib.parse import urlparse, parse_qs

			# Parse the link
			parsed_link = urlparse(link)

			# Get the query part of the URL
			query_string = parsed_link.query

			# Parse the query string into a dictionary
			url_parameters = parse_qs(query_string)

			# Get the correct key to extract the ID based on the type
			id_key = id_parameters_map[id_parameter]

			# Get the ID value from the parsed parameters
			id = url_parameters[id_key][0]

			# Return the ID and the URL parameters
			return id, url_parameters

		# Else, return None
		else:
			return None

	def Get_ID(self, key):
		# Import the validators module
		import validators

		# Define the dictionary of parameter lengths
		parameter_lengths = {
			"Playlist": 34, # For playlists
			"Video": 11, # For videos
			"Comment": 26 # For comments
		}

		# Get the parameter length
		parameter_length = parameter_lengths[key]

		# Define the link variable as an empty string
		link = ""

		# Define the "found comment parameter" switch as False
		found_comment_parameter = False

		# While the "found comment parameter" switch is False
		while found_comment_parameter == False:
			# Ask for the link
			link = self.Input.Type("Paste the {} link or ID".format(key.lower()), accept_enter = False)

			# If the link is an URL
			if validators.url(link) == True:
				# Parse the link to get the ID
				id, url_parameters = self.Parse_Link(link, key)

				# If the ID is not None
				if id != None:
					# Switch the "found comment parameter" switch to True
					found_comment_parameter = True

			# If the number of characters of the link is the same of the ID parameter length
			if len(link) == parameter_length:
				# Define the ID as the link
				id = link

				# Switch the "found comment parameter" switch to True
				found_comment_parameter = True

		# Define a response dictionary
		response = {
			"ID": id
		}

		# If the key is "Comment"
		# And the "v" parameter is inside the dictionary of URL parameters
		if (
			key == "Comment" and
			"v" in url_parameters
		):
			# Also define the video ID
			response["Video ID"] = url_parameters["v"][0]

		# Return the response dictionary
		return response

	def Get_Comment_Information(self):
		# Get the response dictionary
		response = self.Get_ID("Comment")

		# Get the comment ID
		id = response["ID"]

		# Define the request dictionary with the comment ID
		request = {
			"Item": "Comment",
			"ID": id
		}

		# If the "Video ID" key is inside the response dictionary
		if "Video ID" in response:
			# Define it inside the request dictionary
			request["Video ID"] = response["Video ID"]

		# Call the "Call" method of the "API" class to get the information about the comment with the ID
		information = self.API.Call("YouTube", request)["Request"]

		# Show a ten dash space separator
		print()
		print(self.separators["10"])
		print()

		# Show the information dictionary
		self.JSON.Show(information)

		# Show a ten dash space separator
		print()
		print(self.separators["10"])
		print()

		# Get the "Comment" information dictionary
		comment = information["Dictionary"]["Comment"]

		# Show it
		self.JSON.Show(comment)

		# Copy it
		self.Text.Copy(self.JSON.From_Python(comment), verbose = False)

		# Return it
		return comment

	def Get_Video_Information(self):
		# Get the video ID
		id = self.Get_ID("Video")["ID"]

		# Define the request dictionary with the video ID
		request = {
			"Item": "Video",
			"ID": id
		}

		# Call the "Call" method of the "API" class to get the information about the video with the ID
		information = self.API.Call("YouTube", request)["Request"]["Dictionary"]

		# If the ID is inside the information dictionary
		if id in information:
			# Define the information as it
			information = information[id]

		# Show a ten dash space separator
		print()
		print(self.separators["10"])
		print()

		# Show the information dictionary
		self.JSON.Show(information)

		# Show a ten dash space separator
		print()
		print(self.separators["10"])
		print()

		# Define the list of video keys
		keys = [
			"Title",
			"ID",
			"Times"
		]

		# Iterate through the list of video keys
		for key in keys:
			# Get the item using the key
			item = information[key]

			# If the key is "Times"
			if key == "Times":
				# Get the "Timezone" time
				item = item["Timezone"]

			# If the key is not the first one
			if key != keys[0]:
				# Show a five dash space separator
				print()
				print(self.separators["5"])
				print()

			# Define the text to show
			text = key

			# If the key is "Times"
			if key == "Times":
				# Define the text as "Date"
				text = "Date"

			# Show the text
			print(text + ":")

			# Copy the item
			self.Text.Copy(item)

			# If the key is not the last one
			if key != keys[-1]:
				# Wait for user input
				self.Input.Type(self.Language.language_texts["continue, title()"])

	def Get_Channel_Information(self):
		# Ask for the user name
		username = self.Input.Type("Username", accept_enter = False)

		# Define the request dictionary with the username
		request = {
			"Item": "Search",
			"Parameters": {
				"type": "channel",
				"q": username
			}
		}

		# Call the "Call" method of the "API" class to search for the channel
		information = self.API.Call("YouTube", request)["Request"]["Dictionary"]

		# Show the information dictionary
		print()
		self.JSON.Show(information)

		# Get the "Channel" information dictionary
		channel = information["Channel"]

		# Add the "Channel creation times" after the "Times" key and remove the "Times" key
		key_value = {
			"Channel creation times": channel["Times"]
		}

		channel = self.JSON.Add_Key_After_Key(channel, key_value, after_key = "Times", remove_after_key = True)

		# Show the "Channel" dictionary
		print()
		self.JSON.Show(channel)

		# Copy it
		self.Text.Copy(self.JSON.From_Python(channel), verbose = False)

		# Return it
		return channel

	def Get_Playlist_Information(self):
		# Get the playlist ID
		id = self.Get_ID("Playlist")["ID"]

		# Define the API dictionary
		youtube = {
			"Item": "Playlist",
			"ID": id,
			"Remove private videos": False
		}

		# Call the "Call" method of the "API" class to search for the playlist
		information = self.API.Call("YouTube", youtube)["Request"]["Dictionary"]

		# Show a five dash space separator
		print()
		print(self.separators["5"])
		print()

		# Show the information dictionary
		print()
		self.JSON.Show(information)

	def Get_Playlist_IDs_And_Titles(self):
		# Get the playlist ID
		id = self.Get_ID("Playlist")["ID"]

		# Define the API dictionary
		youtube = {
			"Item": "Playlist videos",
			"ID": id,
			"Remove private videos": False
		}

		# Get the API response dictionary
		information = self.API.Call("YouTube", youtube)["Request"]["Dictionary"]

		# Define a dictionary of lists
		lists = {
			"IDs": [],
			"Titles": [],
			"Dates": []
		}

		# Iterate through the list of videos
		for id in information["Videos"]:
			# Add the video ID to the list of IDs
			lists["IDs"].append(id)

			# Get the video dictionary
			video = information["Videos"][id]

			# Add the video title to the list of titles
			lists["Titles"].append(video["Title"])

			# Add the video date to the list of dates
			date = video["Times"]["Timezone"]

			lists["Dates"].append(date)

		# Show a five dash space separator
		print()
		print(self.separators["5"])
		print()

		# List the keys of the lists dictionary
		keys = list(lists.keys())

		# Iterate through the dictionary of lists
		for key, item in lists.items():
			# Show the list key
			print(key + ":")

			# Transform the list into a text string
			item = self.Text.From_List(item, next_line = True)

			# Copy the list
			self.Text.Copy(item)

			# If the key is not the last one
			if key != keys[-1]:
				# Ask for user input before continuing
				self.Input.Type(self.Language.language_texts["continue, title()"])

				# Show a space
				print()

	def Create_Playlist(self, title = None, description = None):
		if title == None:
			title = self.Input.Type("Playlist title")

		if description == None:
			description = self.Input.Lines("Playlist description")["string"]

		youtube = {
			"item": "playlists",
			"submethod": "insert",
			"title": title,
			"description": description
		}

		dictionary = self.API.Call("YouTube", youtube)["Dictionary"]

		print()

		self.JSON.Show(dictionary)

		return dictionary

	def Add_To_Playlist(self, playlist_dictionary = None, videos = None):
		if playlist_dictionary == None:
			youtube = {
				"item": "playlists",
				"id": self.Get_ID("playlist")
			}

			playlist_dictionary = self.API.Call("YouTube", youtube)["Dictionary"]

		destination_playlist = playlist_dictionary["Playlist"]

		print()
		self.JSON.Show(playlist_dictionary)

		if videos == None:
			ids = self.Input.Lines("Video links", accept_enter = False)["lines"]

			videos = {}

			for id in ids:
				id = self.Get_ID("video", id)

				videos[id] = self.Get_Video(id)["Video"]

		root_ids = list(videos.keys())

		number = 1
		for video_id in root_ids:
			youtube = {
				"item": "playlistItems",
				"submethod": "insert",
				"id": destination_playlist["ID"],
				"videoId": video_id
			}

			print()
			print(self.separators["5"])
			print()
			print(str(number) + "/" + str(len(root_ids)) + ":")
			print()
			print("Title:")
			print("[" + videos[video_id]["Title"] + "]")
			print()
			print("ID:")
			print("[" + video_id + "]")

			add_to_playlist = self.API.Call("YouTube", youtube)["Dictionary"]

			number += 1

		print()
		print(self.separators["5"])
		print()
		self.JSON.Show(add_to_playlist)

		return add_to_playlist

	def Copy_Playlist(self):
		root_playlist = self.Get_Playlist_IDs_And_Titles(ask_for_input = False)

		create_playlist = self.Input.Yes_Or_No("Create playlist")

		if create_playlist == True:
			destination_playlist_dictionary = self.Create_Playlist()
			destination_playlist = destination_playlist_dictionary["Playlist"]

		if create_playlist == False:
			youtube = {
				"item": "playlists",
				"id": self.Get_ID("playlist")
			}

			destination_playlist_dictionary = self.API.Call("YouTube", youtube)["Dictionary"]
			destination_playlist = dictionary["Playlist"]

		videos = root_playlist["Videos"]

		add_to_playlist = self.Add_To_Playlist(destination_playlist_dictionary, videos)

		return add_to_playlist

	def String_To_Date(self):
		before = self.Date.From_String(self.Input.Type())

		units = {
			"years": 0,
			"months": 0,
			"days": 1,
			"hours": 12,
			"minutes": 32,
			"seconds": 19
		}

		before["Object"] += self.Date.Relativedelta(**units)

		before = self.Date.Now(before["Object"])

		print(self.Date.To_String(before, utc = True))

	def Tables(self):
		link = ""

		while validators.url(link) != True:
			link = self.Input.Type("Link of the website with a table")

		import json
		import pandas as pd

		dataframe = pd.read_html(link)[4]

		dictionary = json.loads(dataframe.to_json())

		self.JSON.Show(dictionary)

		titles = dictionary["Título"].copy()

		dictionary = {
			"titles": {},
			"list": titles
		}

		for language in self.languages["small"]:
			dictionary["titles"][language] = []

		a = 104
		i = 1
		for title in dictionary["list"].values():
			print()
			print([title])
			if re.search(" \(BR\).*\(PT\) ", title) != None:
				title = re.split(" \(BR\).*\(PT\) ", title)

			elif re.search(" \(PT\).*\(BR\)", title) != None and re.search(" \(PT\)\/\(BR\)", title) == None:
				title = re.split(" \(PT\) ", title)
				title[0] = '"' + title[1].split('" "')[0]
				title[1] = title[1].split('" "')[1]

			elif re.search(" \(BR \/ PT\) ", title) != None:
				title = re.split(" \(BR \/ PT\) ", title)

			elif re.search(" \(BR\/PT\) ", title) != None:
				title = re.split(" \(BR\/PT\) ", title)

			elif re.search(" \(BR\/PT\)  ", title) != None:
				title = re.split(" \(BR\/PT\)  ", title)

			elif re.search(" \(BR\/PT ", title) != None:
				title = re.split(" \(BR\/PT ", title)

			elif re.search(" \(BR\).*\(PT\) ", title) != None:
				title = re.split(" \(BR\).*\(PT\)  ", title)

			elif re.search(" \(BR\)\/\(PT\) ", title) != None:
				title = re.split(" \(BR\)\/\(PT\) ", title)

			elif re.search(" \(PT\/BR\)", title) != None:
				title = re.split(" \(PT\/BR\)", title)

			elif re.search(" \(PT\)\/\(BR\)", title) != None:
				title = re.split(" \(PT\)\/\(BR\)", title)

			elif re.search(" \(PT\)\/\(BR\)  ", title) != None:
				title = re.split(" \(PT\)\/\(BR\)  ", title)

			elif re.search(" \(BR\) ", title) != None:
				title = re.split(" \(BR\) ", title)

			elif re.search(".*\(PT\) ", title) != None:
				title = '"' + re.sub(".*\(PT\) ", "", title)
				title = re.split(" \(BR\)  ", title)

			ep = "EP" + self.Text.Add_Leading_Zeros(str(i)) + "(" + self.Text.Add_Leading_Zeros(str(a)) + ") "

			english = ep + '"' + title[1]
			portuguese = ep + title[0] + '"'

			if re.search(" \(.*\)", english) != None:
				english = re.sub(" \(.*\)", "", english)

			if re.search('" ', english) != None:
				english = re.sub('" ', '"', english)

			if re.search('"""', english) != None:
				english = re.sub('"""', '"', english)

			if re.search(" \(.*\)", portuguese) != None:
				portuguese = re.sub(" \(.*\)", "", portuguese)

			if re.search('" ', portuguese) != None:
				portuguese = re.sub('" ', '"', portuguese)

			if re.search('"""', portuguese) != None:
				portuguese = re.sub('"""', '"', portuguese)

			print(title)
			print(english)
			print(portuguese)

			dictionary["titles"]["en"].append(english)
			dictionary["titles"]["pt"].append(portuguese)

			a += 1
			i += 1

		for key in dictionary["titles"]:
			list_ = dictionary["titles"][key]
			print(key + ":")
			self.Text.Copy(self.Text.From_List(list_, next_line = True))
			input()

	def Play_Sound(self):
		from gtts import gTTS
		from io import BytesIO

		print()

		import pygame

		mp3_file_object = BytesIO()
		tts = gTTS(self.Input.Type("Text"), lang = "pt")
		tts.save("Test.mp3")
		file = open("test.mp3", "r")

		print(file)

		pygame.init()
		pygame.mixer.init()
		pygame.mixer.music.load(file, "mp3")
		pygame.mixer.music.play()

		import time
		time.sleep(15)

Main()