chutils 1.0.0__py3-none-any.whl

chutils/__init__.py

@@ -0,0 +1,104 @@
+"""
+Пакет chutils - набор переиспользуемых утилит для Python.
+
+Основная цель - упростить рутинные задачи, такие как работа с конфигурацией
+и настройка логирования, с минимальными усилиями со стороны разработчика.
+
+Ключевая особенность - автоматическое обнаружение корня проекта. Вам не нужно
+вручную указывать пути к файлу 'config.ini' или папке 'logs'. Пакет сам найдет
+их, ориентируясь на наличие 'config.ini' или 'pyproject.toml' в вашем проекте.
+
+Основное использование (в 99% случаев):
+-------------------------------------------
+Вам не нужно ничего инициализировать. Просто импортируйте и используйте:
+
+    from chutils.config import get_config_value
+    from chutils.logger import setup_logger
+
+    logger = setup_logger()
+    db_host = get_config_value("Database", "host", "localhost")
+    logger.info(f"Подключение к базе данных на {db_host}")
+
+Ручная инициализация (для нестандартных случаев):
+-------------------------------------------------
+Если автоматика не сработала (например, у вас сложная структура проекта),
+вы всегда можете указать путь к корню проекта вручную в самом начале
+работы вашего приложения:
+
+    import chutils
+    chutils.init(base_dir="/path/to/your/project")
+
+"""
+
+import os
+
+# Импортируем модули config и logger, чтобы их внутренние переменные
+# были доступны для функции init.
+from . import config
+from . import logger
+
+# --- Импорт публичных функций ---
+# Мы явно импортируем только те функции, которые предназначены для
+# конечного пользователя. Это формирует "чистый" публичный API пакета.
+
+from .config import (
+    load_config, save_config_value, get_config, get_config_value,
+    get_config_int, get_config_float, get_config_boolean, get_config_list,
+    get_multiple_config_values, get_config_section
+)
+from .logger import setup_logger
+
+
+def init(base_dir: str):
+    """
+    Ручная инициализация пакета с указанием базовой директории проекта.
+
+    Эту функцию нужно вызывать только в том случае, если автоматическое
+    определение корня проекта не сработало. Вызывать следует один раз
+    в самом начале работы основного скрипта вашего приложения.
+
+    Args:
+        base_dir (str): Абсолютный путь к корневой директории проекта,
+                        где лежит 'config.ini'.
+
+    Raises:
+        ValueError: Если указанная директория не существует.
+    """
+    # Проверяем, что переданный путь является существующей директорией
+    if not os.path.isdir(base_dir):
+        raise ValueError(f"Указанная директория base_dir не существует или не является директорией: {base_dir}")
+
+    # Вручную устанавливаем внутренние переменные в модуле config.
+    # Это переопределит любые попытки автоматического поиска.
+    config._BASE_DIR = base_dir
+    config._CONFIG_FILE_PATH = os.path.join(base_dir, "config.ini")
+    config._paths_initialized = True
+
+    # Выводим сообщение, чтобы было понятно, что произошла ручная инициализация.
+    print(f"Пакет chutils вручную инициализирован с базовой директорией: {base_dir}")
+
+
+# --- Определение публичного API ---
+# `__all__` — это специальный список, который определяет, какие имена будут
+# импортированы, когда пользователь выполнит `from chutils import *`.
+# Это также является явным соглашением о том, что является публичным API пакета.
+
+__all__ = [
+    # Основная функция ручной инициализации
+    'init',
+
+    # Функции из модуля config
+    'load_config',
+    'save_config_value',
+    'get_config',
+    'get_config_value',
+    'get_config_int',
+    'get_config_float',
+    'get_config_boolean',
+    'get_config_list',
+    'get_multiple_config_values',
+    'get_config_section',
+
+    # Функции из модуля logger
+    'setup_logger',
+]

chutils/config.py

@@ -0,0 +1,267 @@
+"""
+Модуль для работы с конфигурацией.
+
+Обеспечивает автоматический поиск файла `config.ini` в корне проекта
+и предоставляет удобные функции для чтения и записи настроек.
+"""
+
+import configparser
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any, Optional, List, Dict
+
+# Настраиваем логгер для этого модуля
+logger = logging.getLogger(__name__)
+
+# --- Глобальное состояние для хранения путей ---
+# Эти переменные инициализируются один раз при первом обращении к конфигурации.
+
+_BASE_DIR: Optional[str] = None
+_CONFIG_FILE_PATH: Optional[str] = None
+_paths_initialized = False
+
+
+def find_project_root(start_path: Path, markers: List[str]) -> Optional[Path]:
+    """
+    Ищет корень проекта, двигаясь вверх по дереву каталогов от `start_path`.
+
+    Корень определяется наличием одного из файлов-маркеров (например, 'config.ini').
+    """
+    current_path = start_path.resolve()
+    # Идем вверх до тех пор, пока не достигнем корня файловой системы
+    while current_path != current_path.parent:
+        for marker in markers:
+            if (current_path / marker).exists():
+                logger.debug(f"Найден маркер '{marker}' в директории: {current_path}")
+                return current_path
+        current_path = current_path.parent
+    logger.debug("Корень проекта не найден.")
+    return None
+
+
+def _initialize_paths():
+    """
+    Автоматически находит и устанавливает пути. Вызывается при первом доступе.
+    Это "сердце" автоматического обнаружения.
+    """
+    global _BASE_DIR, _CONFIG_FILE_PATH, _paths_initialized
+    if _paths_initialized:
+        return
+
+    # Ищем корень проекта, начиная от текущей рабочей директории.
+    # Приоритетный маркер — 'config.ini', запасной — 'pyproject.toml'.
+    project_root = find_project_root(Path.cwd(), markers=['config.ini', 'pyproject.toml'])
+
+    if project_root:
+        _BASE_DIR = str(project_root)
+        _CONFIG_FILE_PATH = os.path.join(_BASE_DIR, "config.ini")
+        logger.info(f"Корень проекта автоматически определен: {_BASE_DIR}")
+    else:
+        # Если не нашли, оставляем пути пустыми. Функции ниже будут выбрасывать ошибку.
+        logger.warning("Не удалось автоматически найти корень проекта (отсутствуют config.ini или pyproject.toml).")
+
+    _paths_initialized = True
+
+
+def _get_config_path(cfg_file: Optional[str] = None) -> str:
+    """
+    Внутренняя функция-шлюз для получения пути к файлу конфигурации.
+
+    Если путь не был установлен, запускает автоматический поиск.
+    Если путь не передан явно и автоматический поиск не дал результатов,
+    выбрасывает исключение с понятным сообщением.
+    """
+    # Если путь к файлу передан явно, используем его.
+    if cfg_file:
+        return cfg_file
+
+    # Если пути еще не инициализированы, запускаем поиск.
+    if not _paths_initialized:
+        _initialize_paths()
+
+    # Если после инициализации путь все еще не определен, это ошибка.
+    if _CONFIG_FILE_PATH is None:
+        raise FileNotFoundError(
+            "Файл конфигурации не найден. Не удалось автоматически определить корень проекта. "
+            "Убедитесь, что в корне вашего проекта есть 'config.ini' или 'pyproject.toml', "
+            "либо укажите путь к конфигу вручную через chutils.init(base_dir=...)"
+        )
+    return _CONFIG_FILE_PATH
+
+
+def load_config(cfg_file: Optional[str] = None) -> configparser.ConfigParser:
+    """
+    Загружает конфигурацию из .ini файла.
+
+    Args:
+        cfg_file (str, optional): Явный путь к файлу конфигурации.
+                                  Если не указан, будет использован автоматически найденный путь.
+
+    Returns:
+        configparser.ConfigParser: Загруженный объект конфигурации.
+    """
+    path = _get_config_path(cfg_file)
+    if not os.path.exists(path):
+        logger.critical(f"Файл конфигурации НЕ НАЙДЕН: {path}")
+        return configparser.ConfigParser()
+
+    config = configparser.ConfigParser()
+    try:
+        config.read(path, encoding='utf-8')
+        logger.info(f"Конфигурация успешно загружена из {path}")
+        return config
+    except configparser.Error as e:
+        logger.critical(f"Ошибка чтения файла конфигурации {path}: {e}")
+        return configparser.ConfigParser()
+
+
+def save_config_value(section: str, key: str, value: str, cfg_file: Optional[str] = None) -> bool:
+    """
+    Сохраняет одно значение в конфигурационном файле, пытаясь сохранить комментарии.
+
+    Изменяет только первую найденную строку с ключом в нужной секции.
+    Не добавляет новые секции или ключи, если они не существуют.
+    """
+    path = _get_config_path(cfg_file)
+    if not os.path.exists(path):
+        logger.error(f"Невозможно сохранить значение: файл конфигурации {path} не найден.")
+        return False
+
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+    except IOError as e:
+        logger.error(f"Ошибка чтения файла {path} для сохранения: {e}")
+        return False
+
+    updated = False
+    in_target_section = False
+    section_found = False
+    key_found_in_section = False
+    section_pattern = re.compile(r'^\s*\[\s*(?P<section_name>[^]]+)\s*\]\s*')
+    key_pattern = re.compile(rf'^\s*({re.escape(key)})\s*=\s*(.*)', re.IGNORECASE)
+
+    new_lines = []
+    for line in lines:
+        section_match = section_pattern.match(line)
+        if section_match:
+            current_section_name = section_match.group('section_name').strip()
+            if current_section_name.lower() == section.lower():
+                in_target_section = True
+                section_found = True
+            else:
+                in_target_section = False
+            new_lines.append(line)
+            continue
+
+        if in_target_section and not key_found_in_section:
+            key_match = key_pattern.match(line)
+            if key_match:
+                original_key = key_match.group(1)
+                new_line_content = f"{original_key} = {value}\n"
+                new_lines.append(new_line_content)
+                key_found_in_section = True
+                updated = True
+                logger.info(f"Ключ '{key}' в секции '[{section}]' будет обновлен на '{value}' в файле {path}")
+                continue
+
+        new_lines.append(line)
+
+    if not section_found:
+        logger.warning(f"Секция '[{section}]' не найдена в файле {path}. Значение НЕ сохранено.")
+        return False
+    if section_found and not key_found_in_section:
+        logger.warning(f"Ключ '{key}' не найден в секции '[{section}]' файла {path}. Значение НЕ сохранено.")
+        return False
+
+    if updated:
+        try:
+            with open(path, 'w', encoding='utf-8') as f:
+                f.writelines(new_lines)
+            logger.info(f"Файл конфигурации {path} успешно обновлен.")
+            return True
+        except IOError as e:
+            logger.error(f"Ошибка записи в файл {path} при сохранении: {e}")
+            return False
+    else:
+        logger.debug(f"Обновление для ключа '{key}' в секции '[{section}]' не потребовалось.")
+        return False
+
+
+def get_config() -> configparser.ConfigParser:
+    """Возвращает полностью загруженный объект конфигурации."""
+    return load_config()
+
+
+# --- Функции-обертки для удобного получения значений ---
+
+def get_config_value(section: str, key: str, fallback: str = "", config: Optional[configparser.ConfigParser] = None) -> str:
+    """Получает строковое значение из конфигурации."""
+    if config is None: config = load_config()
+    return config.get(section, key, fallback=fallback)
+
+
+def get_config_int(section: str, key: str, fallback: int = 0, config: Optional[configparser.ConfigParser] = None) -> int:
+    """Получает целочисленное значение из конфигурации."""
+    if config is None: config = load_config()
+    return config.getint(section, key, fallback=fallback)
+
+
+def get_config_float(section: str, key: str, fallback: float = 0.0, config: Optional[configparser.ConfigParser] = None) -> float:
+    """Получает дробное значение из конфигурации."""
+    if config is None: config = load_config()
+    return config.getfloat(section, key, fallback=fallback)
+
+
+def get_config_boolean(section: str, key: str, fallback: bool = False, config: Optional[configparser.ConfigParser] = None) -> bool:
+    """Получает булево значение из конфигурации."""
+    if config is None: config = load_config()
+    return config.getboolean(section, key, fallback=fallback)
+
+
+def get_config_list(section: str, key: str, fallback: Optional[List[str]] = None, config: Optional[configparser.ConfigParser] = None) -> List[str]:
+    """
+    Получает многострочное значение и возвращает его в виде списка очищенных строк.
+
+    Идеально подходит для списков:
+    - Разделяет значение по переносам строк.
+    - Удаляет пустые строки и лишние пробелы.
+    - Игнорирует строки, начинающиеся с '#' (комментарии).
+    """
+    if fallback is None:
+        fallback = []
+    raw_value = get_config_value(section, key, fallback="", config=config)
+    if not raw_value:
+        return fallback
+
+    lines = [line.strip() for line in raw_value.splitlines() if line.strip() and not line.strip().startswith('#')]
+    return lines
+
+
+def get_multiple_config_values(section: str, keys: List[str], config: Optional[configparser.ConfigParser] = None) -> Dict[str, Optional[str]]:
+    """Получает словарь значений для указанных ключей в секции."""
+    if config is None: config = load_config()
+    values = {}
+    if config.has_section(section):
+        for key in keys:
+            values[key] = config.get(section, key, fallback=None)
+    return values
+
+
+def get_config_section(section_name: str, fallback: Optional[Dict] = None, config: Optional[configparser.ConfigParser] = None) -> Dict[str, str]:
+    """
+    Получает всю секцию из конфигурации как словарь.
+    """
+    if fallback is None:
+        fallback = {}
+    if config is None:
+        config = load_config()
+
+    if config.has_section(section_name):
+        # Преобразуем секцию в обычный словарь
+        return dict(config.items(section_name))
+    else:
+        logger.warning(f"Секция '{section_name}' не найдена в конфигурации. Возвращен fallback.")
+        return fallback

chutils/logger.py

@@ -0,0 +1,186 @@
+"""
+Модуль для настройки логирования.
+
+Предоставляет унифицированную функцию setup_logger для создания и настройки логгеров,
+которые могут выводить сообщения в консоль и в файлы с автоматической ротацией.
+Директория для логов ('logs') создается автоматически в корне проекта.
+"""
+
+import logging
+import logging.handlers
+import os
+from typing import Optional
+
+# Импортируем наш модуль config для доступа к путям и настройкам
+from . import config
+
+# --- Пользовательские уровни логирования ---
+# Для более гранулярного контроля над отладочными сообщениями.
+
+DEVDEBUG_LEVEL_NUM = 9
+DEVDEBUG_LEVEL_NAME = "DEVDEBUG"
+MEDIUMDEBUG_LEVEL_NUM = 15
+MEDIUMDEBUG_LEVEL_NAME = "MEDIUMDEBUG"
+
+logging.addLevelName(MEDIUMDEBUG_LEVEL_NUM, MEDIUMDEBUG_LEVEL_NAME)
+logging.addLevelName(DEVDEBUG_LEVEL_NUM, DEVDEBUG_LEVEL_NAME)
+
+
+def mediumdebug(self, message, *args, **kws):
+    if self.isEnabledFor(MEDIUMDEBUG_LEVEL_NUM):
+        self._log(MEDIUMDEBUG_LEVEL_NUM, message, args, **kws)
+
+
+def devdebug(self, message, *args, **kws):
+    if self.isEnabledFor(DEVDEBUG_LEVEL_NUM):
+        self._log(DEVDEBUG_LEVEL_NUM, message, args, **kws)
+
+
+# "Патчим" класс Logger, чтобы добавить наши кастомные методы
+if not hasattr(logging.Logger, MEDIUMDEBUG_LEVEL_NAME.lower()):
+    logging.Logger.mediumdebug = mediumdebug
+
+if not hasattr(logging.Logger, DEVDEBUG_LEVEL_NAME.lower()):
+    logging.Logger.devdebug = devdebug
+
+# --- Глобальное состояние для "ленивой" инициализации ---
+
+# Кэш для пути к директории логов. Изначально пуст.
+_LOG_DIR: Optional[str] = None
+# Глобальный экземпляр основного логгера приложения
+_logger_instance: Optional[logging.Logger] = None
+# Флаг, чтобы сообщение об инициализации выводилось только один раз
+_initialization_message_shown = False
+
+
+def _get_log_dir() -> Optional[str]:
+    """
+    "Лениво" получает и кэширует путь к директории логов.
+
+    При первом вызове:
+    1. Запускает поиск корня проекта через модуль config.
+    2. Создает директорию 'logs' в корне проекта, если ее нет.
+    3. Кэширует результат.
+    При последующих вызовах немедленно возвращает кэшированный путь.
+    """
+    global _LOG_DIR
+    # Если путь уже кэширован, сразу возвращаем его.
+    if _LOG_DIR is not None:
+        return _LOG_DIR
+
+    # Запускаем инициализацию в config, если она еще не была выполнена.
+    # Это "сердце" автоматического обнаружения.
+    config._initialize_paths()
+
+    # Берем найденный config'ом базовый каталог проекта.
+    base_dir = config._BASE_DIR
+
+    # Если корень проекта не был найден, файловое логирование невозможно.
+    if not base_dir:
+        print("ПРЕДУПРЕЖДЕНИЕ: Не удалось определить корень проекта, файловое логирование будет отключено.")
+        return None
+
+    # Создаем путь к директории логов и саму директорию, если нужно.
+    log_path = os.path.join(base_dir, 'logs')
+    if not os.path.exists(log_path):
+        try:
+            os.makedirs(log_path)
+            print(f"INFO: Создана директория для логов: {log_path}")
+        except OSError as e:
+            # Если не удалось создать директорию, логирование в файл будет невозможно.
+            print(f"ОШИБКА: Не удалось создать директорию для логов {log_path}: {e}")
+            return None
+
+    # Кэшируем успешный результат и возвращаем его.
+    _LOG_DIR = log_path
+    return _LOG_DIR
+
+
+def setup_logger(name: str = 'app_logger', log_level_str: str = '') -> logging.Logger:
+    """
+    Настраивает и возвращает логгер с нужным именем.
+
+    - Предотвращает повторную настройку уже существующего логгера.
+    - Читает настройки из config.ini (уровень, имя файла и т.д.).
+    - Добавляет обработчики для вывода в консоль и в файл с ежедневной ротацией.
+
+    Args:
+        name (str): Имя логгера. 'app_logger' используется для основного логгера приложения.
+        log_level_str (str, optional): Явное указание уровня логирования (например, 'DEBUG').
+                                       Если не задан, берется из конфига.
+
+    Returns:
+        logging.Logger: Настроенный экземпляр логгера.
+    """
+    global _logger_instance, _initialization_message_shown
+
+    # Если логгер с таким именем уже имеет обработчики, значит он настроен.
+    # Просто возвращаем его, чтобы не дублировать вывод.
+    existing_logger = logging.getLogger(name)
+    if existing_logger.hasHandlers():
+        return existing_logger
+
+    # Если запрашивается основной логгер приложения и он уже есть в кэше.
+    if name == 'app_logger' and _logger_instance:
+        return _logger_instance
+
+    # Получаем директорию для логов. Это первая точка, где запускается вся магия поиска путей.
+    log_dir = _get_log_dir()
+
+    # Загружаем конфигурацию для получения настроек логирования.
+    cfg = config.get_config()
+
+    # Определяем уровень логирования
+    if not log_level_str:
+        log_level_str = config.get_config_value('Logging', 'log_level', 'INFO', cfg)
+    log_level = getattr(logging, log_level_str.upper(), logging.INFO)
+
+    # Получаем остальные настройки из конфига
+    log_file_name = config.get_config_value('Logging', 'log_file_name', 'app.log', cfg)
+    backup_count = config.get_config_int('Logging', 'log_backup_count', 3, cfg)
+
+    # Создаем и настраиваем новый экземпляр логгера
+    logger = logging.getLogger(name)
+    logger.setLevel(log_level)
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+    # 1. Обработчик для вывода в консоль (StreamHandler)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    # 2. Обработчик для записи в файл (TimedRotatingFileHandler)
+    #    Добавляем его, только если директория логов была успешно определена.
+    if log_dir and log_file_name:
+        log_file_path = os.path.join(log_dir, log_file_name)
+        try:
+            # Ротация каждый день ('D'), храним backup_count старых файлов
+            file_handler = logging.handlers.TimedRotatingFileHandler(
+                log_file_path,
+                when="D",
+                interval=1,
+                backupCount=backup_count,
+                encoding='utf-8'
+            )
+            file_handler.setFormatter(formatter)
+            logger.addHandler(file_handler)
+
+            # Выводим информационное сообщение только один раз для всего приложения
+            if not _initialization_message_shown:
+                logger.info(
+                    f"Логирование настроено. Уровень: {log_level_str}. "
+                    f"Файл: {log_file_path}, ротация: {backup_count} дней."
+                )
+                _initialization_message_shown = True
+        except Exception as e:
+            logger.error(f"Не удалось настроить файловый обработчик логов для {log_file_path}: {e}")
+    else:
+        if not _initialization_message_shown:
+            logger.warning("Директория для логов не настроена. Файловое логирование отключено.")
+            _initialization_message_shown = True
+
+    # Кэшируем основной логгер приложения
+    if name == 'app_logger':
+        _logger_instance = logger
+
+    return logger

chutils-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chu4hel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chutils-1.0.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.3
+Name: chutils
+Version: 1.0.0
+Summary: 
+License: MIT
+Author: Sergo
+Author-email: sergeiivanov636@gmail.com
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+
+# chutils
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+
+Набор простых и удобных утилит для Python, который избавляет от рутины при работе с конфигурацией и логированием в новых проектах.
+
+## Проблема
+
+Каждый раз, начиная новый проект, приходится решать одни и те же задачи:
+- Как удобно читать настройки из файла `config.ini`?
+- Как настроить логирование, чтобы сообщения писались и в консоль, и в файл с ежедневной ротацией?
+- Как сделать так, чтобы это работало без жестко прописанных путей и работало сразу после установки?
+
+**chutils** решает эти проблемы.
+
+## Ключевые возможности
+
+- **✨ Ноль конфигурации:** Библиотека **автоматически** находит корень вашего проекта и файл `config.ini`. Вам не нужно ничего инициализировать вручную.
+- **⚙️ Удобная работа с конфигом:** Простые функции для получения строковых, числовых, булевых значений и даже списков из `config.ini`.
+- **✍️ Мощный логгер:** Функция `setup_logger()` "из коробки" настраивает логирование в консоль и в ротируемые файлы в папке `logs/`, которая создается автоматически.
+- **🚀 Готовность к работе:** Просто установите и используйте.
+
+## Установка
+
+Вы можете установить пакет напрямую из GitHub-репозитория с помощью `pip`:
+
+```bash
+pip install git+https://github.com/Chu4hel/chutils.git
+```
+
+Для разработки клонируйте репозиторий и установите его в режиме редактирования:
+```bash
+git clone https://github.com/Chu4hel/chutils.git
+cd chutils
+pip install -e .
+```
+
+## Быстрый старт
+
+1.  Создайте в корне вашего проекта файл `config.ini`.
+
+    **Структура проекта:**
+    ```
+    my_awesome_app/
+    ├── main.py
+    └── config.ini
+    ```
+
+    **Содержимое `config.ini`:**
+    ```ini
+    [API]
+    base_url = https://api.example.com
+    token = your_secret_token_here
+
+    [Database]
+    host = localhost
+    port = 5432
+    ```
+
+2.  Используйте `chutils` в вашем коде `main.py`:
+
+    ```python
+    # main.py
+    from chutils.config import get_config_value
+    from chutils.logger import setup_logger
+
+    # 1. Настраиваем логгер. Он автоматически прочитает настройки из config.ini
+    #    и создаст папку logs/
+    logger = setup_logger()
+
+    def connect_to_db():
+        # 2. Легко получаем значения из конфига
+        db_host = get_config_value("Database", "host")
+        db_port = get_config_value("Database", "port")
+
+        logger.info(f"Подключаемся к базе данных по адресу {db_host}:{db_port}...")
+        # ... логика подключения ...
+        logger.info("Успешно подключились!")
+
+    def main():
+        logger.info("Приложение запущено.")
+        connect_to_db()
+        api_token = get_config_value("API", "token")
+        logger.debug(f"Используемый токен API: {api_token[:4]}****")
+        logger.info("Приложение завершило работу.")
+
+    if __name__ == "__main__":
+        main()
+    ```
+
+3.  Запустите ваш скрипт. Вы увидите логи в консоли, а в проекте появится папка `logs` с файлом лога.
+
+## API и Использование
+
+### Работа с конфигурацией (`chutils.config`)
+
+- `get_config_value(section, key, fallback="")`: Получить строковое значение.
+- `get_config_int(section, key, fallback=0)`: Получить целое число.
+- `get_config_boolean(section, key, fallback=False)`: Получить булево значение.
+- `get_config_list(section, key, fallback=[])`: Получить список строк из многострочного значения.
+- `save_config_value(section, key, value)`: Сохранить значение в `config.ini`.
+
+### Настройка логирования (`chutils.logger`)
+
+- `setup_logger(name='app_logger', log_level_str='')`: Настраивает и возвращает стандартный объект `logging.Logger`.
+
+### Ручная инициализация (`chutils.init`)
+
+В 99% случаев вам это **не понадобится**. Но если автоматика не справилась, вы можете один раз указать путь к проекту вручную:
+```python
+import chutils
+chutils.init(base_dir="/path/to/my/project/root")
+```
+
+### Пример файла `config.ini`
+
+`chutils` использует секцию `[Logging]` для настройки логгера.
+
+```ini
+[API]
+token = your_secret_token_here
+
+[Database]
+host = localhost
+
+[Logging]
+# Уровни: DEBUG, INFO, WARNING, ERROR, CRITICAL
+log_level = DEBUG
+# Имя файла для логов
+log_file_name = my_app.log
+# Сколько дней хранить файлы логов
+log_backup_count = 7
+```
+
+## Лицензия
+
+Проект распространяется под лицензией MIT.

chutils-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+chutils/__init__.py,sha256=PJ7vusg09BA87CH46PQuMuzqN_2fdmW3DZwzz5g34CU,5395
+chutils/config.py,sha256=suN_1LDY3Jn50bLIzCXyng9snhluhIn4a_TG1Uumepo,12932
+chutils/logger.py,sha256=BUc76gvTyjmsiD6niA7CSMJ6I7RweRCEJA90sBc2z_c,9596
+chutils-1.0.0.dist-info/LICENSE,sha256=S3egx-rPyEfAdXQl2ybrzfOJmUDlK3KBP2GqroTvm9o,1085
+chutils-1.0.0.dist-info/METADATA,sha256=S0RREF-meeVsqmR0X0p4imfDQ3uX8ctjvNx0IhZHYL0,6702
+chutils-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+chutils-1.0.0.dist-info/RECORD,,

chutils-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any