import subprocess
import time
import csv
from datetime import datetime

HOST = "8.8.8.8"
INTERVAL = 60  # секунда
LOG_FILE = "connectivity_log.csv"

def ping(host):
    # ping для Linux/macOS; под Windows может быть другой ключ
    result = subprocess.run(["ping", "-c", "1", host], capture_output=True)
    return result.returncode == 0, result

def log_status(timestamp, status, latency):
    with open(LOG_FILE, "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([timestamp, status, latency])

def extract_latency(output):
    # пробуем парсить строку ping-ответа
    out = output.decode('utf-8', errors='ignore')
    # строка вида: time=12.345 ms
    for part in out.split():
        if part.startswith("time="):
            try:
                return float(part.split("=")[1])
            except:
                pass
    return None

def main():
    # заголовок CSV, если файл новый
    try:
        with open(LOG_FILE, "x") as f:
            writer = csv.writer(f)
            writer.writerow(["timestamp", "status", "latency_ms"])
    except FileExistsError:
        pass

    while True:
        ts = datetime.now().isoformat()
        ok, res = ping(HOST)
        latency = None
        if ok:
            latency = extract_latency(res.stdout)
            status = "online"
        else:
            status = "outage"
        log_status(ts, status, latency)
        print(f"{ts} — {status} — {latency}")
        time.sleep(INTERVAL)

if name == "__main__":
    main()

🟢 Пингует указанный хост (по умолчанию 8.8.8.8) с интервалом
🟢 Определяет, отвечает ли хост (если нет — “outage”)
🟢 Если ответ — парсит задержку (ms)
🟢 Записывает лог в формате CSV: временная метка, статус, задержка
🟢 Выводит в консоль текущее состояние

🟢 Использует предобученные модели — не нужно самому тренить что-то тяжелое
🟢 Работает быстро: может обрабатывать отдельные изображения или батчами
🟢 Поддерживает разные форматы изображений (PNG, JPG и др.)
🟢 Может быть использована в скриптах, приложениях или на сервере
🟢 Легко интегрируется с PIL/Pillow или OpenCV

pip install rembg

import time
import subprocess

WHITELIST = ["Device1_ID", "Device2_ID"]
CHECK_INTERVAL = 1  # секунда

def list_usb_devices():
    # команда lsusb — показывает USB-устройства на Linux
    output = subprocess.check_output(["lsusb"]).decode()
    return output.splitlines()

def monitor():
    while True:
        devices = list_usb_devices()
        for d in devices:
            # простая проверка: если строка не содержит ни одного whitelist ID
            if all(w not in d for w in WHITELIST):
                # небелое устройство — активируем защиту
                print("Unknown USB device detected:", d)
                # Пример действия: выключить систему
                subprocess.call(["shutdown", "now", "-h"])
                return
        time.sleep(CHECK_INTERVAL)

if __name__ == "__main__":
    monitor()

🟢 Мониторит список USB-устройств
🟢 Сравнивает с белым списком
🟢 При обнаружении “чужого” устройства — выполняет “жёсткое” действие (shutdown, удаление, очистка)
🟢 Полезен как антифизическая защита при чувствительных данных

🟢 Поддержка операций над тензорами: умножения, срезы, перестановки, транспонирование и др.
🟢 Алгоритмы декомпозиции тензоров: CP, Tucker и др.
🟢 Методы для многоклассовой классификации и объединения данных на основе тензорных представлений — например, Support Tensor Machine и Tensor Ensemble Learning
🟢 API, упрощающий интеграцию с другими библиотеками научного стека (NumPy, SciPy и др.)
🟢 Встроенные инструменты визуализации тензоров и их разложения — помогает лучше понять структуру данных и результаты анализа
🟢 Сконцентрирована на масштабируемости и интерактивном использовании (например в Jupyter)

pip install hottbox

from PIL import Image
import os

def images_to_pdf(img_folder, output_pdf_path, paper_size=(595, 842)):
# paper_size в пунктах — примерно A4 (в зависимости от DPI)
imgs = []
for fname in sorted(os.listdir(img_folder)):
if fname.lower().endswith(('.png', '.jpg', '.jpeg')):
img_path = os.path.join(img_folder, fname)
img = Image.open(img_path).convert('RGB')
img = img.resize(paper_size) # подгонка под формат
imgs.append(img)
if not imgs:
print("Нет изображений для конвертации")
return
first, rest = imgs[0], imgs[1:]
first.save(output_pdf_path, save_all=True, append_images=rest)
print(f"Создан PDF: {output_pdf_path}")

if __name__ == "__main__":
images_to_pdf("input_images", "out.pdf")

🟢 Сканирует папку с изображениями (JPG, PNG и др.)
🟢 Подгоняет каждый кадр под заданный размер (например, формат страницы)
🟢 Объединяет все изображения в один PDF-файл
🟢 Сохраняет PDF с указанным именем

🟢 Работает с Python 3.8+ — совместимость гарантируется.
🟢 Зависимости: requests, beautifulsoup, numpy, scipy, pandas, lxml и др.
🟢 Лёгкий старт: установка одной командой, изучение функций быстрое благодаря хорошему списку API.

pip install nselib

import time
import os
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class RansomwareHandler(FileSystemEventHandler):
def __init__(self):
self.modified_files = set()
self.deleted_files = set()

def on_modified(self, event):
if not event.is_directory:
self.modified_files.add(event.src_path)
print("Modified:", event.src_path)

def on_deleted(self, event):
if not event.is_directory:
self.deleted_files.add(event.src_path)
print("Deleted:", event.src_path)

def monitor(path_to_watch, check_interval=10):
event_handler = RansomwareHandler()
observer = Observer()
observer.schedule(event_handler, path=path_to_watch, recursive=True)
observer.start()
try:
while True:
time.sleep(check_interval)
# Простая логика: если за интервал изменилось или удалилось слишком много файлов
if len(event_handler.modified_files) > 100 or len(event_handler.deleted_files) > 10:
print("Warning: Potential ransomware activity detected!")
# Можно логировать события
event_handler.modified_files.clear()
event_handler.deleted_files.clear()
except KeyboardInterrupt:
observer.stop()
observer.join()

if name == "__main__":
path = "/path/to/watch"
monitor(path, check_interval=10)

🟢 Мониторит указанную директорию на события изменения и удаления файлов
🟢 Логирует эти события в консоль и файл (например ransomware_detection.log)
🟢 Периодически проверяется, если много изменений/удалений — вывод предупреждения о потенциальной атаке

🟢 Можно создавать палитры с произвольным количеством цветов: glasbey.create_palette(palette_size=15) — и цвета будут стараться быть максимально отличимыми визуально.
🟢 Можно расширять существующие палитры, или “с нуля” задавать seed цвета, чтобы новая палитра дополняла прежнюю (чтобы цвета не пересекались сильно).
🟢 Поддержка ограничений: можно задавать границы яркости, хромности (chroma), чтобы цвета не были слишком яркими или слишком блеклыми.
🟢 Можно создавать “блочные” палитры — когда есть иерархии категорий, вложенные группы.
🟢 Легко использовать в связке с matplotlib / seaborn и др. визуализациями — просто генерируешь цвета и передаёшь библиотеке визуализации.

pip install glasbey

import os
import sys
from PIL import Image
from argparse import ArgumentParser

def process_images(input_dir, output_dir, max_width, max_height, quality=70, rename_template=None):
    os.makedirs(output_dir, exist_ok=True)
    count = 0
    for fname in os.listdir(input_dir):
        if fname.lower().endswith(('.jpg', '.jpeg', '.png')):
            path = os.path.join(input_dir, fname)
            img = Image.open(path)
            # изменение размера с сохранением пропорций
            img.thumbnail((max_width, max_height))
            base_name, ext = os.path.splitext(fname)
            if rename_template:
                out_name = rename_template.replace("{count}", str(count)) + ext
            else:
                out_name = fname
            out_path = os.path.join(output_dir, out_name)
            img.save(out_path, quality=quality)
            print(f"Saved: {out_path}")
            count += 1

def main():
    parser = ArgumentParser()
    parser.add_argument("input_dir")
    parser.add_argument("output_dir")
    parser.add_argument("--max_width", type=int, default=800)
    parser.add_argument("--max_height", type=int, default=600)
    parser.add_argument("--quality", type=int, default=70)
    parser.add_argument("--rename", help="template, e.g. img_{count}")
    args = parser.parse_args()
    process_images(args.input_dir, args.output_dir, args.max_width, args.max_height, args.quality, args.rename)

if name == "__main__":
    main()

🟢 Идёт по всем изображениям в папке с разрешениями .jpg, .jpeg, .png
🟢 Изменяет их размер до заданных максимальных ширины/высоты, сохраняя пропорции
🟢 Сжимает качество (для JPG например), чтобы уменьшить размер файлов
🟢 Опционально переименовывает файлы по шаблону с номером
🟢 Сохраняет всё в выходную папку, чтобы не перезаписывать оригиналы

🟢 Масштабируемость — работает с большими наборами данных, использует PyTorch и Pyro под капотом для ускорения вычислений.
🟢 Байесовский подход — поддерживает обучение с априорными распределениями и вывод параметров через стохастические методы.
🟢 GPU-поддержка — если данные большие, можно ускорить обучение.
🟢 Чистый API — удобно интегрировать в образовательные платформы или аналитические пайплайны.

pip install py-irt

import qrcode
import sys

def make_qr(data, output_file="qrcode.png", version=1, box_size=10, border=4):
    qr = qrcode.QRCode(
        version=version,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=box_size,
        border=border,
    )
    qr.add_data(data)
    qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white")
    img.save(output_file)
    print(f"QR saved to {output_file}")

if name == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python qr_gen.py <text_or_url>")
        sys.exit(1)
    data = sys.argv[1]
    make_qr(data)

🟢 Принимает строку (URL, текст и т.д.)
🟢 Генерирует QR-код с заданными параметрами (размер, граница)
🟢 Сохраняет в файл (PNG)
🟢 Можно встроить в GUI или веб-интерфейс

🟢 Поддержка CAN и LIN — взаимодействие с сетями транспортных сообщений через NI-XNET оборудование
🟢 Возможность читать кадры, сигналы, преобразовывать данные между физическим и представлением (unit conversion)
🟢 Использует API NI-XNET / NI hardware — фактически “Python на железо” решение
🟢 Поддержка Windows и взаимодействие с runtime NI-XNET

pip install nixnet

class ChainedDicts(dict):
    def __init__(self, *dicts):
        self.dicts = dicts
        self.base = {}

    def __getitem__(self, item):
        if item in self.base:
            return self.base[item]
        elif item not in self.dicts[0]:
            raise KeyError
        for internal_dict in self.dicts:
            if item in internal_dict:
                item = internal_dict[item]
            else:
                return item
        return item

    def __setitem__(self, key, value):
        self.base[key] = value

    def __delitem__(self, key):
        if key in self.base:
            del self.base[key]
        if key in self.dicts[0]:
            del self.dicts[0][key]

# Пример использования из Gist:
d = ChainedDicts({1: 2, 3: 4}, {4: 5, 6: 8})
print(d[1])
print(d[3])

🟢Конструирует словарь, объединяющий несколько уровней словарей
🟢При чтении ключа: сначала смотрит base (локальные переопределения), потом “цепочку” словарей
🟢При записи: всегда записывает в base
🟢При удалении: удаляет из base или из первого словаря, если там
🟢Позволяет иметь “умный” конфиг: “дефолт + overrides + runtime”

🟢 Поддерживает различные статистические методы для графов: распределения степеней, алгоритмы сравнения графов, random graph models.
🟢 API совместим с привычным стилем библиотек Python для работы с данными / машинным обучением: интеграция в пайплайны исследовательской работы.
🟢 Визуализация и инструменты анализа графов внутри библиотеки.
🟢 Открытый исходный код, лицензия Apache 2.0.

pip install graspy

import argparse
import subprocess

def autocut(input_files, output, silent_speed=10, silent_threshold=600, denoise=False):
    for input_vid in input_files:
        cmd = ["ffmpeg", "-i", input_vid]
        # добавляется фильтр, который ускоряет silent части
        vfilt = f"silencedetect=n={silent_threshold}dB"
        # здесь опции ускорения, убирание шума и т.д.
        # пример:
        cmd.extend([
            "-vf", vfilt,
            "-filter_complex", f"[0:v]setpts=PTS/ {silent_speed}[v]",
            "-map", "[v]", "-map", "0:a",
            output or f"{input_vid}_faster.mp4"
        ])
        if denoise:
            cmd.extend(["-af", "arnndn"])
        print("Running:", " ".join(cmd))
        subprocess.run(cmd, check=True)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Speed up silent parts in videos.")
    parser.add_argument("--input", nargs='+', required=True, help="Input video files *.mp4")
    parser.add_argument("--output", help="Output filename or directory")
    parser.add_argument("--silent-speed", type=int, default=10, help="How much to speed up silent parts")
    parser.add_argument("--silent-threshold", type=int, default=600, help="What is considered silent (threshold in milliseconds/sound level)")
    parser.add_argument("--denoise", action="store_true", help="Remove background noise using ffmpeg model")
    args = parser.parse_args()
    autocut(args.input, args.output, args.silent_speed, args.silent_threshold, args.denoise)

🟢 Определяет “тихие” участки видео, используя порог громкости / шумов
🟢 Автоматически ускоряет эти участки, чтобы сократить общее время просмотра видео
🟢 Опционально удаляет шум или фоновые звуки (denoise) при помощи фильтров ffmpeg
🟢 Сохраняет модифицированное видео с суффиксом или в указанное место

🟢 Аннотация типов клеток: библиотека помогает метить клетки по данным транскриптомики.
🟢 Выявление взаимодействий ниш: определение, какие типы клеток близко соседствуют и как они влияют друг на друга.
🟢 Ковариационный анализ: нахождение взаимозависимостей между наборами генов у взаимодействующих клеток.
🟢 Интеграция с популярными библиотеками: зависит от scanpy, pandas, numpy, pygraphviz и др.

pip install nico-sc-sp

import requests
from bs4 import BeautifulSoup
import os

def download_slideshare(slide_url, output_dir="slides"):
    os.makedirs(output_dir, exist_ok=True)
    resp = requests.get(slide_url)
    soup = BeautifulSoup(resp.text, "html.parser")
    # найти контейнер со слайдами, получить ссылки на изображения слайдов
    img_tags = soup.select("img.slide_image")  # пример селектора
    for idx, img in enumerate(img_tags):
        img_url = img.get("data-full") or img.get("src")
        if not img_url:
            continue
        ext = img_url.split('.')[-1]
        fname = f"slide_{idx}.{ext}"
        path = os.path.join(output_dir, fname)
        r = requests.get(img_url)
        with open(path, "wb") as f:
            f.write(r.content)
        print("Downloaded:", fname)

if __name__ == "__main__":
    url = "https://www.slideshare.net/some-presentation"
    download_slideshare(url)

🟢 Загружает HTML страницы Slideshare
🟢 Парсит HTML и извлекает ссылки на изображения слайдов
🟢 Скачивает каждый слайд как картинку
🟢 Сохраняет всё в указанную папку, нумеруя слайды

🟢 Поддержка Python 3.12.10 или новее.
🟢 Позволяет генерировать данные с различными типами аномальной диффузии (subdiffusion, superdiffusion и др.).
🟢 Встроенные методы статистического анализа (оценка показателей, сравнение моделей) + инференс моделей.
🟢 С визуализацией: возможность строить графики траекторий, распределений, оценки отклонения от нормальной диффузии.

pip install anomalouslib