#Разработка архиватора файлов

import tkinter as tk
from tkinter import filedialog
import shutil

# Создаем главное окно приложения
root = tk.Tk()
root.title("Архиватор")
root.geometry("640x480")

# Функция для выбора папки с файлами
def choose_folder():
    folder_path = filedialog.askdirectory()
    folder_path_entry.delete(0, tk.END)
    folder_path_entry.insert(0, folder_path)

# Функция для архивирования файлов
def archive_files():
    # Получаем путь к выбранной папке
    folder_path = folder_path_entry.get()

    # Получаем путь и имя для создания архива
    archive_path = filedialog.asksaveasfilename(defaultextension=".zip")

    try:
        # Архивируем файлы
        shutil.make_archive(archive_path, "zip", folder_path)
        result_label.config(text="Файлы успешно заархивированы!")
    except Exception as e:
        result_label.config(text="Файлы успешно заархивированы!Ошибка при архивировании файлов:" + str(e))

# Функция для разархивирования файлов
def extract_files():
    # Получаем путь и имя выбранного архива
    archive_path = filedialog.askopenfilename()

    # Получаем путь для разархивирования файлов
    extract_path = filedialog.askdirectory()

    try:
        # Разархивируем файлы
        shutil.unpack_archive(archive_path, extract_path)
        result_label.config(text="Файлы извлечены успешно!")
    except Exception as e:
        result_label.config(text="Ошибка при извлечении файлов: " + str(e))

# Создаем элементы пользовательского интерфейса
folder_path_label = tk.Label(root, text="Путь к папке:")
folder_path_entry = tk.Entry(root, width=30)
choose_folder_button = tk.Button(root, text="Выберите папку", command=choose_folder)
archive_button = tk.Button(root, text="Архивировать файлы", command=archive_files)
extract_button = tk.Button(root, text="Извлечь файлы", command=extract_files)
result_label = tk.Label(root, text="")

# Размещаем элементы на главном окне
folder_path_label.pack()
folder_path_entry.pack()
choose_folder_button.pack()
archive_button.pack()
extract_button.pack()
result_label.pack()

# Запускаем главный цикл приложения
root.mainloop()


    
  

    
#Разработка шифровальщика файлов
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QFileDialog, QMessageBox
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes

class EncryptionApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Приложение для шифрования файлов")
        self.setGeometry(100, 100, 640, 480)

        self.folder_label = QLabel("Выбранная папка: ", self)
        self.folder_label.setGeometry(20, 20, 600, 30)

        self.select_folder_button = QPushButton("Выбрать папку", self)
        self.select_folder_button.setGeometry(20, 60, 150, 30)
        self.select_folder_button.clicked.connect(self.select_folder)

        self.encrypt_button = QPushButton("Шифровать файлы", self)
        self.encrypt_button.setGeometry(20, 100, 150, 30)
        self.encrypt_button.clicked.connect(self.encrypt_files)

        self.decrypt_button = QPushButton("Расшифровывать файлы", self)
        self.decrypt_button.setGeometry(20, 140, 150, 30)
        self.decrypt_button.clicked.connect(self.decrypt_files)

        self.key_label = QLabel("Ключ шифрования: ", self)
        self.key_label.setGeometry(20, 180, 600, 30)

        self.generate_key_button = QPushButton("Генерировать ключ", self)
        self.generate_key_button.setGeometry(20, 220, 150, 30)
        self.generate_key_button.clicked.connect(self.generate_key)

        self.status_label = QLabel("", self)
        self.status_label.setGeometry(20, 260, 600, 30)

        self.key = None

    def select_folder(self):
        folder_path = QFileDialog.getExistingDirectory(self, "Выбрать папку")
        self.folder_label.setText("Выбранная папка: " + folder_path)

    def encrypt_files(self):
        folder_path = self.folder_label.text().replace("Выбранная папка: ", "")
        if not folder_path:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, выберите папку.")
            return

        if not self.key:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, сгенерируйте ключ шифрования.")
            return

        try:
            # Шифрование файлов с использованием алгоритма AES
            files = os.listdir(folder_path)
            for file in files:
                file_path = os.path.join(folder_path, file)
                if os.path.isfile(file_path):
                    with open(file_path, "rb") as f:
                        plaintext = f.read()
                    cipher = AES.new(self.key, AES.MODE_CBC)
                    ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
                    with open(file_path, "wb") as f:
                        f.write(cipher.iv + ciphertext)
            self.status_label.setText("Шифрование завершено.")
        except Exception as e:
            self.status_label.setText(f"Ошибка шифрования: {str(e)}")

    def decrypt_files(self):
        folder_path = self.folder_label.text().replace("Выбранная папка: ", "")
        if not folder_path:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, выберите папку.")
            return

        if not self.key:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, сгенерируйте ключ расшифрования.")
            return

        try:
            # Дешифрование файлов с использованием алгоритма AES
            files = os.listdir(folder_path)
            for file in files:
                file_path = os.path.join(folder_path, file)
                if os.path.isfile(file_path):
                    with open(file_path, "rb") as f:
                        ciphertext = f.read()
                    iv = ciphertext[:AES.block_size]
                    cipher = AES.new(self.key, AES.MODE_CBC, iv)
                    plaintext = unpad(cipher.decrypt(ciphertext[AES.block_size:]), AES.block_size)
                    with open(file_path, "wb") as f:
                        f.write(plaintext)
            self.status_label.setText("Расшифровка завершена.")
        except Exception as e:
            self.status_label.setText(f"Не удалось расшифровать: {str(e)}")

    def generate_key(self):
        self.key = get_random_bytes(16)
        self.key_label.setText("Ключ шифрования: " + self.key.hex())

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = EncryptionApp()
    window.show()
    sys.exit(app.exec_())


    
  

    
#Удаление дубликатов файлов
import sys
import os
import hashlib
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QFileDialog, QMessageBox

class DuplicateRemoverApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Удаление дубликатов файлов")
        self.setGeometry(100, 100, 640, 480)

        self.folder_label = QLabel("Выбранная папка: ", self)
        self.folder_label.setGeometry(20, 20, 600, 30)

        self.select_folder_button = QPushButton("Выбрать папку", self)
        self.select_folder_button.setGeometry(20, 60, 150, 30)
        self.select_folder_button.clicked.connect(self.select_folder)

        self.remove_duplicates_button = QPushButton("Удалить дубликаты", self)
        self.remove_duplicates_button.setGeometry(20, 100, 150, 30)
        self.remove_duplicates_button.clicked.connect(self.remove_duplicates)

        self.status_label = QLabel("", self)
        self.status_label.setGeometry(20, 140, 600, 30)

    def select_folder(self):
        folder_path = QFileDialog.getExistingDirectory(self, "Выбрать папку")
        self.folder_label.setText("Выбранная папка: " + folder_path)

    def remove_duplicates(self):
        folder_path = self.folder_label.text().replace("Выбранная папка: ", "")
        if not folder_path:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, выберите папку.")
            return

        try:
            # Создание словаря, где ключом является хэш файла, а значением - список файлов с одинаковым хэшем
            file_hash_dict = {}
            for root, dirs, files in os.walk(folder_path):
                for file in files:
                    file_path = os.path.join(root, file)
                    file_hash = hash_file(file_path)
                    if file_hash in file_hash_dict:
                        file_hash_dict[file_hash].append(file_path)
                    else:
                        file_hash_dict[file_hash] = [file_path]

            # Удаление дубликатов файлов
            for file_list in file_hash_dict.values():
                if len(file_list) > 1:
                    # Оставляем только один файл с наименьшим размером, остальные удаляем
                    min_size = min([os.path.getsize(file) for file in file_list])
                    for file in file_list:
                        if os.path.getsize(file) > min_size:
                            os.remove(file)

            self.status_label.setText("Удаление дубликатов выполенено.")
        except Exception as e:
            self.status_label.setText(f"Не удалось удалить дубликаты: {str(e)}")

def hash_file(file_path):
    # Функция для получения хэша файла
    CHUNK_SIZE = 65536  # Размер блока для чтения файла
    hash_obj = hashlib.sha256()
    with open(file_path, 'rb') as f:
        chunk = f.read(CHUNK_SIZE)
        while len(chunk) > 0:
            hash_obj.update(chunk)
            chunk = f.read(CHUNK_SIZE)
    return hash_obj.digest()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = DuplicateRemoverApp()
    window.show()
    sys.exit(app.exec_())

    
  

    
#Генератор QR-кода
import sys
import os
import qrcode
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit, QFileDialog, QMessageBox

class QRCodeGeneratorApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Генератор QR-кода")
        self.setGeometry(100, 100, 640, 480)

        self.text_label = QLabel("Текст:", self)
        self.text_label.setGeometry(20, 20, 100, 30)

        self.text_input = QLineEdit(self)
        self.text_input.setGeometry(130, 20, 400, 30)

        self.generate_button = QPushButton("Сгенерировать QR-код", self)
        self.generate_button.setGeometry(20, 60, 200, 30)
        self.generate_button.clicked.connect(self.generate_qr_code)

        self.save_button = QPushButton("Сохранить QR-код", self)
        self.save_button.setGeometry(20, 100, 200, 30)
        self.save_button.clicked.connect(self.save_qr_code)

    def generate_qr_code(self):
        text = self.text_input.text()
        if not text:
            QMessageBox.warning(self, "Ошибка", "Пожалуйста, введите текст.")
            return

        qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=4)
        qr.add_data(text)
        qr.make(fit=True)

        self.qr_code = qr.make_image(fill_color="black", back_color="white")
        self.qr_code.show()

    def save_qr_code(self):
        if not hasattr(self, 'qr_code'):
            QMessageBox.warning(self, "Ошибка", "Сначала сгенерируйте QR-код.")
            return

        save_path, _ = QFileDialog.getSaveFileName(self, "Сохранить QR-код", "", "PNG files (*.png)")
        if not save_path:
            return

        try:
            self.qr_code.save(save_path)
            QMessageBox.information(self, "Успех", "QR-код успешно сохранен.")
        except Exception as e:
            QMessageBox.warning(self, "Ошибка", f"Не удалось сохранить QR-код: {str(e)}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = QRCodeGeneratorApp()
    window.show()
    sys.exit(app.exec_())

    
  

    
#Переводчик текста
#Для полноценной работы вставьте API-ключ Яндекс.Переводчика в переменную api_key.
import sys
import requests
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QTextEdit, QComboBox, QMessageBox, QFileDialog


class TranslationApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Переводчик")
        self.setGeometry(100, 100, 640, 480)

        self.text_label = QLabel("Текст:", self)
        self.text_label.setGeometry(20, 20, 100, 30)

        self.text_input = QTextEdit(self)
        self.text_input.setGeometry(130, 20, 400, 120)

        self.source_lang_label = QLabel("Исходный язык:", self)
        self.source_lang_label.setGeometry(20, 160, 100, 30)

        self.source_lang_combo = QComboBox(self)
        self.source_lang_combo.setGeometry(130, 160, 200, 30)

        self.target_lang_label = QLabel("Целевой язык:", self)
        self.target_lang_label.setGeometry(20, 200, 100, 30)

        self.target_lang_combo = QComboBox(self)
        self.target_lang_combo.setGeometry(130, 200, 200, 30)

        self.translate_button = QPushButton("Перевести", self)
        self.translate_button.setGeometry(20, 240, 100, 30)
        self.translate_button.clicked.connect(self.translate_text)

        self.save_button = QPushButton("Сохранить", self)
        self.save_button.setGeometry(130, 240, 100, 30)
        self.save_button.clicked.connect(self.save_translation)

        self.translation_label = QLabel("Перевод:", self)
        self.translation_label.setGeometry(20, 280, 100, 30)

        self.translation_output = QTextEdit(self)
        self.translation_output.setGeometry(130, 280, 400, 120)

        self.api_key = ""  # Вставьте свой API-ключ Яндекс.Переводчика

        self.get_supported_languages()

    def get_supported_languages(self):
        try:
            url = "https://translate.yandex.net/api/v1.5/tr.json/getLangs"
            params = {
                "key": self.api_key,
                "ui": "en"
            }
            response = requests.get(url, params=params)
            data = response.json()

            if data["code"] == 200:
                languages = data["langs"]
                self.source_lang_combo.addItems(languages.keys())
                self.target_lang_combo.addItems(languages.keys())
            else:
                QMessageBox.warning(self, "Ошибка", "Не удалось получить поддерживаемые языки.")

        except requests.RequestException:
            QMessageBox.warning(self, "Ошибка", "Ошибка сети. Проверьте подключение к интернету.")

    def translate_text(self):
        text = self.text_input.toPlainText()
        source_lang = self.source_lang_combo.currentText()
        target_lang = self.target_lang_combo.currentText()

        try:
            url = "https://translate.yandex.net/api/v1.5/tr.json/translate"
            params = {
                "key": self.api_key,
                "text": text,
                "lang": f"{source_lang}-{target_lang}"
            }
            response = requests.get(url, params=params)
            data = response.json()

            if data["code"] == 200:
                translation = data["text"][0]
                self.translation_output.setPlainText(translation)
            else:
                QMessageBox.warning(self, "Ошибка", "Не удалось выполнить перевод.")

        except requests.RequestException:
            QMessageBox.warning(self, "Ошибка", "Ошибка сети. Проверьте подключение к интернету.")

    def save_translation(self):
        translation = self.translation_output.toPlainText()
        if not translation:
            QMessageBox.warning(self, "Ошибка", "Нет доступного перевода для сохранения.")
            return

        save_path, _ = QFileDialog.getSaveFileName(self, "Сохранить перевод", "", "Text files (*.txt)")
        if not save_path:
            return

        try:
            with open(save_path, "w", encoding="utf-8") as file:
                file.write(translation)
            QMessageBox.information(self, "Успех", "Перевод успешно сохранен.")

        except IOError:
            QMessageBox.warning(self, "Ошибка", "Не удалось сохранить перевод.")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = TranslationApp()
    window.show()
    sys.exit(app.exec_())


    
  

    
#Разработка парсера новостного сайта
import requests
from bs4 import BeautifulSoup
import tkinter as tk
from tkinter.scrolledtext import ScrolledText
import openpyxl
from openpyxl.utils import get_column_letter
from openpyxl.styles import Font, Alignment
from openpyxl.styles.colors import BLUE


def get_news(url, num=10):
    # Получаем HTML-код страницы
    response = requests.get(url)
    html_doc = response.text
    soup = BeautifulSoup(html_doc, "html.parser")

    # Ищем заголовки, ссылки, даты и времена новостей и выводим указанное количество
    news = []
    for news_elem in soup.find_all('div', class_='arch-block')[:num]:
        # Находим заголовок новости
        title_elem = news_elem.find('h2', class_='arch-title')
        title = title_elem.text.strip()

        # Находим дату и время новости
        datetime_elem = news_elem.find('div', class_='date')
        datetime = datetime_elem.text.strip()

        # Находим ссылку на новость
        link_elem = news_elem.find('a', href=True)
        link = link_elem['href']

        # Добавляем новость в список
        news.append({'title': title, 'datetime': datetime, 'link': link})

    return news


def on_button_click():
    # Получаем адрес новостного сайта из поля ввода
    url = entry.get()

    # Получаем количество новостей
    try:
        num = int(input_entry.get())
    except ValueError:
        tk.messagebox.showerror("Ошибка", "Введите число от 1 до 10")
        return

    if num < 1 or num > 10:
        tk.messagebox.showerror("Ошибка", "Введите число от 1 до 10")
        return

    # Получаем список заголовков новостей
    news = get_news(url, num=num)

    # Выводим список заголовков в текстовом поле
    news_text.delete('1.0', tk.END)
    for i, item in enumerate(news):
        try:
            news_text.insert(tk.END, f'{i+1}. {item["datetime"]} - {item["title"]} ({item["link"]})\n\n')
        except IndexError:
            break

    # Записываем результаты в файл
    wb = openpyxl.Workbook()
    ws = wb.active
    ws.title = 'Новости'

    for col_num, column_title in enumerate(['Заголовок', 'Дата и время', 'Ссылка'], start=1):
        column_letter = get_column_letter(col_num)
        ws.column_dimensions[column_letter].width = 20
        cell = ws.cell(row=1, column=col_num)
        cell.value = column_title
        cell.font = Font(bold=True)
        cell.alignment = Alignment(horizontal='center', vertical='center')

    for row_num, news_elem in enumerate(news, start=2):
        ws.cell(row=row_num, column=1).value = news_elem['title']
        ws.cell(row=row_num, column=2).value = news_elem['datetime']
        cell = ws.cell(row=row_num, column=3)
        cell.value = news_elem['link']
        cell.font = Font(color=BLUE, underline='single')
        cell.alignment = Alignment(horizontal='left', vertical='center')

        cell.hyperlink = news_elem['link']

    wb.save('rtvi.xlsx')


# Создаем графический
root = tk.Tk()
root.geometry('640x480')
root.title("Новости RTVI")

#Создаем виджет для ввода адреса сайта
url_label = tk.Label(root, text="Адрес сайта:")
url_label.grid(row=0, column=0, padx=5, pady=5, sticky='w')
entry = tk.Entry(root)
entry.grid(row=0, column=1, padx=5, pady=5, sticky='we')
entry.insert(0, "https://rtvi.com/news/")

#Создаем виджет для ввода количества новостей
input_label = tk.Label(root, text="Количество новостей (от 1 до 10):")
input_label.grid(row=1, column=0, padx=5, pady=5, sticky='w')
input_entry = tk.Entry(root)
input_entry.grid(row=1, column=1, padx=5, pady=5, sticky='we')

#Создаем кнопку для запуска парсинга новостей
button = tk.Button(root, text="Получить новости", command=on_button_click)
button.grid(row=2, column=0, columnspan=2, padx=5, pady=5)

#Создаем текстовое поле для вывода заголовков новостей
news_label = tk.Label(root, text="Заголовки новостей:")
news_label.grid(row=3, column=0, padx=5, pady=5, sticky='w')
news_text = ScrolledText(root, width=75, height=20)
news_text.grid(row=4, column=0, columnspan=2, padx=5, pady=5, sticky='we')

root.mainloop()
    
  

    
#Приложение для преобразования аудиозаписи речи в текст
import tkinter as tk
from tkinter import filedialog
import speech_recognition as sr

# Создаем объект распознавания речи
r = sr.Recognizer()

# Создаем главное окно приложения
root = tk.Tk()
root.title("Speech to Text")
root.geometry("640x480")

# Функция для выбора аудиофайла
def choose_file():
    file_path = filedialog.askopenfilename()
    file_path_entry.delete(0, tk.END)
    file_path_entry.insert(0, file_path)

# Функция для распознавания речи
def recognize_speech():
    # Получаем путь к выбранному файлу
    file_path = file_path_entry.get()

    # Определяем язык речи
    language = language_var.get()

    # Открываем аудиофайл
    with sr.AudioFile(file_path) as source:
        # Считываем аудиоданные из файла
        audio_data = r.record(source)

        # Распознаем речь
        try:
            if language == "Russian":
                text = r.recognize_google(audio_data, language="ru-RU")
            else:
                text = r.recognize_google(audio_data)
            result_text.delete("1.0", tk.END)
            result_text.insert(tk.END, text)
            with open("result.txt", "w") as f:
                f.write(text)
        except sr.UnknownValueError:
            result_text.delete("1.0", tk.END)
            result_text.insert(tk.END, "Speech recognition could not understand audio")
        except sr.RequestError as e:
            result_text.delete("1.0", tk.END)
            result_text.insert(tk.END, "Could not request results from Google Speech Recognition service; {0}".format(e))

# Создаем элементы пользовательского интерфейса
file_path_label = tk.Label(root, text="Audio file path:")
file_path_entry = tk.Entry(root, width=50)
choose_file_button = tk.Button(root, text="Choose file", command=choose_file)
language_label = tk.Label(root, text="Language:")
language_var = tk.StringVar(value="English")
language_rus_radio = tk.Radiobutton(root, text="Russian", variable=language_var, value="Russian")
language_eng_radio = tk.Radiobutton(root, text="English", variable=language_var, value="English")
recognize_button = tk.Button(root, text="Recognize speech", command=recognize_speech)
result_label = tk.Label(root, text="Result:")
result_text = tk.Text(root, height=10)

# Размещаем элементы на главном окне
file_path_label.pack()
file_path_entry.pack()
choose_file_button.pack()
language_label.pack()
language_rus_radio.pack()
language_eng_radio.pack()
recognize_button.pack()
result_label.pack()
result_text.pack()

# Запускаем главный цикл приложения
root.mainloop()