Андрей Прохоренко

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")

const calculatePadding = (labels) => {
    const labelCount = labels.length;
    const maxLabelLength = Math.max(...labels.map(label => label.length));
    
    return {
        left: 40,
        right: Math.max(100, labelCount * 20 + maxLabelLength * 3)
    };
};

<div className="pie-chart-grid-container">
    <div className="pie-chart-canvas">
        <Pie data={data} options={optionsWithoutLegend} />
    </div>
    <div className="custom-legend">
        {/* Кастомная легенда */}
    </div>
</div>

.pie-chart-wrapper {
    width: 100%;
    height: 100%;
    position: relative;
    display: flex;
    justify-content: center;
    align-items: center;
}

from tkinter import Canvas,Tk,Button,PhotoImage, Toplevel

root = Tk()
root.wm_attributes('-alpha', 0.5)
root.wm_attributes("-topmost", True)
root.overrideredirect(True) 
img = PhotoImage(file=r"pics\image_19x19.png")
canvas = Canvas(root, width=1920, height=1080, highlightthickness=0)
canvas.pack()

image_window = Toplevel(root)
image_window.overrideredirect(True) 
image_window.wm_attributes("-topmost", True) 

image_canvas = Canvas(image_window, width=img.width(), height=img.height(), highlightthickness=0)
image_canvas.pack()

image_window.withdraw()

def leftclick(event):
    x = event.x_root
    y = event.y_root

    image_canvas.delete("all")
    image_canvas.create_image(img.width() // 2, img.height() // 2, image=img)

    image_window.geometry(f"+{x}+{y}")
    image_window.deiconify()

root.bind('<Button-1>' , leftclick)
root.mainloop()

# main.py
import customtkinter as ctk
from right_menu import RightMenu
from bottom_menu import BottomMenu

def main():
    root = ctk.CTk()
    root.geometry("600x400")
    root.title("Demo передачи значения между меню")
    right = RightMenu(root)
    right.pack(side="right", fill="y")
    bottom = BottomMenu(root, right_menu=right)
    bottom.pack(side="bottom", fill="x")

    root.mainloop()

if __name__ == "__main__":
    main()

# right_menu.py
import customtkinter as ctk
class RightMenu(ctk.CTkFrame):
    def __init__(self, master, **kwargs):
        super().__init__(master, **kwargs)
        self.right_menu = ctk.CTkFrame(self,
                                       width=200,
                                       corner_radius=0,
                                       border_color="#242323",
                                       border_width=1)
        self.right_menu.pack(side="right", fill="y")
        self.checkbox = ctk.CTkCheckBox(
            self.right_menu,
            text="Contrast",
            width=100,
            height=25,
            command=self.toggle_slider
        )
        self.checkbox.pack(padx=10, pady=10, anchor="w")

    def toggle_slider(self):
        print("Checkbox toggled, now:", self.checkbox.get())

    def get_effects(self):
        """
        Возвращает текущее состояние чекбокса:
        1 — включён; 0 — выключен.
        """
        return self.checkbox.get()

# bottom_menu.py
import customtkinter as ctk
class BottomMenu(ctk.CTkFrame):
    def __init__(self, master, right_menu, **kwargs):
        super().__init__(master, corner_radius=0, height=100,
                         border_color="#242323", border_width=1, **kwargs)
        self.right_menu = right_menu
        apply_btn = ctk.CTkButton(
            self,
            text="Применить",
            command=self.on_apply_changes_click
        )
        apply_btn.pack(padx=10, pady=10, anchor="e")

    def on_apply_changes_click(self):
        checkbox_value = self.right_menu.get_effects()
        print(f"Текущее состояние чекбокса Contrast: {checkbox_value}")

if current_rad >= 190:
            radius_mult = 2.0
        else:
            radius_mult = 1.0

const test = this.ArrBookingHours.filter((hour) => hour.date === day.toDateString())
console.log(test)
console.log(test[0].hours)

const booking = this.ArrBookingHours.find(
  hour => hour.date === day.toDateString()
)

console.log(booking?.hours ?? 'Нет записи на эту дату')

#include <audiere.h>
#include <vector>
#include <string>
#include <algorithm>

#ifdef _WIN32
#include <objbase.h>
#endif

int main() {
#ifdef _WIN32
  CoInitialize(nullptr);
#endif
  std::vector<audiere::AudioDeviceDesc> devices;
  devices.reserve(8); 
  audiere::GetSupportedAudioDevices(devices); 
  auto it = std::find_if(
    devices.begin(), devices.end(),
    [](auto const& desc){ return desc.name == "MyDesiredDeviceName"; }
  );
  audiere::AudioDevicePtr device(
    audiere::OpenDevice(
      it != devices.end() ? it->name.c_str() : nullptr,
      /* parameters = */ nullptr
    )
  );

  if (!device) {
    // Реализуй свою уже логику обработки ошибок...
    return -1;
  }
  auto sound = audiere::OpenSound(device, "music.ogg", true);
  sound->play();

  // ... Далее уже реализуй свою логику программы ...

  return 0;
}

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('Ошибка: ключ должен быть числом.')

def tick(self):
    x1, y1, x2, y2 = self.coords(self.box)
    if y2 < self.line_y:  # 
        self.move(self.box, self.dx, self.dy)
    else:
        self.dx = 0
        self.dy = 0
    self.after(self.dt, self.tick)

import ipaddress
import random
import time
import subprocess
import platform
import keyboard  # pip install keyboard
import re


class IPAddressManager:
    """Класс для управления и скрытия IP-адресов в локальной сети."""

    def __init__(self, interface: str):
        self.interface = interface
        self.original_ip = self._get_current_ip()
        self.hidden_ip = None

    def _get_current_ip(self) -> str:
        """Получить текущий IP-адрес интерфейса."""
        try:
            if platform.system() == "Windows":
                output = subprocess.check_output(
                    "ipconfig", shell=True, stderr=subprocess.DEVNULL, universal_newlines=True)
                pattern = re.compile(
                    rf"{self.interface}.*?IPv4.*?:\s*(\d+\.\d+\.\d+\.\d+)", re.DOTALL)
                match = pattern.search(output)
                if match:
                    return match.group(1)
                raise ValueError(
                    f"IP-адрес для интерфейса {self.interface} не найден")
            else:  # Linux и macOS
                output = subprocess.check_output(
                    f"ifconfig {self.interface}", shell=True, universal_newlines=True)
                match = re.search(r"inet (\d+\.\d+\.\d+\.\d+)", output)
                if match:
                    return match.group(1)
                raise ValueError(
                    f"IP-адрес для интерфейса {self.interface} не найден")
        except subprocess.CalledProcessError as e:
            raise RuntimeError(f"Ошибка при выполнении команды: {e}")

    def hide_ip(self) -> None:
        """Скрыть IP-адрес, изменив его на случайный в той же подсети."""
        current_ip = ipaddress.ip_address(self.original_ip)
        network = ipaddress.ip_network(f"{current_ip}/24", strict=False)

        while True:
            new_ip = ipaddress.ip_address(random.randint(
                int(network.network_address) + 1, int(network.broadcast_address) - 1))
            if new_ip != current_ip:
                self.hidden_ip = str(new_ip)
                break

        self._change_ip(self.hidden_ip)

    def restore_ip(self) -> None:
        """Восстановить оригинальный IP-адрес."""
        if self.hidden_ip:
            self._change_ip(self.original_ip)
            self.hidden_ip = None

    def _change_ip(self, new_ip: str) -> None:
        """Изменить IP-адрес интерфейса."""
        try:
            if platform.system() == "Windows":
                subprocess.run(f'netsh interface ip set address name="{self.interface}" static {new_ip} 255.255.255.0',
                               shell=True, check=True, stderr=subprocess.DEVNULL)
            else:  # Linux и macOS
                subprocess.run(f"sudo ifconfig {self.interface} {new_ip} netmask 255.255.255.0",
                               shell=True, check=True, stderr=subprocess.DEVNULL)
        except subprocess.CalledProcessError as e:
            raise RuntimeError(
                f"Не удалось изменить IP-адрес на {new_ip}. Ошибка: {e}")

    def restore_dhcp(self) -> None:
        """Восстановить автоматическое получение IP-адреса (DHCP)."""
        try:
            if platform.system() == "Windows":
                subprocess.run(
                    f'netsh interface ip set address name="{
                        self.interface}" source=dhcp',
                    shell=True, check=True, stderr=subprocess.DEVNULL
                )
                print(f"Интерфейс {
                      self.interface} успешно переведен в режим DHCP")
            else:  # Linux и macOS
                subprocess.run(
                    f"sudo dhclient -r {self.interface} && sudo dhclient {self.interface}",
                    shell=True, check=True, stderr=subprocess.DEVNULL
                )
                print(f"Интерфейс {
                      self.interface} успешно переведен в режим DHCP")
        except subprocess.CalledProcessError as e:
            print(f"Ошибка при восстановлении DHCP: {e}")

    def run(self) -> None:
        """Запустить процесс скрытия IP-адреса."""
        print(f"Начальный IP-адрес: {self.original_ip}")
        self.hide_ip()
        print(f"IP-адрес скрыт. Новый адрес: {self.hidden_ip}")
        print("Нажмите 'q' для выхода и восстановления автоматического получения IP.")

        while True:
            if keyboard.is_pressed('q'):
                break
            time.sleep(0.1)

        self.restore_dhcp()
        print("Программа завершена. DHCP восстановлен.")


if __name__ == "__main__":
    try:
        interface = "Ethernet"  # Тут замени на имя твоего сетевого интерфейса - так как я делал это все на своем компе
        manager = IPAddressManager(interface)
        manager.run()
    except Exception as e:
        print(f"Произошла ошибка: {e}")

import customtkinter as ctk

ctk.set_appearance_mode("dark")


class App(ctk.CTk):
    def __init__(self):
        super().__init__()

        self.title("Delta Search")
        self.geometry("1050x630")

        self.button_frame_1 = ctk.CTkFrame(self,
                                           fg_color='#333333',
                                           border_width=2,
                                           corner_radius=10,
                                           border_color='#f53333',
                                           width=915,
                                           height=50,
                                           )
        self.button_frame_1.grid(row=0, column=0, padx=50, pady=10)

        # тут и меняется тебе сам объект  для шрифта
        custom_font = ctk.CTkFont(family="Arial", size=20, weight="bold")

        self.button = ctk.CTkButton(self.button_frame_1,
                                    fg_color='#454545',
                                    text='Universal search',
                                    width=150,
                                    height=40,
                                    border_color='#f53333',
                                    corner_radius=10,
                                    border_width=1,
                                    font=custom_font  # Применить тут шрифт
                                    )
        self.button.grid(row=0, column=0, padx=(20, 2), pady=10)


app = App()
app.mainloop()

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-packages