import os
import requests
from urllib.parse import urlparse
def versionDownload(url, folder, chunk_size=8192):
if not os.path.exists(folder):
os.makedirs(folder, exist_ok=True)
if "github.com" in url and "/releases/" in url and "/download/" not in url:
print("Обнаружена ссылка на страницу релиза. Попытка найти правильную ссылку...")
page_response = requests.get(url)
page_response.raise_for_status()
import re
download_links = re.findall(r'href="([^"]*\/download\/[^"]*)"', page_response.text)
if download_links:
url = "https://github.com" + download_links[0] if download_links[0].startswith('/') else download_links[0]
print(f"Найдена ссылка для скачивания: {url}")
else:
print("Не удалось найти файлы для скачивания на странице релиза")
return None
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
'Accept': 'application/octet-stream'
}
print(f"Начался процесс скачивания с URL: {url}")
with requests.get(url, headers=headers, stream=True, allow_redirects=True) as r:
r.raise_for_status()
content_type = r.headers.get('Content-Type', '')
if 'text/html' in content_type:
print("Ошибка: получен HTML вместо файла!")
print(f"Content-Type: {content_type}")
print("Проверьте правильность URL")
return None
filename = "engine.zip"
if 'Content-Disposition' in r.headers:
content_disp = r.headers['Content-Disposition']
if 'filename=' in content_disp:
filename = content_disp.split('filename=')[1].strip('"')
else:
parsed_url = urlparse(url)
if parsed_url.path:
filename = os.path.basename(parsed_url.path) or "engine.zip"
file_path = os.path.join(folder, filename)
total_size = int(r.headers.get('Content-Length', 0))
downloaded_size = 0
print(f"Скачивание {filename}...")
if total_size > 0:
print(f"Размер файла: {total_size / (1024*1024):.2f} MB")
with open(file_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=chunk_size):
if chunk:
f.write(chunk)
downloaded_size += len(chunk)
if total_size > 0:
progress = (downloaded_size / total_size) * 100
print(f"\rПрогресс: {progress:.1f}% ({downloaded_size / (1024*1024):.2f} MB)", end='', flush=True)
print(f"\nФайл успешно скачан: {file_path}")
return file_path
if __name__ == "__main__":
url = "https://github.com/artyom7774/Game-Engine-3/releases/download/GE3.12.0/Game-Engine-3-windows.sfx.exe"
versionDownload(url, "./downloads")from __future__ import annotations
import logging
import os
import shelve
from datetime import datetime, timedelta
from pathlib import Path
from aiogram import Bot, Dispatcher, F
from aiogram.types import Message, CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.filters import Command
from aiogram.utils.keyboard import InlineKeyboardBuilder
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.client.default import DefaultBotProperties
# Configure logging
logging.basicConfig(level=logging.INFO)
# Constants
TRIAL_FLAG = "active"
class UltraLiteSubBot:
__slots__ = ("_bot", "_dp", "_prices", "_db", "_cmd_map", "_cb_map")
def __init__(self, token: str, prices: dict[str, int], db: shelve.DbfilenameShelf):
self._bot = Bot(token=token, default=DefaultBotProperties(parse_mode="HTML"))
self._dp = Dispatcher(storage=MemoryStorage())
self._prices = prices
self._db = db
self._cmd_map = {
"start": self._show,
"help": self._help
}
self._cb_map = {
**{plan: self._plan(plan) for plan in prices},
"activate": self._activate
}
self._register_handlers()
def _register_handlers(self) -> None:
self._dp.message.register(self._show, Command("start"))
self._dp.message.register(self._help, Command("help"))
self._dp.message.register(self._unknown)
for plan in self._prices:
self._dp.callback_query.register(self._plan(plan), F.data == plan)
self._dp.callback_query.register(self._activate, F.data == "activate")
self._dp.callback_query.register(self._unknown_callback)
async def run(self) -> None:
await self._bot.set_my_commands([
{"command": "start", "description": "Выбрать тариф"},
{"command": "help", "description": "Справка"}
])
await self._dp.start_polling(self._bot)
async def _show(self, msg: Message) -> None:
uid = msg.chat.id
builder = InlineKeyboardBuilder()
for plan, price in self._prices.items():
builder.button(text=f"{plan.title()} — {price}₽", callback_data=plan)
if await self._trial_ok(uid):
builder.button(text="Активировать пробный период", callback_data="activate")
builder.adjust(1)
await msg.answer("Выберите тариф:", reply_markup=builder.as_markup())
async def _help(self, msg: Message) -> None:
await msg.answer("/start — выбрать тариф\n/help — справка")
async def _unknown(self, msg: Message) -> None:
await msg.answer("Неизвестная команда. /help")
async def _unknown_callback(self, call: CallbackQuery) -> None:
await call.answer()
await call.message.answer("Неизвестная операция.")
def _plan(self, name: str):
async def _handler(call: CallbackQuery) -> None:
await call.answer()
await call.message.answer(f"Вы выбрали тариф «{name}».")
return _handler
async def _activate(self, call: CallbackQuery) -> None:
await call.answer()
uid = str(call.from_user.id)
try:
self._db[uid] = {
"started": datetime.utcnow(),
TRIAL_FLAG: True,
"questions": 0,
"symbols": 0,
}
self._db.sync()
except Exception as e:
await call.message.answer(f"⚠️ Ошибка БД: {e}")
return
await call.message.answer(
"✅ Пробный период активирован!\nДоступно: 10 вопросов / 10 000 символов"
)
try:
await call.message.edit_reply_markup(reply_markup=None)
except Exception:
pass
async def _trial_ok(self, uid: int) -> bool:
rec = self._db.get(str(uid), {})
return not rec.get(TRIAL_FLAG) or datetime.utcnow() - rec.get("started", datetime.min) >= timedelta(days=7)
async def main():
TOKEN = os.getenv("BOT_TOKEN", "вставь свой токен сюда")
PRICES = {"month": 199, "quarter": 549, "year": 1_490}
db = shelve.open(str(Path(__file__).with_name("trial.db")), writeback=True)
db.update({k: v | {TRIAL_FLAG: v.get(TRIAL_FLAG, False)} for k, v in db.items()})
bot = UltraLiteSubBot(TOKEN, PRICES, db)
await bot.run()
if __name__ == "__main__":
import asyncio
asyncio.run(main())import pandas as pd
df = pd.DataFrame({'Name': ['car1', 'car2', 'car3', 'car4'], 'Type': [20, 21, 19, 18], 'Repair': ["n", "n", "y", "n"]})
def add_bit_rows(df):
y_rows = df[df['Repair'] == 'y']
bit_rows = [
{
'Name': row['Name'],
'Type': row['Type'],
'Repair': f"y_bit{i}"
}
for _, row in y_rows.iterrows()
for i in range(16)
]
df_bits = pd.DataFrame(bit_rows)
return pd.concat([df, df_bits], ignore_index=True)
print(add_bit_rows(df))alphabet = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
caesar_cipher = lambda text, key: ''.join(
alphabet[(alphabet.find(letter) + key) % len(alphabet)] if letter in alphabet else letter
for letter in text
)
encrypt = input('Введите слово, которое хотите зашифровать: ')
try:
encrypted = caesar_cipher(encrypt, int(input('Введите ключ (от 1 до 32): ')))
print(f'Зашифрованное слово: {encrypted}')
except ValueError:
print('Ошибка: ключ должен быть числом.')Python 3.8.19 (default, Mar 20 2024, 11:17:09) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print('\n'.join(__import__('sys').path))
D:\Python38\python38.zip
D:\Python38\DLLs
D:\Python38\lib
D:\Python38
D:\Python38\lib\site-packagesfilter_chars = lambda pattern, text: __import__('re').findall(pattern, text)
pattern = r"[^а-яА-ЯёЁa-zA-Z]" # паттерн для поиска отсеянных символов - или какие символы ты хочешь отсеить
text = "Добро пожаловать в Python! 1234567890 @#$%^&*()_+=-" # текст для поиска
print("Отсеянные символы:", filter_chars(pattern, text))pattern = r"[@#$%^&*()_+=-]"print("Собрано все символы в строку:", ''.join(filter_chars(pattern, text)))