import openai
from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip
import os

# 🔹 Вставьте свой API-ключ OpenAI
openai.api_key = "YOUR_OPENAI_API_KEY"

# 🔹 Настройки
text_script = "Этот ролик был создан автоматически с помощью искусственного интеллекта."
image_folder = "images"  # Папка с картинками
audio_output = "voice.mp3"
video_output = "output.mp4"

# 🔹 Функция генерации озвучки
def generate_openai_tts(text, output_audio):
    response = openai.audio.speech.create(
        model="tts-1",
        voice="alloy",
        input=text
    )
    response.stream_to_file(output_audio)
    return output_audio

# 🔹 Функция создания видео
def create_video(image_folder, text_script, output_video):
    images = [os.path.join(image_folder, img) for img in sorted(os.listdir(image_folder)) if img.endswith(('.png', '.jpg'))]
    if not images:
        print("❌ Нет изображений в папке!")
        return

    audio_path = generate_openai_tts(text_script, audio_output)
    clips = [ImageClip(img).set_duration(3) for img in images]
    video = concatenate_videoclips(clips, method="compose").set_audio(AudioFileClip(audio_path))
    video.write_videofile(output_video, fps=24, codec="libx264")
    print("✅ Видео готово:", output_video)

# 🔹 Запуск
if __name__ == "__main__":
    create_video(image_folder, text_script, video_output)

import openai
import requests

# 🔹 Вставьте ваш OpenAI API-ключ
openai.api_key = "YOUR_OPENAI_API_KEY"

# 🔹 Описание изображения
prompt = "Футуристический город с летающими автомобилями, закатное небо"

# 🔹 Файл для сохранения изображения
output_image = "generated_image.png"

# 🔹 Функция генерации изображения с DALL·E
def generate_image(prompt, output_file):
    response = openai.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1024x1024"
    )
    
    image_url = response.data[0].url  # Получаем URL изображения
    image_data = requests.get(image_url).content  # Загружаем изображение
    
    with open(output_file, "wb") as file:
        file.write(image_data)  # Сохраняем на диск
    
    print("✅ Изображение сохранено как", output_file)

# 🔹 Запуск генерации
generate_image(prompt, output_image)

import psutil
import time
from rich.console import Console
from rich.table import Table

console = Console()

def monitor_system():
    while True:
        table = Table(title="📊 Мониторинг системы")

        table.add_column("Параметр", justify="left", style="cyan", no_wrap=True)
        table.add_column("Значение", justify="right", style="magenta")

        # CPU
        cpu_usage = psutil.cpu_percent(interval=1)
        table.add_row("🔹 Загрузка CPU", f"{cpu_usage}%")

        # RAM
        memory = psutil.virtual_memory()
        table.add_row("🔹 Использование RAM", f"{memory.percent}% ({memory.used // (1024 ** 2)}MB / {memory.total // (1024 ** 2)}MB)")

        console.clear()
        console.print(table)

        time.sleep(1)  # Обновление каждую секунду

if __name__ == "__main__":
    monitor_system()

import http.server
import socketserver
import os

# 🔹 Параметры сервера
PORT = 8080
DIRECTORY = "files"  # Папка, содержимое которой будет доступно

# 🔹 Создаём папку, если её нет
if not os.path.exists(DIRECTORY):
    os.makedirs(DIRECTORY)

class CustomHandler(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=DIRECTORY, **kwargs)

# 🔹 Запуск HTTP-сервера
with socketserver.TCPServer(("", PORT), CustomHandler) as httpd:
    print(f"✅ Файловый сервер запущен: http://localhost:{PORT}")
    print(f"📂 Папка: {DIRECTORY}")
    httpd.serve_forever()

import ccxt
import pandas as pd
import talib

# Параметры
EXCHANGE_NAME = "binance"
PAIR = "BTC/USDT"
TIMEFRAME = "1h"
SMA_PERIOD = 20  # Период скользящей средней
BB_STD_DEV = 2  # Отклонение Боллинджера

# Инициализация биржи
exchange = getattr(ccxt, EXCHANGE_NAME)()
exchange.load_markets()

# Получаем данные
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=TIMEFRAME, limit=SMA_PERIOD + 5)
    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
    return df

# Рассчет SMA и Bollinger Bands
def calculate_indicators(df):
    sma = talib.SMA(df["close"], timeperiod=SMA_PERIOD).iloc[-1]
    upper, middle, lower = talib.BBANDS(df["close"], timeperiod=SMA_PERIOD, nbdevup=BB_STD_DEV, nbdevdn=BB_STD_DEV)
    return sma, upper.iloc[-1], lower.iloc[-1], df["close"].iloc[-1]

# Логика торговли
def mean_reversion_bot():
    df = fetch_ohlcv(PAIR)
    sma, upper, lower, close = calculate_indicators(df)

    print(f"Цена: {close:.2f}, SMA: {sma:.2f}, BB Upper: {upper:.2f}, BB Lower: {lower:.2f}")

    if close > upper:
        print("📉 Цена выше верхней границы → возможен шорт.")
    elif close < lower:
        print("📈 Цена ниже нижней границы → возможен лонг.")
    else:
        print("⚡ Цена в нормальном диапазоне.")

# Запуск
if __name__ == "__main__":
    mean_reversion_bot()

import os
import zipfile
import datetime

# 🔹 Настройки
SOURCE_FOLDER = "my_folder"  # Папка, которую нужно заархивировать
BACKUP_FOLDER = "backup"  # Куда сохранять архивы

# 🔹 Создаём папку для бэкапов, если её нет
if not os.path.exists(BACKUP_FOLDER):
    os.makedirs(BACKUP_FOLDER)

# 🔹 Формируем имя архива с текущей датой
timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
backup_filename = os.path.join(BACKUP_FOLDER, f"backup_{timestamp}.zip")

# 🔹 Создание ZIP-архива
with zipfile.ZipFile(backup_filename, "w", zipfile.ZIP_DEFLATED) as zipf:
    for root, _, files in os.walk(SOURCE_FOLDER):
        for file in files:
            file_path = os.path.join(root, file)
            arcname = os.path.relpath(file_path, SOURCE_FOLDER)  # Убираем полный путь
            zipf.write(file_path, arcname)

print(f"✅ Резервная копия создана: {backup_filename}")

import os
import queue
import sounddevice as sd
import vosk
import json

# 🔹 Укажите путь к модели Vosk
MODEL_PATH = "vosk-model-small-ru-0.22"  # Для русского языка

# 🔹 Настройки аудиозахвата
SAMPLE_RATE = 16000  # Частота дискретизации
DEVICE = None  # Использовать стандартное аудиоустройство

# 🔹 Очередь для обработки аудио
q = queue.Queue()

# 🔹 Функция обработки аудиопотока
def callback(indata, frames, time, status):
    if status:
        print(status, flush=True)
    q.put(bytes(indata))

# 🔹 Загрузка модели Vosk
if not os.path.exists(MODEL_PATH):
    print("❌ Модель не найдена! Скачайте и распакуйте её.")
    exit(1)

model = vosk.Model(MODEL_PATH)
recognizer = vosk.KaldiRecognizer(model, SAMPLE_RATE)

# 🔹 Запуск захвата аудио и распознавания
print("🎤 Говорите...")

with sd.RawInputStream(samplerate=SAMPLE_RATE, blocksize=8000, device=DEVICE, dtype="int16",
                       channels=1, callback=callback):
    while True:
        data = q.get()
        if recognizer.AcceptWaveform(data):
            result = json.loads(recognizer.Result())
            text = result.get("text", "").strip()
            if text:
                print(f"📝 Распознанный текст: {text}")