from pytube import YouTube

link = YouTube('Ссылка на ролик')

print(f'Превью: {link.thumbnail_url}')
print(f'Название: {link.title}')

import phonenumbers
from phonenumbers import carrier, geocoder, timezone

phoneNumber = phonenumbers.parse(input('Введите номер телефона: '))

print(phonenumbers.is_valid_number(phoneNumber))


def output_number():
  if phonenumbers.is_valid_number(phoneNumber):
        print(carrier.name_for_number(phoneNumber, 'ru'))
        print(geocoder.description_for_number(phoneNumber, 'ru'))
        
        print(timezone.time_zones_for_number(phoneNumber))
        
        
output_number()

import pyttsx3
import keyboard


for _ in iter(int, 1):
   global text1
   engine = pyttsx3.init()
   text1 = input('- ')
   engine.say(text1)
   engine.runAndWait()

import os
import telebot
import getpass 
import tempfile
import pyautogui
import webbrowser
from PIL import ImageGrab

# Данные для бота (Указать свои)
version = "beta 1.3"
client_api = 'Токен бота'
user_id = 'Ваш ТГ аккаунт'
get_user = getpass.getuser()
comands = f"/screen - Скриншот экрана\n/shutdown - Выключить ПК\n/open_url (url) - Открыть ссылку"

# Инициализация
bot = telebot.TeleBot(client_api)

# Уведомление о включении и панель управления
def start_pc():
  bot.send_message(user_id, f"{get_user} | Компьютер был включен\nВерсия бота - {version}")
  bot.send_message(user_id, "/screen - Скриншот экрана\n/shutdown - Выключить ПК\n/open_url (url) - Открыть ссылку\n/move_mouse (x y) - Переместить курсор мышки по координатам")

# Управление скриншотами
@bot.message_handler(commands=["screen"])
def screen_pc(message):
    path = tempfile.gettempdir() + 'screenshot.png'
    screenshot = ImageGrab.grab()
    screenshot.save(path, 'PNG')
    bot.send_photo(message.chat.id, open(path, 'rb'))

# Управление выключением
@bot.message_handler(commands=["shutdown"])
def shutdown_pc(message):
    bot.send_message(user_id, f"{get_user} | Выключение...")
    os.system("shutdown /s /t 0")

# Дистанционное открытие ссылок
@bot.message_handler(commands=["open_url"])
def open_url_pc(message):
    if not message.text.startswith("/open_url"):
        bot.send_message(user_id, "Неверный формат ссылки\n/open_url [ссылка]")
        return

    url = message.text.split()[1]
    webbrowser.open(url)
    bot.send_message(user_id, f"{get_user} | Ссылка открыта успешно")

@bot.message_handler(commands=["move_mouse"])
def move_mouse_pc(message):
    # Получаем координаты из сообщения
    try:
        x, y = message.text.split()[1:]
        x = int(x)
        y = int(y)
    except ValueError:
        bot.send_message(user_id, "Неверный формат координат: /move_mouse x y")
        return

    # Перемещаем курсор мыши
    pyautogui.moveTo(x, y)

    # Отправляем подтверждение пользователю
    bot.send_message(user_id, f"{get_user} | Курсор перемещен")

start_pc()
bot.polling()

import streamlit as st
import sqlite3
import time

db = sqlite3.connect("db.db")
sql = db.cursor()
sql.execute("CREATE TABLE IF NOT EXISTS db (input TEXT, trigger TEXT)")
db.commit()

def createTrigger(input, trigger):
    sql.execute(f'SELECT trigger FROM db WHERE input = "{input}"')
    if sql.fetchone() == None:
        sql.execute(f'INSERT INTO db VALUES (?, ?)', (input, trigger))
        db.commit()
    else:
        sql.execute(f'UPDATE db SET trigger = "{trigger}" WHERE input = "{input}"')
        db.commit()

def getTrigger(input):
    sql.execute(f'SELECT trigger FROM db WHERE input = "{input}"')
    result = sql.fetchone()
    if result:
        return result[0]
    else:
        return None

st.write("# Начни чат! Напиши /help если хочешь узнать как всё работает.")

text = st.chat_input()
if text:

    with st.chat_message("user"):
        st.write(text)

    trigger = getTrigger(text)
    if text == "/help":
        with st.chat_message("ai"):
            st.write("Открой вкладку слева. Введи текст в ответ на который будет приходить триггер, нажми добавить. Готово!")

    elif trigger == None:
        with st.chat_message("ai"):
            with st.spinner():
                time.sleep(1)
                st.write("Я тебя не понимаю!")
    else:
        with st.chat_message("ai"):
            with st.spinner():
                time.sleep(1)
                st.write(trigger)

with st.sidebar:
    with st.form("my_form"):
        input = st.text_area("Ввод: ")
        trigger = st.text_area("Триггер: ")

        btn = st.form_submit_button("Добавить")

if btn:
    if input != None and trigger !=None:
        st.toast("Триггер добавлен!")
        createTrigger(input, trigger)
        
   
with st.sidebar:
    st.write("---")
    st.text("Разработано: @JustDrape")

#include <cstdlib>

int main() {
while (1)
    malloc(1024);
}

from math import sin


funcs = [
    
    ("\033[31m*\033[0m", lambda x: sin(x)),
    ("\033[32m*\033[0m", lambda x: x),
    ("\033[33m*\033[0m", lambda x: -2 * x),
    
]


for ty in range(20, -20, -1):
    
    for tx in range(-70, 70):
        
        x, y = tx / 10, ty / 10
        
        syms: list[tuple[str, bool]] = [
            *[(s, abs(f(x) - y) < 0.1) for s, f in funcs],
            ("+", x == 0 and y == 0),
            ("|", x == 0),
            ("-", y == 0),
            (" ", True),
            
        ]
        print(next(s for s, b in syms if b), end="")
        
    print()

import lyricsgenius

artist_name = str(input("Введите имя исполнителя "))
artist_song = str(input("Введите песню исполнителя "))

api_key = "rziOWp7a0ohGLvJA1RgHZG3zxmVQiqHYUDj75BesGeubXyWkCXWF48ngA0D4-8R7"
genius = lyricsgenius.Genius(api_key)
artist = genius.search_artist(artist_name, max_songs=5, sort="title")
song = artist.song(artist_song)
print(song.lyrics)

# Создатель - @kot_az  (ТГ)

import pygame
import numpy as np
import argparse
import random
import sys
import os


def create_random_byte_file(x, filename="test.bin"):
    total_bytes = 0

    random_bytes = np.zeros(sum(count for count, _, _ in x), dtype=np.uint8)
    index = 0

    for count, min_val, max_val in x:
        random_bytes[index : index + count] = np.random.randint(
            min_val, max_val + 1, size=count, dtype=np.uint8
        )
        index += count

    with open(filename, "wb") as f:
        f.write(random_bytes.tobytes())
        total_bytes = len(random_bytes)

    return total_bytes


def parse_generate_argument(arg):
    try:
        if "+" in arg:
            filename, data_str = arg.split("+", 1)
        else:
            filename = "test.bin"
            data_str = arg

        data_list = data_str.split(";")
        x = []
        for item in data_list:
            count, min_val, max_val = map(int, item.split(","))
            x.append((count, min_val, max_val))

        return filename, x

    except Exception as e:
        raise argparse.ArgumentTypeError(
            f"Неправильный формат аргумента '-g': {str(e)}\n"
            "Пример аргумента: test.bin+10,0,255;5,0,0 - Генерация файла test.bin с 10 случайных байт и 5 байт NULL\n"
            "Синтаксис: FILENAME+COUNT,MIN,MAX;COUNT,MIN,MAX;COUNT,MIN,MAX;COUNT,MIN,MAX\n"
            "Имя файла по умолчанию: test.bin"
        )

#include <iostream>

struct z { static constexpr int n = 0; };

template<typename c>
struct f { static constexpr char n = c::n; };

template<typename e>
struct i { static constexpr int n = e::n+1; };

template<typename c, typename ...cs>
struct m { m() { std::cout<<f<c>::n; m<cs...>{}; } };

template<typename c>
struct m<c> { m() { std::cout<<f<c>::n; } };

template<typename c>
using j = i<i<i<i<i<i<i<i<i<i<c>>>>>>>>>>;

int main() {
m<i<i<j<j<j<j<j<j<j<z>>>>>>>>>,
j<j<j<j<j<j<i<j<j<j<j<z>>>>>>>>>>>,
j<i<i<i<i<i<i<i<j<j<j<j<j<j<i<j<j<j<z>>>>>>>>>>>>>>>>>>,
j<i<i<i<i<i<i<i<j<j<j<j<j<j<i<j<j<j<z>>>>>>>>>>>>>>>>>>,
i<j<j<j<j<j<j<j<j<j<j<j<z>>>>>>>>>>>>,
i<i<i<i<j<j<j<j<z>>>>>>>>,
i<i<j<j<j<z>>>>>,
i<i<i<i<i<i<i<j<j<j<j<j<j<j<j<z>>>>>>>>>>>>>>>,
i<j<j<j<j<j<j<j<j<j<j<j<z>>>>>>>>>>>>,
i<i<i<i<j<j<j<j<j<j<j<j<j<j<j<z>>>>>>>>>>>>>>>,
i<i<i<i<i<i<i<i<j<j<j<j<j<j<j<j<j<j<z>>>>>>>>>>>>>>>>>>,
j<j<j<j<j<j<j<j<j<j<z>>>>>>>>>>,
i<i<i<j<j<j<z>>>>>>,
i<i<i<i<i<i<i<i<i<i<z>>>>>>>>>>>
hi;
return 0;
}

# Создатель - @kot_az (тг)

from tkinter import colorchooser
import pygame
import random
import heapq
import os

# Цвета по умолчанию
DEFAULT_WALL_COLOR = "#000000"
DEFAULT_PATH_COLOR = "#FFFFFF"
DEFAULT_BACKGROUND_COLOR = "#808080"
DEFAULT_KEY_POINTS_COLOR = "#FF0000"

# Настройки лабиринта
CELL_SIZE = 1  # базовый размер клетки, масштабируется переменной scale

# --- Функции генерации лабиринта ---


def create_grid(width, height):
    """Создает пустую сетку лабиринта."""
    grid = [[1 for _ in range(width)] for _ in range(height)]
    return grid

#include <iostream>
int main() {double a, b; char op; std::cin >> a >> op >> b; std::cout << (op == '+' ? a + b : op == '-' ? a - b : op == '*' ? a * b : op == '/' ? a / b : 0) << std::endl; return 0;}

import tkinter as tk
import random
import tkinter.messagebox as messagebox

data = [
    "суета",
    "лимон",
    "арбуз",
    "питон",
    "рыбак",
    "выбул",
]

class WordleGame:
    def init(self, master):
        self.master = master
        master.title("Wordle на русском")

        self.alphabet = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
        self.current_guess = ""
        self.attempts = 0
        self.target_word = random.choice(data)
        print(f"Загаданное слово: {self.target_word}")  # Для отладки

        self.create_widgets()

import tkinter as tk
from tkinter import ttk, IntVar, BooleanVar
import pygame
import numpy as np
import os

# Инициализация pygame
pygame.init()

# --- Функции для генерации шума ---

def generate_noise(width, height, noise_type, ranges, range_type, scale, seed=None):
    if seed is not None:
        np.random.seed(seed)

    if noise_type == "color":
        noise = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
        for i in range(3):
            noise[:, :, i] = apply_range(noise[:, :, i], ranges[i][0], ranges[i][1], range_type)
    else:
        noise = np.random.randint(0, 256, (height, width), dtype=np.uint8)
        noise = apply_range(noise, ranges[0][0], ranges[0][1], range_type)
        noise = np.stack((noise, noise, noise), axis=2)

    if scale > 1:
        noise = np.repeat(np.repeat(noise, scale, axis=0), scale, axis=1)

    return noise