Нейросети в руках школьника⁠⁠3

import sys
import logging
from abc import ABC, abstractmethod
from functools import wraps
from typing import Union, Optional, List

# ----------------------------------------------------------------------
# 1. слой пользовательских исключений
# ----------------------------------------------------------------------
class NumericSystemError(Exception):
"""Базовое исключение для всей математической вселенной."""
pass

class NumberFormatError(NumericSystemError):
"""Ошибка формата числа."""
pass

class InvalidIntegerError(NumberFormatError):
"""Ошибка: введённое значение не является целым числом."""
pass

class EmptyInputError(NumberFormatError):
"""Ошибка: пустой ввод."""
pass

class NegativeNumberWarning(UserWarning):
"""Предупреждение о знаке (мы всё равно обработаем)."""
pass

# ----------------------------------------------------------------------
# 2. логгер-одиночка
# ----------------------------------------------------------------------
class LoggerSingleton:
"""
Потокобезопасный (нет) синглтон для ведения журнала всех
арифметических операций вселенной.
"""
_instance = None
_initialized = False

def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance

def __init__(self):
if not self._initialized:
self._logger = logging.getLogger("HyperbolicNineChecker")
self._logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stderr)
formatter = logging.Formatter(
"%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
handler.setFormatter(formatter)
if not self._logger.handlers:
self._logger.addHandler(handler)
self._initialized = True

def log(self, level: int, message: str):
self._logger.log(level, message)

logger = LoggerSingleton()

# ----------------------------------------------------------------------
# 3. Абстрактная иерархия «Цифро-ориентированных сущностей»
# ----------------------------------------------------------------------
class AbstractDigitEntity(ABC):
"""Абстрактная сущность, имеющая отношение к цифрам."""
@abstractmethod
def as_digit(self) -> int:
pass

class ConcreteDigit(AbstractDigitEntity):
"""Конкретная цифра от 0 до 9."""
def __init__(self, value: int):
if not 0 <= value <= 9:
raise ValueError(f"Цифра должна быть 0..9, получено {value}")
self._value = value

def as_digit(self) -> int:
return self._value

def __eq__(self, other):
if isinstance(other, ConcreteDigit):
return self._value == other._value
if isinstance(other, int):
return self._value == other
return False

def __repr__(self):
return f"ConcreteDigit({self._value})"

# ----------------------------------------------------------------------
# 4. Класс «Число как объект»
# ----------------------------------------------------------------------
class WholeNumber:
"""
Представление целого числа в виде объекта с дополнительными
методами анализа и украшательствами.
"""
def __init__(self, raw_input: str):
self._raw = raw_input.strip()
self._value: Optional[int] = None
self._validate_and_parse()

def _validate_and_parse(self):
if not self._raw:
raise EmptyInputError("Пустая строка не может быть числом!")
# Убираем возможные знаки и проверяем цифры
candidate = self._raw
if candidate[0] in ('+', '-'):
candidate = candidate[1:]
if not candidate.isdigit():
raise InvalidIntegerError(
f"'{self._raw}' не является допустимым целым числом!"
)
self._value = int(self._raw)
logger.log(logging.INFO, f"Успешно распознано число: {self._value}")

@property
def integer_value(self) -> int:
return self._value

def last_digit(self) -> ConcreteDigit:
"""Возвращает последнюю цифру как объект ConcreteDigit."""
abs_val = abs(self._value)
digit_int = abs_val % 10
return ConcreteDigit(digit_int)

def __str__(self):
return str(self._value)

# ----------------------------------------------------------------------
# 5. Валидаторы
# ----------------------------------------------------------------------
class InputValidator(ABC):
"""Абстрактный валидатор пользовательского ввода."""
@abstractmethod
def validate(self, user_input: str) -> bool:
pass

class NotEmptyValidator(InputValidator):
def validate(self, user_input: str) -> bool:
if not user_input or not user_input.strip():
raise EmptyInputError("Строка не должна быть пустой!")
return True

class IntegerFormatValidator(InputValidator):
def validate(self, user_input: str) -> bool:
stripped = user_input.strip()
if stripped[0] in ('+', '-'):
stripped = stripped[1:]
if not stripped.isdigit():
raise InvalidIntegerError("Содержимое должно состоять только из цифр и опционального знака.")
return True

class CompositeValidator(InputValidator):
"""Применяет несколько валидаторов последовательно."""
def __init__(self, validators: List[InputValidator]):
self._validators = validators

def validate(self, user_input: str) -> bool:
for v in self._validators:
v.validate(user_input)
return True

# ----------------------------------------------------------------------
# 6. Фабрика для создания объекта числа (с паттерном)
# ----------------------------------------------------------------------
class NumberFactory:
"""Фабрика, порождающая объекты WholeNumber с полной валидацией."""
@staticmethod
def create_from_input(user_input: str) -> WholeNumber:
validator = CompositeValidator([
NotEmptyValidator(),
IntegerFormatValidator()
])
validator.validate(user_input)
return WholeNumber(user_input)

# ----------------------------------------------------------------------
# 7. Декоратор для измерения (бессмысленного) времени проверки
# ----------------------------------------------------------------------
def performance_logger(func):
@wraps(func)
def wrapper(*args, **kwargs):
import time
start = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() - start
logger.log(logging.DEBUG,
f"Метод '{func.__name__}' отработал за {elapsed:.10f} сек.")
return result
return wrapper

# ----------------------------------------------------------------------
# 8. Главный чекер, использующий всю инфраструктуру
# ----------------------------------------------------------------------
class NineTerminationChecker:
"""
Класс, отвечающий за единственную операцию:
проверку окончания числа на 9.
"""
NINE_DIGIT = ConcreteDigit(9)

def __init__(self, number: WholeNumber):
self._number = number

@performance_logger
def check_ends_with_nine(self) -> bool:
"""
Сравнивает последнюю цифру числа с эталонным объектом ConcreteDigit(9).
"""
last = self._number.last_digit()
logger.log(logging.INFO, f"Последняя цифра числа {self._number}: {last}")
return last == self.NINE_DIGIT

def print_verdict(self):
"""Выводит торжественное заключение."""
if self.check_ends_with_nine():
print(f"✅ Число {self._number} заканчивается на 9.")
else:
print(f"❌ Число {self._number} НЕ заканчивается на 9 (последняя цифра: {self._number.last_digit().as_digit()}).")

# ----------------------------------------------------------------------
# 9. Главная программа с обработкой всех исключений
# ----------------------------------------------------------------------
def main():
"""Точка входа в гипертрофированную вселенную."""
print("=" * 60)
print(" ПРОВЕРКА ОКОНЧАНИЯ ЧИСЛА НА 9")
print("=" * 60)
user_input = input("Введите целое число: ")

try:
# Фабрика создаёт обёртку числа со всей валидацией
number = NumberFactory.create_from_input(user_input)

# Создаём чекер и выдаём вердикт
checker = NineTerminationChecker(number)
checker.print_verdict()

except EmptyInputError as e:
print(f"ОШИБКА ПУСТОГО ВВОДА: {e}")
logger.log(logging.ERROR, str(e))
sys.exit(1)
except InvalidIntegerError as e:
print(f"ОШИБКА ФОРМАТА ЧИСЛА: {e}")
logger.log(logging.ERROR, str(e))
sys.exit(2)
except NumericSystemError as e:
print(f"СИСТЕМНАЯ ОШИБКА: {e}")
logger.log(logging.CRITICAL, str(e))
sys.exit(3)
except Exception as e:
print(f"НЕПРЕДВИДЕННАЯ КАТАСТРОФА: {e}")
logger.log(logging.CRITICAL, f"Неизвестное исключение: {e}")
sys.exit(99)

if __name__ == "__main__":
main()