Коллекция из 25 потрясающих скриптов Python

import json

if __name__ == '__main__':
    try:
        # Открываем файл 'input.json' для чтения
        with open('input.json', 'r') as f:
            data = json.loads(f.read())

        # Формируем строку 'output' из ключей первого объекта в 'data'
        output = ','.join([*data[0]])

        # Добавляем каждый объект из 'data' в строку 'output' в формате CSV
        for obj in data:
            output += f'\n{obj["Name"]},{obj["age"]},{obj["birthyear"]}'

        # Открываем файл 'output.csv' для записи и записываем в него строку 'output'
        with open('output.csv', 'w') as f:
            f.write(output)
    except Exception as ex:
        # Если происходит ошибка, выводим сообщение об ошибке
        print(f'Error: {str(ex)}')

import random
import string
total = string.ascii_letters + string.digits + string.punctuation
length = 16
password = "".join(random.sample(total, length))
print(password)

import os

text = input("input text : ")
path = input("path : ")

def getfiles(path):
    f = 0
    os.chdir(path)  # Изменяем текущую директорию на заданную 'path'
    files = os.listdir()  # Получаем список файлов и папок в текущей директории
    for file_name in files:
        abs_path = os.path.abspath(file_name)  # Получаем абсолютный путь к файлу/папке
        if os.path.isdir(abs_path):  # Проверяем, является ли объект директорией
            getfiles(abs_path)  # Если да, рекурсивно вызываем функцию для этой директории
        if os.path.isfile(abs_path):  # Проверяем, является ли объект файлом
  with open(file_name, "r") as f_n:
   if text in f_n.read():
    f = 1
    print(text + " found in ")
    final_path = os.path.abspath(file_name)
    print(final_path)
    return True
    if f == 0:
        print(text + " not found! ")
        return False

getfiles(path)

import requests as rq
from bs4 import BeautifulSoup

url = input("Enter Link: ")

# Проверяем, содержит ли URL протокол "https" или "http", исходя из этого формируем запрос
if "https" in url or "http" in url:
    data = rq.get(url)
else:
    data = rq.get("https://" + url)

soup = BeautifulSoup(data.text, "html.parser")  # Создаем объект BeautifulSoup для парсинга HTML

links = []
for link in soup.find_all("a"):  # Находим все теги <a> в HTML-коде
    links.append(link.get("href"))  # Получаем значения атрибута "href" и добавляем их в список

# Записываем результат в файл "myLinks.txt" вместо вывода на экран
# Если нужно перезаписать файл при каждом выполнении, измените 'a' на 'w'
with open("myLinks.txt", 'a') as saved:
    print(links[:10], file=saved)

import os
from PIL import Image

def watermark_photo(input_image_path, watermark_image_path, output_image_path):
    # Открываем базовое изображение
    base_image = Image.open(input_image_path)
    # Открываем изображение водяного знака и конвертируем его в режим с прозрачностью (RGBA)
    watermark = Image.open(watermark_image_path).convert("RGBA")

    # Изменяем размер водяного знака
    position = base_image.size
    newsize = (int(position[0] * 8 / 100), int(position[0] * 8 / 100))
    watermark = watermark.resize(newsize)

    # Устанавливаем позицию водяного знака на изображении
    new_position = position[0] - newsize[0] - 20, position[1] - newsize[1] - 20

    # Создаем новое прозрачное изображение
    transparent = Image.new(mode='RGBA', size=position, color=(0, 0, 0, 0))
    # Вставляем базовое изображение
    transparent.paste(base_image, (0, 0))
    # Вставляем изображение водяного знака
    transparent.paste(watermark, new_position, watermark)

    # Конвертируем прозрачное изображение в тот же режим цветности, что и базовое изображение
    image_mode = base_image.mode
    if image_mode == 'RGB':
        transparent = transparent.convert(image_mode)
    else:
        transparent = transparent.convert('P')

    # Сохраняем изображение с водяным знаком
    transparent.save(output_image_path, optimize=True, quality=100)
    print("Saving " + output_image_path + "...")

from selenium import webdriver
import requests as rq
import os
from bs4 import BeautifulSoup
import time

# Определяем путь к драйверу Chrome
path = input("Enter Path: ")

# Вводим URL-адрес
url = input("Enter URL: ")

# Папка для сохранения изображений
output = "output"

# Функция для получения HTML-кода страницы с помощью Selenium
def get_url(path, url):
    driver = webdriver.Chrome(executable_path=r"{}".format(path))
    driver.get(url)
    print("Loading...")
    res = driver.execute_script("return document.documentElement.outerHTML")
    return res

# Функция для получения ссылок на изображения из HTML-кода
def get_img_links(res):
    soup = BeautifulSoup(res, "lxml")
    imglinks = soup.find_all("img", src=True)
    return imglinks

# Функция для загрузки изображений
def download_img(img_link, index):
    try:
        extensions = [".jpeg", ".jpg", ".png", ".gif"]
        extension = ".jpg"
        for exe in extensions:
            if img_link.find(exe) > 0:
                extension = exe
                break

        img_data = rq.get(img_link).content
        with open(output + "\\" + str(index + 1) + extension, "wb+") as f:
            f.write(img_data)
        f.close()
    except Exception:
        pass

# Получаем HTML-код страницы
result = get_url(path, url)
time.sleep(60)

# Получаем ссылки на изображения
img_links = get_img_links(result)

# Создаем папку для сохранения изображений, если ее нет
if not os.path.isdir(output):
    os.mkdir(output)

# Загружаем изображения
for index, img_link in enumerate(img_links):
    img_link = img_link["src"]
    print("Downloading...")
    if img_link:
        download_img(img_link, index)
print("Download Complete!")

import psutil
from pynotifier import Notification

# Получаем информацию о заряде батареи
battery = psutil.sensors_battery()
plugged = battery.power_plugged
percent = battery.percent

# Проверяем, если заряд батареи меньше или равен 30 и батарея не подключена к источнику питания
if percent <= 30 and plugged != True:
    # Отправляем уведомление о низком заряде батареи
    Notification(
        title="Battery Low",
        description=str(percent) + "% Battery remaining!!",
        duration=5  # Продолжительность отображения уведомления в секундах
    ).send()

import time
from calendar import isleap

# Функция для определения високосного года
def judge_leap_year(year):
    if isleap(year):
        return True
    else:
        return False


# Функция для определения количества дней в каждом месяце
def month_days(month, leap_year):
    if month in [1, 3, 5, 7, 8, 10, 12]:
        return 31
    elif month in [4, 6, 9, 11]:
        return 30
    elif month == 2 and leap_year:
        return 29
    elif month == 2 and (not leap_year):
        return 28


name = input("Введите ваше имя: ")
age = input("Введите ваш возраст: ")
localtime = time.localtime(time.time())

year = int(age)
month = year * 12 + localtime.tm_mon
day = 0

begin_year = int(localtime.tm_year) - year
end_year = begin_year + year

# Рассчитываем количество дней
for y in range(begin_year, end_year):
    if judge_leap_year(y):
        day += 366
    else:
        day += 365

leap_year = judge_leap_year(localtime.tm_year)
for m in range(1, localtime.tm_mon):
    day += month_days(m, leap_year)

day += localtime.tm_mday

print("Возраст %s составляет %d лет или " % (name, year), end="")
print("%d месяцев или %d дней" % (month, day))

import os
import shutil

# Изменяем текущую рабочую директорию на "E:\downloads"
os.chdir("E:\downloads")

# Проверяем количество файлов в директории
files = os.listdir()

# Список расширений файлов для категоризации
extensions = {
    "images": [".jpg", ".png", ".jpeg", ".gif"],
    "videos": [".mp4", ".mkv"],
    "music": [".mp3", ".wav"],
    "archives": [".zip", ".tgz", ".rar", ".tar"],
    "documents": [".pdf", ".docx", ".csv", ".xlsx", ".pptx", ".doc", ".ppt", ".xls"],
    "setup": [".msi", ".exe"],
    "programs": [".py", ".c", ".cpp", ".php", ".C", ".CPP"],
    "design": [".xd", ".psd"],
}


# Функция для определения категории файла на основе его расширения
def get_category(file):
    for category, extensions_list in extensions.items():
        for ext in extensions_list:
            if file.endswith(ext):
                return category
    return "others"


# Итерируемся по каждому файлу
for file in files:
    category = get_category(file)
    if category:
        try:
            shutil.move(file, "../download-sorting/" + category)
        except FileExistsError:
            print(file + " already exists.")
    else:
        try:
            shutil.move(file, "../download-sorting/others")
        except FileExistsError:
            print(file + " already exists.")

import csv
from email.message import EmailMessage
import smtplib


def get_credentials(filepath):
    with open("credentials.txt", "r") as f:
        email_address = f.readline()
        email_pass = f.readline()
    return (email_address, email_pass)


def login(email_address, email_pass, s):
    s.ehlo()
    s.starttls()
    s.ehlo()
    s.login(email_address, email_pass)
    print("Logged in successfully.")


def send_mail():
    s = smtplib.SMTP("smtp.gmail.com", 587)
    email_address, email_pass = get_credentials("./credentials.txt")
    login(email_address, email_pass, s)

    subject = "Welcome to Python"
    body = """Python is an interpreted, high-level,
    general-purpose programming language.\n
    Created by Guido van Rossum and first released in 1991,
    Python's design philosophy emphasizes code readability\n
    with its notable use of significant whitespace"""

    message = EmailMessage()
    message.set_content(body)
    message['Subject'] = subject

    with open("emails.csv", newline="") as csvfile:
        spamreader = csv.reader(csvfile, delimiter=" ", quotechar="|")
        for email in spamreader:
            s.send_message(email_address, email[0], message)
            print("Sent to " + email[0])

    s.quit()
    print("Emails sent successfully.")


if __name__ == "__main__":
    send_mail()

import socket

def get_hostname_IP():
    hostname = input("Введите домен сайта: ")
    try:
        print(f'Hostname: {hostname}')  # Выводим имя хоста на экран
        print(f'IP: {socket.gethostbyname(hostname)}')  # Получаем и выводим IP-адрес
    except socket.gaierror as error:
        print(f'Invalid Hostname, error raised: {error}')  # Обрабатываем ошибку, если введенный адрес недействителен

get_hostname_IP()

from tqdm import tqdm  # Импорт библиотеки для отображения прогресса
from PIL import Image  # Импорт библиотеки для работы с изображениями
import os  # Импорт модуля для работы с операционной системой
from time import sleep  # Импорт функции для добавления паузы

def Resize_image(size, image):
    if os.path.isfile(image):  # Проверка, является ли файл существующим файлом
        try:
            im = Image.open(image)  # Открытие изображения
            im.thumbnail(size, Image.ANTIALIAS)  # Изменение размера изображения
            im.save("resize/" + str(image) + ".jpg")  # Сохранение измененного изображения
        except Exception as ex:  # Обработка возможных исключений
            print(f"Error: {str(ex)} to {image}")

path = input("Enter Path to images: ")  # Ввод пути к изображениям
size = input("Size Height, Width: ")  # Ввод размера изображений
size = tuple(map(int, size.split(",")))  # Преобразование введенного размера в кортеж

os.chdir(path)  # Изменение текущей директории

list_images = os.listdir(path)  # Получение списка файлов в директории
if "resize" not in list_images:  # Проверка наличия директории для измененных изображений
    os.mkdir("resize")  # Создание директории

for image in tqdm(list_images, desc="Resizing Images"):  # Цикл по списку файлов с отображением прогресса
    Resize_image(size, image)  # Изменение размера изображения
    sleep(0.1)  # Пауза в цикле для отображения прогресса
print("Resizing Completed!")  # Вывод сообщения о завершении изменения размеров

import subprocess

# Получение списка всех Wi-Fi профилей
data = (
    subprocess.check_output(["netsh", "wlan", "show", "profiles"])
    .decode("utf-8")
    .split("\n")
)
profiles = [i.split(":")[1][1:-1] for i in data if "All User Profile" in i]

# Для каждого профиля получаем пароль (если доступно) и выводим результаты
for i in profiles:
    # Получение пароля для каждого профиля
    results = (
        subprocess
        .check_output(["netsh", "wlan", "show", "profile", i, "key=clear"])
        .decode("utf-8")
        .split("\n")
    )
    results = [b.split(":")[1][1:-1] for b in results if "Key Content" in b]

    # Вывод результатов на экран
    try:
        print("{:<30}|  {:<}".format(i, results[0]))
    except IndexError:
        print("{:<30}|  {:<}".format(i, ""))

import sys
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import chromedriver_binary

# Получение имени скрипта
script_name = sys.argv[0]

# Настройка веб-драйвера Selenium
options = Options()
options.add_argument('--headless')
driver = webdriver.Chrome(options=options)

try:
    # Получение URL из аргументов командной строки
    url = sys.argv[1]

    # Открытие страницы и создание скриншота
    driver.get(url)
    page_width = driver.execute_script('return document.body.scrollWidth')
    page_height = driver.execute_script('return document.body.scrollHeight')
    driver.set_window_size(page_width, page_height)
    driver.save_screenshot('screenshot.png')
    driver.quit()
    print("SUCCESS")

except IndexError:
    print('Usage: %s URL' % script_name)

import sys
import os
import shutil
import pandas as pd

class Split_Files:
    '''
        Класс для разделения файлов
    '''
    def __init__(self, filename, split_number):
        '''
            Получение имени файла и индекса разделения
            Инициализация директории для вывода, если она существует, то она очищается.
            Получение расширения файла
        '''
        self.file_name = filename
        self.directory = "file_split"
        self.split = int(split_number)
        if os.path.exists(self.directory):
            shutil.rmtree(self.directory)
        os.mkdir(self.directory)
        if self.file_name.endswith('.txt'):
            self.file_extension = '.txt'
        else:
            self.file_extension = '.csv'
        self.file_number = 1

    def split_data(self):
        '''
            Разделение входного файла csv/txt в соответствии с указанным индексом
        '''
        data = pd.read_csv(self.file_name, header=None)
        data.index += 1

        split_frame = pd.DataFrame()
        output_file = f"{self.directory}/split_file{self.file_number}{self.file_extension}"

        for i in range(1, len(data)+1):
            split_frame = split_frame.append(data.iloc[i-1])
            if i % self.split == 0:
                output_file = f"{self.directory}/split_file{self.file_number}{self.file_extension}"
                if self.file_extension == '.txt':
                    split_frame.to_csv(output_file, header=False, index=False, sep=' ')
                else:
                    split_frame.to_csv(output_file, header=False, index=False)
                split_frame.drop(split_frame.index, inplace=True)
                self.file_number += 1
        if not split_frame.empty:
            output_file = f"{self.directory}/split_file{self.file_number}{self.file_extension}"
            split_frame.to_csv(output_file, header=False, index=False)

if __name__ == '__main__':
    file, split_number = sys.argv[1], sys.argv[2]
    sp = Split_Files(file, split_number)
    sp.split_data()

from Crypto.Cipher import AES
from Crypto import Random
from binascii import b2a_hex
import sys

# Получаем открытый текст
plain_text = sys.argv[1]

# Длина ключа должна быть 16 (AES-128), 24 (AES-192) или 32 (AES-256) байтов.
key = b'this is a 16 key'

# Генерируем неповторяющийся вектор инициализации (IV) длиной,
# равной размеру блока AES.
iv = Random.new().read(AES.block_size)

# Инициализируем объект AES с использованием ключа и вектора инициализации (IV),
# используя режим MODE_CFB.
mycipher = AES.new(key, AES.MODE_CFB, iv)

# Добавляем вектор инициализации (IV) в начало зашифрованного шифротекста
# и передаем их вместе.
ciphertext = iv + mycipher.encrypt(plain_text.encode())

# Для расшифровки используем ключ и вектор инициализации (IV),
# чтобы создать новый объект AES.
mydecrypt = AES.new(key, AES.MODE_CFB, ciphertext[:16])

# Используем новый объект AES для расшифровки зашифрованного шифротекста.
decrypttext = mydecrypt.decrypt(ciphertext[16:])

# Выводим результаты
file_out = open("encrypted.bin", "wb")
file_out.write(ciphertext[16:])
file_out.close()

print("Ключ k: ", key)
print("IV: ", b2a_hex(ciphertext)[:16])
print("Зашифрованные данные: ", b2a_hex(ciphertext)[16:])
print("Расшифрованные данные: ", decrypttext.decode())

import os
import argparse
import pyautogui
import time

# Создание парсера аргументов командной строки
parser = argparse.ArgumentParser()

# Определение аргументов
parser.add_argument("-p", "--path", help="абсолютный путь для сохранения скриншотов", default=r"./images")
parser.add_argument("-t", "--type", help="h (в часах) или m (в минутах) или s (в секундах)", default='h')
parser.add_argument("-f", "--frequency", help="частота создания скриншотов в час/мин/сек", default=1, type=int)

# Получение аргументов из командной строки
args = parser.parse_args()

# Расчет временного интервала между скриншотами в секундах
sec = 0.
if args.type == 'h':
    sec = 60 * 60 / args.frequency
elif args.type == 'm':
    sec = 60 / args.frequency

# Установка минимального значения временного интервала в 1 секунду
if sec < 1.:
    sec = 1.

# Создание директории для сохранения скриншотов, если она не существует
if os.path.isdir(args.path) != True:
    os.mkdir(args.path)

try:
    while True:
        t = time.localtime()
        current_time = time.strftime("%H_%M_%S", t)
        file = current_time + ".jpg"
        image = pyautogui.screenshot(os.path.join(args.path, file))
        print(f"{file} успешно сохранен.\n")
        time.sleep(sec)

except KeyboardInterrupt:
    print("Программа завершена по запросу пользователя.")

try:
    # Вывод меню с выбором опции
    menu = int(input("Выберите опцию:\n 1. Десятичное в двоичное\n 2. Двоичное в десятичное\n Опция: "))
    
    # Проверка выбранной опции на валидность
    if menu < 1 or menu > 2:
        raise ValueError
    
    # Обработка выбранной опции
    if menu == 1:
        # Ввод десятичного числа
        dec = int(input("Введите ваше десятичное число:\nДесятичное: "))
        # Преобразование десятичного числа в двоичное и вывод результата
        print("Двоичное: {}".format(bin(dec)[2:]))
    elif menu == 2:
        # Ввод двоичного числа
        binary = input("Введите ваше двоичное число:\nДвоичное: ")
        # Преобразование двоичного числа в десятичное и вывод результата
        print("Десятичное: {}".format(int(binary, 2)))

except ValueError:
    # В случае некорректного выбора опции выводится сообщение об ошибке
    print("Пожалуйста, выберите допустимую опцию.")

import click

@click.group()
@click.pass_context
def todo(ctx):
    '''Простое CLI-приложение для списка задач'''
    ctx.ensure_object(dict)
    # Открываем файл todo.txt – первая строка содержит последний идентификатор, остальные строки содержат задачи и их идентификаторы
    with open('./todo.txt') as f:
        content = f.readlines()
    # Переносим данные из файла todo.txt в контекст
    ctx.obj['LATEST'] = int(content[:1][0])
    ctx.obj['TASKS'] = {en.split('```')[0]:en.split('```')[1][:-1] for en in content[1:]}

@todo.command()
@click.pass_context
def tasks(ctx):
    '''Вывод задач'''
    if ctx.obj['TASKS']:
        click.echo('ВАШИ ЗАДАЧИ\n**********')
        # Перебираем все задачи, хранящиеся в контексте
        for i, task in ctx.obj['TASKS'].items():
            click.echo('• ' + task + ' (ID: ' + i + ')')
        click.echo('')
    else:
        click.echo('Задач пока нет! Используйте команду ADD для добавления задачи.\n')

@todo.command()
@click.pass_context
@click.option('-add', '--add_task', prompt='Введите задачу для добавления')
def add(ctx, add_task):
    '''Добавление задачи'''
    if add_task:
        # Добавляем задачу в список в контексте
        ctx.obj['TASKS'][ctx.obj['LATEST']] = add_task
        click.echo('Добавлена задача "' + add_task + '" с ID ' + str(ctx.obj['LATEST']))
        # Открываем файл todo.txt и записываем текущий индекс и задачи с их идентификаторами (разделенными "```")
        curr_ind = [str(ctx.obj['LATEST'] + 1)]
        tasks = [str(i) + '```' + t for (i, t) in ctx.obj['TASKS'].items()]
        with open('./todo.txt', 'w') as f:
            f.writelines(['%s\n' % en for en in curr_ind + tasks])

@todo.command()
@click.pass_context
@click.option('-fin', '--fin_taskid', prompt='Введите ID задачи для завершения', type=int)
def done(ctx, fin_taskid):
    '''Удаление задачи по ID'''
    # Находим задачу с указанным идентификатором
    if str(fin_taskid) in ctx.obj['TASKS'].keys():
        task = ctx.obj['TASKS'][str(fin_taskid)]
        # Удаляем задачу из списка задач в контексте
        del ctx.obj['TASKS'][str(fin_taskid)]
        click.echo('Завершена и удалена задача "' + task + '" с ID ' + str(fin_taskid))
        # Открываем файл todo.txt и записываем текущий индекс и задачи с их идентификаторами (разделенными "```")
        if ctx.obj['TASKS']:
            curr_ind = [str(ctx.obj['LATEST'] + 1)]
            tasks = [str(i) + '```' + t for (i, t) in ctx.obj['TASKS'].items()]
            with open('./todo.txt', 'w') as f:
                f.writelines(['%s\n' % en for en in curr_ind + tasks])
        else:
            # Сбрасываем индекс на 0, если список пуст
            with open('./todo.txt', 'w') as f:
                f.writelines([str(0) + '\n'])
    else:
        click.echo('Ошибка: нет задачи с ID ' + str(fin_taskid))

if __name__ == '__main__':
    todo()

import requests 
import json
import sys
from pprint import pprint

# The below 4 lines bring out the value of currency from the api at fixer.io.  I had to register there, the key is unique to me.
url = "http://data.fixer.io/api/latest?access_key=33ec7c73f8a4eb6b9b5b5f95118b2275"
data = requests.get(url).text
data2 = json.loads(data) #brings whether request was successful,timestamp etc
fx = data2["rates"]

currencies = [
    "AED : Emirati Dirham,United Arab Emirates Dirham",
    "AFN : Afghan Afghani,Afghanistan Afghani",
    "ALL : Albanian Lek,Albania Lek",
    "AMD : Armenian Dram,Armenia Dram",
    "ANG : Dutch Guilder,Netherlands Antilles Guilder,Bonaire,Curaçao,Saba,Sint Eustatius,Sint Maarten",
    "AOA : Angolan Kwanza,Angola Kwanza",
    "ARS : Argentine Peso,Argentina Peso,Islas Malvinas",
    "AUD : Australian Dollar,Australia Dollar,Christmas Island,Cocos (Keeling) Islands,Norfolk Island,Ashmore and Cartier Islands,Australian Antarctic Territory,Coral Sea Islands,Heard Island,McDonald Islands,Kiribati,Nauru",
    "AWG : Aruban or Dutch Guilder,Aruba Guilder",
    "AZN : Azerbaijan Manat,Azerbaijan Manat",
    "BAM : Bosnian Convertible Mark,Bosnia and Herzegovina Convertible Mark",
    "BBD : Barbadian or Bajan Dollar,Barbados Dollar",
    "BDT : Bangladeshi Taka,Bangladesh Taka",
    "BGN : Bulgarian Lev,Bulgaria Lev",
    "BHD : Bahraini Dinar,Bahrain Dinar",
    "BIF : Burundian Franc,Burundi Franc",
    "BMD : Bermudian Dollar,Bermuda Dollar",
    "BND : Bruneian Dollar,Brunei Darussalam Dollar",
    "BOB : Bolivian Bolíviano,Bolivia Bolíviano",
    "BRL : Brazilian Real,Brazil Real",
    "BSD : Bahamian Dollar,Bahamas Dollar",
    "BTC : Bitcoin,BTC, XBT",
    "BTN : Bhutanese Ngultrum,Bhutan Ngultrum",
    "BWP : Botswana Pula,Botswana Pula",
    "BYN : Belarusian Ruble,Belarus Ruble",
    "BYR : Belarusian Ruble,Belarus Ruble",
    "BZD : Belizean Dollar,Belize Dollar",
    "CAD : Canadian Dollar,Canada Dollar",
    "CDF : Congolese Franc,Congo/Kinshasa Franc",
    "CHF : Swiss Franc,Switzerland Franc,Liechtenstein,Campione d'Italia,Büsingen am Hochrhein",
    "CLF : Chilean Unit of Account",
    "CLP : Chilean Peso,Chile Peso",
    "CNY : Chinese Yuan Renminbi,China Yuan Renminbi",
    "COP : Colombian Peso,Colombia Peso",
    "CRC : Costa Rican Colon,Costa Rica Colon",
    "CUC : Cuban Convertible Peso,Cuba Convertible Peso",
    "CUP : Cuban Peso,Cuba Peso",
    "CVE : Cape Verdean Escudo,Cape Verde Escudo",
    "CZK : Czech Koruna,Czech Republic Koruna",
    "DJF : Djiboutian Franc,Djibouti Franc",
    "DKK : Danish Krone,Denmark Krone,Faroe Islands,Greenland",
    "DOP : Dominican Peso,Dominican Republic Peso",
    "DZD : Algerian Dinar,Algeria Dinar",
    "EGP : Egyptian Pound,Egypt Pound,Gaza Strip",
    "ERN : Eritrean Nakfa,Eritrea Nakfa",
    "ETB : Ethiopian Birr,Ethiopia Birr,Eritrea",
    "EUR : Euro,Euro Member Countries,Andorra,Austria,Azores,Baleares (Balearic Islands),Belgium,Canary Islands,Cyprus,Finland,France,French Guiana,French Southern Territories,Germany,Greece,Guadeloupe,Holland (Netherlands),Holy See (Vatican City),Ireland (Eire),Italy,Luxembourg,Madeira Islands,Malta,Monaco,Montenegro,Netherlands",
    "FJD : Fijian Dollar,Fiji Dollar",
    "FKP : Falkland Island Pound,Falkland Islands (Malvinas) Pound",
    "GBP : British Pound,United Kingdom Pound,United Kingdom (UK),England,Northern Ireland,Scotland,Wales,Falkland Islands,Gibraltar,Guernsey,Isle of Man,Jersey,Saint Helena and Ascension,South Georgia and the South Sandwich Islands,Tristan da Cunha",
    "GEL : Georgian Lari,Georgia Lari",
    "GGP : Guernsey Pound,Guernsey Pound",
    "GHS : Ghanaian Cedi,Ghana Cedi",
    "GIP : Gibraltar Pound,Gibraltar Pound",
    "GMD : Gambian Dalasi,Gambia Dalasi",
    "GNF : Guinean Franc,Guinea Franc",
    "GTQ : Guatemalan Quetzal,Guatemala Quetzal",
    "GYD : Guyanese Dollar,Guyana Dollar",
    "HKD : Hong Kong Dollar,Hong Kong Dollar",
    "HNL : Honduran Lempira,Honduras Lempira",
    "HRK : Croatian Kuna,Croatia Kuna",
    "HTG : Haitian Gourde,Haiti Gourde",
    "HUF : Hungarian Forint,Hungary Forint",
    "IDR : Indonesian Rupiah,Indonesia Rupiah,East Timor",
    "ILS : Israeli Shekel,Israel Shekel,Palestinian Territories",
    "IMP : Isle of Man Pound,Isle of Man Pound",
    "INR : Indian Rupee,India Rupee,Bhutan,Nepal",
    "IQD : Iraqi Dinar,Iraq Dinar",
    "IRR : Iranian Rial,Iran Rial",
    "ISK : Icelandic Krona,Iceland Krona",
    "JEP : Jersey Pound,Jersey Pound",
    "JMD : Jamaican Dollar,Jamaica Dollar",
    "JOD : Jordanian Dinar,Jordan Dinar",
    "JPY : Japanese Yen,Japan Yen",
    "KES : Kenyan Shilling,Kenya Shilling",
    "KGS : Kyrgyzstani Som,Kyrgyzstan Som",
    "KHR : Cambodian Riel,Cambodia Riel",
    "KMF : Comorian Franc,Comorian Franc",
    "KPW : North Korean Won,Korea (North) Won",
    "KRW : South Korean Won,Korea (South) Won",
    "KWD : Kuwaiti Dinar,Kuwait Dinar",
    "KYD : Caymanian Dollar,Cayman Islands Dollar",
    "KZT : Kazakhstani Tenge,Kazakhstan Tenge",
    "LAK : Lao Kip,Laos Kip",
    "LBP : Lebanese Pound,Lebanon Pound",
    "LKR : Sri Lankan Rupee,Sri Lanka Rupee",
    "LRD : Liberian Dollar,Liberia Dollar",
    "LSL : Basotho Loti,Lesotho Loti",
    "LTL : Lithuanian litas",
    "LVL : Latvia Lats",
    "LYD : Libyan Dinar,Libya Dinar",
    "MAD : Moroccan Dirham,Morocco Dirham,Western Sahara",
    "MDL : Moldovan Leu,Moldova Leu",
    "MGA : Malagasy Ariary,Madagascar Ariary",
    "MKD : Macedonian Denar,Macedonia Denar",
    "MMK : Burmese Kyat,Myanmar (Burma) Kyat",
    "MNT : Mongolian Tughrik,Mongolia Tughrik",
    "MOP : Macau Pataca,Macau Pataca",
    "MRU : Mauritanian Ouguiya,Mauritania Ouguiya",
    "MUR : Mauritian Rupee,Mauritius Rupee",
    "MVR : Maldivian Rufiyaa,Maldives (Maldive Islands) Rufiyaa",
    "MWK : Malawian Kwacha,Malawi Kwacha",
    "MXN : Mexican Peso,Mexico Peso",
    "MYR : Malaysian Ringgit,Malaysia Ringgit",
    "MZN : Mozambican Metical,Mozambique Metical",
    "NAD : Namibian Dollar,Namibia Dollar",
    "NGN : Nigerian Naira,Nigeria Naira",
    "NIO : Nicaraguan Cordoba,Nicaragua Cordoba",
    "NOK : Norwegian Krone,Norway Krone,Bouvet Island,Svalbard,Jan Mayen,Queen Maud Land,Peter I Island",
    "NPR : Nepalese Rupee,Nepal Rupee,India (unofficially near India-Nepal border)",
    "NZD : New Zealand Dollar,New Zealand Dollar,Cook Islands,Niue,Pitcairn Islands,Tokelau",
    "OMR : Omani Rial,Oman Rial",
    "PAB : Panamanian Balboa,Panama Balboa",
    "PEN : Peruvian Sol,Peru Sol",
    "PGK : Papua New Guinean Kina,Papua New Guinea Kina",
    "PHP : Philippine Peso,Philippines Peso",
    "PKR : Pakistani Rupee,Pakistan Rupee",
    "PLN : Polish Zloty,Poland Zloty",
    "PYG : Paraguayan Guarani,Paraguay Guarani",
    "QAR : Qatari Riyal,Qatar Riyal",
    "RON : Romanian Leu,Romania Leu",
    "RSD : Serbian Dinar,Serbia Dinar",
    "RUB : Russian Ruble,Russia Ruble,Tajikistan,Abkhazia,South Ossetia",
    "RWF : Rwandan Franc,Rwanda Franc",
    "SAR : Saudi Arabian Riyal,Saudi Arabia Riyal",
    "SBD : Solomon Islander Dollar,Solomon Islands Dollar",
    "SCR : Seychellois Rupee,Seychelles Rupee",
    "SDG : Sudanese Pound,Sudan Pound",
    "SEK : Swedish Krona,Sweden Krona",
    "SGD : Singapore Dollar,Singapore Dollar",
    "SHP : Saint Helenian Pound,Saint Helena Pound",
    "SLL : Sierra Leonean Leone,Sierra Leone Leone",
    "SOS : Somali Shilling,Somalia Shilling",
    "SRD : Surinamese Dollar,Suriname Dollar",
    "STN : Sao Tomean Dobra,São Tomé and Príncipe Dobra",
    "SVC : Salvadoran Colon,El Salvador Colon",
    "SYP : Syrian Pound,Syria Pound",
    "SZL : Swazi Lilangeni,eSwatini Lilangeni",
    "THB : Thai Baht,Thailand Baht",
    "TJS : Tajikistani Somoni,Tajikistan Somoni",
    "TMT : Turkmenistani Manat,Turkmenistan Manat",
    "TND : Tunisian Dinar,Tunisia Dinar",
    "TOP : Tongan Pa'anga,Tonga Pa'anga",
    "TRY : Turkish Lira,Turkey Lira,North Cyprus",
    "TTD : Trinidadian Dollar,Trinidad and Tobago Dollar,Trinidad,Tobago",
    "TWD : Taiwan New Dollar,Taiwan New Dollar",
    "TZS : Tanzanian Shilling,Tanzania Shilling",
    "UAH : Ukrainian Hryvnia,Ukraine Hryvnia",
    "UGX : Ugandan Shilling,Uganda Shilling",
    "USD : US Dollar,United States Dollar,America,American Samoa,American Virgin Islands,British Indian Ocean Territory,British Virgin Islands,Ecuador,El Salvador,Guam,Haiti,Micronesia,Northern Mariana Islands,Palau,Panama,Puerto Rico,Turks and Caicos Islands,United States Minor Outlying Islands,Wake Island,East Timor",
    "UYU : Uruguayan Peso,Uruguay Peso",
    "UZS : Uzbekistani Som,Uzbekistan Som",
    "VEF : Venezuelan Bolívar,Venezuela Bolívar",
    "VND : Vietnamese Dong,Viet Nam Dong",
    "VUV : Ni-Vanuatu Vatu,Vanuatu Vatu",
    "WST : Samoan Tala,Samoa Tala",
    "XAF : Central African CFA Franc BEAC,Communauté Financière Africaine (BEAC) CFA Franc BEAC,Cameroon,Central African Republic,Chad,Congo/Brazzaville,Equatorial Guinea,Gabon",
    "XAG : Silver Ounce,Silver",
    "XAU : Gold Ounce,Gold",
    "XCD : East Caribbean Dollar,East Caribbean Dollar,Anguilla,Antigua and Barbuda,Dominica,Grenada,The Grenadines and Saint Vincent,Montserrat",
    "XDR : IMF Special Drawing Rights,International Monetary Fund (IMF) Special Drawing Rights",
    "XOF : CFA Franc,Communauté Financière Africaine (BCEAO) Franc,Benin,Burkina Faso,Ivory Coast,Guinea-Bissau,Mali,Niger,Senegal,Togo",
    "XPF : CFP Franc,Comptoirs Français du Pacifique (CFP) Franc,French Polynesia,New Caledonia,Wallis and Futuna Islands",
    "YER : Yemeni Rial,Yemen Rial",
    "ZAR : South African Rand,South Africa Rand,Lesotho,Namibia",
    "ZMK : Zambian Kwacha,Zambia Kwacha",
    "ZMW : Zambian Kwacha,Zambia Kwacha",
    "ZWL : Zimbabwean Dollar,Zimbabwe Dollar",
]


# The below function calculates the actual conversion
def function1():
    query = input(
        "Please specify the amount of currency to convert, from currency, to currency (with space in between).\nPress SHOW to see list of currencies available. \nPress Q to quit. \n"
    )
    if query == "Q":
        sys.exit()
    elif query == "SHOW":
        pprint(currencies)
        function1()
    else:
        qty, fromC, toC = query.split(" ")
        fromC = fromC.upper()
        toC = toC.upper()
        qty = float(round(int(qty), 2))
        amount = round(qty * fx[toC] / fx[fromC], 2)
        print(f"{qty} of currency {fromC} amounts to {amount} of currency {toC} today")


try:
    function1()
except KeyError:
    print("You seem to have inputted wrongly, retry!")
    function1()

import tkinter as Tkinter
from datetime import datetime
counter = 0
running = False


def counter_label(label):
    def count():
        if running:
            global counter
            # To manage the intial delay. 
            if counter == 0:
                display = 'Ready!'
            else:
                tt = datetime.utcfromtimestamp(counter)
                string = tt.strftime('%H:%M:%S')
                display = string

            label['text'] = display

            # label.after(arg1, arg2) delays by 
            # first argument given in milliseconds 
            # and then calls the function given as second argument. 
            # Generally like here we need to call the 
            # function in which it is present repeatedly. 
            # Delays by 1000ms=1 seconds and call count again. 
            label.after(1000, count)
            counter += 1

    # Triggering the start of the counter. 
    count()


# start function of the stopwatch 
def Start(label):
    global running
    running = True
    counter_label(label)
    start['state'] = 'disabled'
    stop['state'] = 'normal'
    reset['state'] = 'normal'


# Stop function of the stopwatch 
def Stop():
    global running
    start['state'] = 'normal'
    stop['state'] = 'disabled'
    reset['state'] = 'normal'
    running = False


# Reset function of the stopwatch 
def Reset(label):
    global counter
    counter = 0
    # If reset is pressed after pressing stop. 
    if not running:
        reset['state'] = 'disabled'
        label['text'] = '00:00:00'
    # If reset is pressed while the stopwatch is running. 
    else:
        label['text'] = '00:00:00'


root = Tkinter.Tk()
root.title("Stopwatch")

# Fixing the window size.
root.minsize(width=250, height=70)
label = Tkinter.Label(root, text='Ready!', fg='black', font='Verdana 30 bold')
label.pack()
f = Tkinter.Frame(root)
start = Tkinter.Button(f, text='Start', width=6, command=lambda: Start(label))
stop = Tkinter.Button(f, text='Stop', width=6, state='disabled', command=Stop)
reset = Tkinter.Button(f, text='Reset', width=6, state='disabled', command=lambda: Reset(label))
f.pack(anchor='center', pady=5)
start.pack(side='left')
stop.pack(side='left')
reset.pack(side='left')
root.mainloop()

import zipfile
import sys
import os


# compress file function
def zip_file(file_path):
    compress_file = zipfile.ZipFile(file_path + '.zip', 'w')
    compress_file.write(path, compress_type=zipfile.ZIP_DEFLATED)
    compress_file.close()


# Declare the function to return all file paths of the particular directory
def retrieve_file_paths(dir_name):
    # setup file paths variable
    file_paths = []

    # Read all directory, subdirectories and file lists
    for root, directories, files in os.walk(dir_name):
        for filename in files:
            # Create the full file path by using os module.
            file_path = os.path.join(root, filename)
            file_paths.append(file_path)

    # return all paths
    return file_paths


def zip_dir(dir_path, file_paths):
    # write files and folders to a zipfile
    compress_dir = zipfile.ZipFile(dir_path + '.zip', 'w')
    with compress_dir:
        # write each file separately
        for file in file_paths:
            compress_dir.write(file)


if __name__ == "__main__":
    path = sys.argv[1]

    if os.path.isdir(path):
        files_path = retrieve_file_paths(path)
        # print the list of files to be zipped
        print('The following list of files will be zipped:')
        for file_name in files_path:
            print(file_name)
        zip_dir(path, files_path)
    elif os.path.isfile(path):
        print('The %s will be zipped:' % path)
        zip_file(path)
    else:
        print('a special file(socket,FIFO,device file), please input file or dir')

from bs4 import BeautifulSoup
import requests
import pandas as pd
import os

# Setting up session
s = requests.session()  

# List contaiting all the films for which data has to be scraped from IMDB
films = []

# Lists contaiting web scraped data
names = []
ratings = []
genres = []

# Define path where your films are present 
# For eg: "/Users/utkarsh/Desktop/films"
path = input("Enter the path where your films are: ")

# Films with extensions
filmswe = os.listdir(path)

for film in filmswe:
    # Append into my films list (without extensions)
    films.append(os.path.splitext(film)[0])
    # print(os.path.splitext(film)[0])

for line in films:
    # x = line.split(", ")
    title = line.lower()
    # release = x[1]
    query = "+".join(title.split()) 
    URL = "https://www.imdb.com/search/title/?title=" + query
    print(URL)
    # print(release)
    try: 
        response = s.get(URL)

        #getting contect from IMDB Website
        content = response.content

        # print(response.status_code)

        soup = BeautifulSoup(response.content, features="html.parser") 
        #searching all films containers found
        containers = soup.find_all("div", class_="lister-item-content")
        for result in containers:
            name1 = result.h3.a.text
            name = result.h3.a.text.lower()

            # Uncomment below lines if you want year specific as well, define year variable before this 
            # year = result.h3.find(
            # "span", class_="lister-item-year text-muted unbold"
            # ).text.lower() 

            #if film found (searching using name)
            if title in name:
                #scraping rating
                rating = result.find("div",class_="inline-block ratings-imdb-rating")["data-value"]
                #scraping genre
                genre = result.p.find("span", class_="genre")
                genre = genre.contents[0]

                #appending name, rating and genre to individual lists
                names.append(name1)
                ratings.append(rating)
                genres.append(genre)



    except Exception:
        print("Try again with valid combination of tile and release year")

#storing in pandas dataframe
df = pd.DataFrame({'Film Name':names,'Rating':ratings,'Genre':genres}) 

#making csv using pandas
df.to_csv('film_ratings.csv', index=False, encoding='utf-8')

from selenium import webdriver
import csv
import time

items=[]
driver=webdriver.Chrome(r"C:/Users/hp/Anaconda3/chromedriver.exe")

driver.get('https://www.youtube.com/watch?v=iFPMz36std4')

driver.execute_script('window.scrollTo(1, 500);')

#now wait let load the comments
time.sleep(5)

driver.execute_script('window.scrollTo(1, 3000);')


username_elems = driver.find_elements_by_xpath('//*[@id="author-text"]')
comment_elems = driver.find_elements_by_xpath('//*[@id="content-text"]')
for username, comment in zip(username_elems, comment_elems):
    item = {}
    item['Author'] = username.text
    item['Comment'] = comment.text
    items.append(item)
filename = 'C:/Users/hp/Desktop/commentlist.csv'
with open(filename, 'w', newline='', encoding='utf-8') as f: 
    w = csv.DictWriter(f,['Author','Comment']) 
    w.writeheader() 
    for item in items: 
        w.writerow(item) 

from gtts import gTTS 
import os
file = open("abc.txt", "r").read()

speech = gTTS(text=file, lang='en', slow=False)
speech.save("voice.mp3")
os.system("voice.mp3")