codeinsult 0.1.0__tar.gz

codeinsult-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vaz15k
+
+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.

codeinsult-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: codeinsult
+Version: 0.1.0
+Summary: Turn HTTP errors into laughter — funny, sarcastic & offensive messages for every status code.
+Author: Vaz15k
+License-Expression: MIT
+Project-URL: Source, https://github.com/Vaz15k/code-insult
+Project-URL: Tracker, https://github.com/Vaz15k/code-insult/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# CodeInsult
+
+> **Turn errors into laughter.** A Python library that maps HTTP status codes to funny, sarcastic, and offensive messages — from "cult reference" to "heavy insult" levels.
+
+> **English 🇺🇸** | [Português 🇧🇷](docs/README.pt.md)
+
+[![Python](https://img.shields.io/badge/python-≥3.11-blue.svg)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Version](https://img.shields.io/badge/version-0.1.0-orange.svg)](codeinsult/__version__.py)
+
+---
+
+## Installation
+
+```bash
+pip install codeinsult
+```
+
+> *Requires Python 3.11 or higher.*
+
+---
+
+## Usage
+
+```python
+import codeinsult
+
+# Get a message for a status code
+print(codeinsult.insult(404))
+# "404: O recurso sumiu. Como meias na máquina de lavar."
+
+# With severity level ("light", "medium", "heavy")
+print(codeinsult.insult(500, level="heavy"))
+# "DEU MERDA NO SERVIDOR! Não foi você, foi a gente. Mas foi você também."
+
+# A completely random message
+print(codeinsult.random_insult())
+# "418 I'm a Teapot: Sou um bule, não uma cafeteira. Respeita minha profissão!"
+
+# Configure global defaults
+codeinsult.set_defaults(lang="pt_br", level="light")
+print(codeinsult.insult(401))
+# "401 Unauthorized: Você não vai passar! — Gandalf, Servidor Edition."
+```
+
+---
+
+## Severity Levels
+
+| Level      | Description                                                  | Example                                                                             |
+| ---------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------- |
+| `LIGHT`  | References to movies, series, books, and memes. No swearing. | *"404: Procurei em toda galáxia e não achei. — Baby Yoda."*                    |
+| `MEDIUM` | Sarcasm and irony. Mildly offensive language.                | *"500: O servidor teve um treco. Tenta de novo quando ele se recuperar."*         |
+| `HEAVY`  | Heavy insults, with explicit swear words and profanity.      | *"400: QUE REQUEST DE MERDA É ESSE? Nem o Google Tradutor salva essa bagunça!"* |
+
+---
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/Vaz15k/code-insult.git
+cd code-insult
+
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run the tests
+pytest tests/ -v
+```
+
+---
+
+## Contributing
+
+Contributions are very welcome! Some ideas:
+
+- 🗣️ **Add new languages** — Spanish, French, etc.
+- 💬 **Add more phrases** for existing status codes (Be Creative)
+- 🐛 **Fix bugs** or improve documentation
+- 📦 **New status codes** that don't have messages yet
+
+To contribute:
+
+1. Fork the project
+2. Create a branch for your feature
+3. Add your messages and tests
+4. Submit a Pull Request

codeinsult-0.1.0/codeinsult/CodeInsult.py

@@ -0,0 +1,107 @@
+import random
+from typing import Optional
+
+from codeinsult.config import InsultLevel
+from codeinsult.messages.registry import available_languages, get_provider
+
+_default_lang: str = "pt_br"
+_default_level: Optional[InsultLevel] = None
+
+
+def set_defaults(
+    *,
+    lang: str = "pt_br",
+    level: Optional[str] = None,
+) -> None:
+    """Configura o idioma e nível de severidade padrão globais.
+
+    Args:
+        lang: Idioma padrão (ex: ``"pt_br"``).
+        level: Nível de severidade padrão (``"light"``, ``"medium"``,
+            ``"heavy"``). ``None`` para usar todos os níveis.
+
+    Example:
+        >>> codeinsult.set_defaults(lang="pt_br", level="light")
+        >>> codeinsult.insult(404)  # usa pt_br + LIGHT
+    """
+    global _default_lang, _default_level
+    if lang not in available_languages():
+        raise ValueError(
+            f"Idioma '{lang}' não disponível. Disponíveis: {available_languages()}"
+        )
+    _default_lang = lang
+    _default_level = InsultLevel.from_str(level)
+
+
+def insult(
+    status_code: int,
+    *,
+    level: Optional[str] = None,
+    lang: Optional[str] = None,
+) -> str:
+    """
+    Retorna uma mensagem engraçada para o código de status HTTP informado.
+
+    Args:
+        status_code: Código de status HTTP (ex: 200, 404, 500).
+        level: Nível de severidade (``"light"``, ``"medium"``, ``"heavy"``).
+            Se None, usa TODOS os níveis.
+        lang: Idioma (ex: ``"pt_br"``). Se None, usa ``"pt_br"``.
+    """
+    parsed_level = InsultLevel.from_str(level) if level is not None else _default_level
+    lang = lang if lang is not None else _default_lang
+
+    provider = get_provider(lang)
+    messages = provider.get_messages(status_code, parsed_level)
+
+    if not messages:
+        if parsed_level is None:
+            messages = []
+            for lvl in InsultLevel:
+                messages.extend(provider.catalog.default_messages.get(lvl, []))
+        else:
+            messages = provider.catalog.default_messages.get(
+                parsed_level, ["Erro desconhecido."]
+            )
+
+    if not messages:
+        return f"Status {status_code}: sem mensagem disponível."
+    return random.choice(messages)
+
+
+def random_insult(
+    *,
+    level: Optional[str] = None,
+    lang: Optional[str] = None,
+) -> str:
+    """
+    Retorna uma mensagem aleatória de qualquer status code disponível.
+
+    Args:
+        level: Nível de severidade (``"light"``, ``"medium"``, ``"heavy"``).
+            Se None, usa TODOS os níveis.
+        lang: Idioma (ex: ``"pt_br"``). Se None, usa ``"pt_br"``.
+    """
+    parsed_level = InsultLevel.from_str(level) if level is not None else _default_level
+    lang = lang if lang is not None else _default_lang
+
+    provider = get_provider(lang)
+    catalog = provider.catalog
+
+    # Coleta todas as mensagens
+    all_msgs: list[str] = []
+    if parsed_level is None:
+        for code_msgs in catalog.messages.values():
+            for lvl in InsultLevel:
+                all_msgs.extend(code_msgs.get(lvl, []))
+    else:
+        for code_msgs in catalog.messages.values():
+            all_msgs.extend(code_msgs.get(parsed_level, []))
+
+    if not all_msgs:
+        if parsed_level is None:
+            for lvl in InsultLevel:
+                all_msgs.extend(catalog.default_messages.get(lvl, []))
+        else:
+            all_msgs = catalog.default_messages.get(parsed_level, ["Nada a declarar."])
+    return random.choice(all_msgs)

codeinsult-0.1.0/codeinsult/__init__.py

@@ -0,0 +1,13 @@
+# codeinsult/__init__.py
+import codeinsult.messages.pt_br  # noqa: F401, F811
+from codeinsult.__version__ import __version__
+from codeinsult.CodeInsult import insult, random_insult, set_defaults
+from codeinsult.messages.registry import available_languages
+
+__all__ = [
+    "__version__",
+    "insult",
+    "random_insult",
+    "set_defaults",
+    "available_languages",
+]

codeinsult-0.1.0/codeinsult/__version__.py

@@ -0,0 +1,4 @@
+# codeinsult/__version__.py
+# coding: utf-8
+
+__version__ = "0.1.0"

codeinsult-0.1.0/codeinsult/config.py

@@ -0,0 +1,33 @@
+from enum import Enum
+from typing import Optional
+
+
+class InsultLevel(Enum):
+    """
+    Níveis de severidade das mensagens.
+
+    LIGHT  — Referências leves a filmes, séries, livros, memes. Sem palavrões.
+    MEDIUM — Sarcasmo e ironia. Pode conter linguagem levemente ofensiva.
+    HEAVY  — Insultos pesados, com palavrões e xingamentos explícitos.
+    """
+
+    LIGHT = "light"
+    MEDIUM = "medium"
+    HEAVY = "heavy"
+
+    @classmethod
+    def from_str(cls, level: Optional[str]) -> Optional["InsultLevel"]:
+        """
+        Converte uma string para ``InsultLevel``.
+
+        Aceita ``"light"``, ``"medium"``, ``"heavy"``.
+        ``None`` retorna ``None``.
+        """
+        if level is None:
+            return None
+        try:
+            return cls(level.lower())
+        except ValueError:
+            raise ValueError(
+                f"Nível '{level}' inválido. Use: light, medium, heavy."
+            ) from None

codeinsult-0.1.0/codeinsult/messages/__init__.py

@@ -0,0 +1,4 @@
+# codeinsult/messages/__init__.py
+from codeinsult.messages.base import BaseMessageProvider, MessageCatalog
+
+__all__ = ["BaseMessageProvider", "MessageCatalog"]

codeinsult-0.1.0/codeinsult/messages/base.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from codeinsult.config import InsultLevel
+
+
+@dataclass
+class MessageCatalog:
+    """
+    Catálogo de mensagens para um idioma.
+
+    Estrutura:
+        messages[status_code][InsultLevel] = [lista de frases]
+    """
+
+    lang: str
+    lang_name: str
+    messages: Dict[int, Dict[InsultLevel, List[str]]] = field(default_factory=dict)
+    default_messages: Dict[InsultLevel, List[str]] = field(default_factory=dict)
+
+    def get_messages(self, status_code: int, level: Optional[InsultLevel]) -> List[str]:
+        """
+        Retorna as mensagens para um status code e nível.
+        Se level for None, retorna mensagens de TODOS os níveis.
+        Se não houver mensagens específicas, retorna as padrão.
+        """
+        if level is None:
+            # Coleta mensagens de todos os níveis
+            code_msgs = self.messages.get(status_code, {})
+            msgs: List[str] = []
+            for lvl in InsultLevel:
+                msgs.extend(code_msgs.get(lvl, []))
+            if not msgs:
+                for lvl in InsultLevel:
+                    msgs.extend(self.default_messages.get(lvl, []))
+            return msgs
+
+        code_msgs = self.messages.get(status_code, {})
+        msgs = code_msgs.get(level, [])
+        if not msgs:
+            msgs = self.default_messages.get(level, [])
+        return msgs
+
+    def has_messages(self, status_code: int, level: Optional[InsultLevel]) -> bool:
+        """Verifica se existem mensagens para o status e nível."""
+        if level is None:
+            code_msgs = self.messages.get(status_code, {})
+            return any(code_msgs.get(lvl, []) for lvl in InsultLevel)
+        return bool(self.messages.get(status_code, {}).get(level, []))
+
+
+class BaseMessageProvider(ABC):
+    """
+    Provider abstrato — cada idioma implementa um provider concreto.
+
+    Para adicionar um novo idioma:
+
+        class EnUSProvider(BaseMessageProvider):
+            @property
+            def catalog(self) -> MessageCatalog:
+                return _EN_US_CATALOG
+    """
+
+    @property
+    @abstractmethod
+    def catalog(self) -> MessageCatalog:
+        """Retorna o catálogo de mensagens para este idioma."""
+        ...
+
+    @classmethod
+    @abstractmethod
+    def lang_code(cls) -> str:
+        """Código do idioma (ex: 'pt_BR', 'en_US')."""
+        ...
+
+    def get_messages(self, status_code: int, level: Optional[InsultLevel]) -> List[str]:
+        return self.catalog.get_messages(status_code, level)