kroxy 1.0.3__tar.gz → 1.0.4__tar.gz

{kroxy-1.0.3/kroxy.egg-info → kroxy-1.0.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: kroxy
-Version: 1.0.3
+Version: 1.0.4
 Summary: A powerful Python toolkit for building automation, integrations, and bots.
 Author-email: kroxy <kroxy@example.com>
 License-Expression: LicenseRef-Proprietary
 Project-URL: Homepage, https://pypi.org/project/kroxy
-Keywords: bot,automation,antinuke,giveaway,music,scraper,webhook,cache,moderation,toolkit
+Keywords: bot,automation,antinuke,giveaway,music,scraper,webhook,cache,moderation,roles,tickets,automod,seo,ratelimit,toolkit
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

{kroxy-1.0.3 → kroxy-1.0.4}/kroxy/__init__.py

@@ -7,7 +7,9 @@ All classes are available directly from the top-level `kroxy` namespace.
 
     import kroxy
     from kroxy import AntiNuke, Embed, Moderation, Cache, Webhook
+    from kroxy import RoleManager, TicketManager, AutoMod
     from kroxy import Fetcher, Scraper, WebUtils, Monitor
+    from kroxy import SEOAnalyzer, RateLimiter
     from kroxy import discord   # full discord submodule
     from kroxy import website   # full website submodule
 
@@ -17,7 +19,7 @@ Proprietary — Copyright (c) 2026 kroxy. All rights reserved.
 Unauthorized copying, modification, or redistribution is strictly prohibited.
 """
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 __author__ = "kroxy"
 __license__ = "Proprietary"
 __copyright__ = "Copyright (c) 2026 kroxy. All rights reserved."
@@ -39,12 +41,17 @@ from kroxy.discord.embed import Embed
 from kroxy.discord.logger import ModLogger
 from kroxy.discord.cache import Cache
 from kroxy.discord.webhook import Webhook
+from kroxy.discord.roles import RoleManager, RoleInfo
+from kroxy.discord.tickets import TicketManager, Ticket, TicketNote
+from kroxy.discord.automod import AutoMod, Violation
 
 # ── Website ────────────────────────────────────────────────────────────────────
 from kroxy.website.fetch import Fetcher
 from kroxy.website.scraper import Scraper
 from kroxy.website.utils import WebUtils
 from kroxy.website.monitor import Monitor, CheckResult
+from kroxy.website.seo import SEOAnalyzer, SEOReport, SEOIssue
+from kroxy.website.ratelimit import RateLimiter, RateLimitInfo
 
 __all__ = [
     # Submodules
@@ -73,6 +80,12 @@ __all__ = [
     "Cache",
     # Discord — Webhook
     "Webhook",
+    # Discord — Roles
+    "RoleManager", "RoleInfo",
+    # Discord — Tickets
+    "TicketManager", "Ticket", "TicketNote",
+    # Discord — AutoMod
+    "AutoMod", "Violation",
     # Website — Fetch
     "Fetcher",
     # Website — Scraper
@@ -81,4 +94,8 @@ __all__ = [
     "WebUtils",
     # Website — Monitor
     "Monitor", "CheckResult",
+    # Website — SEO
+    "SEOAnalyzer", "SEOReport", "SEOIssue",
+    # Website — Rate Limiter
+    "RateLimiter", "RateLimitInfo",
 ]

{kroxy-1.0.3 → kroxy-1.0.4}/kroxy/discord/__init__.py

@@ -14,6 +14,9 @@ from kroxy.discord.embed import Embed
 from kroxy.discord.logger import ModLogger
 from kroxy.discord.cache import Cache
 from kroxy.discord.webhook import Webhook
+from kroxy.discord.roles import RoleManager, RoleInfo
+from kroxy.discord.tickets import TicketManager, Ticket, TicketNote
+from kroxy.discord.automod import AutoMod, Violation
 
 __all__ = [
     "DiscordAPI",
@@ -28,4 +31,7 @@ __all__ = [
     "ModLogger",
     "Cache",
     "Webhook",
+    "RoleManager", "RoleInfo",
+    "TicketManager", "Ticket", "TicketNote",
+    "AutoMod", "Violation",
 ]

kroxy-1.0.4/kroxy/discord/automod.py

@@ -0,0 +1,488 @@
+"""
+kroxy.discord.automod - Discord message auto-moderation filters.
+"""
+
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+
+@dataclass
+class Violation:
+    user_id: int
+    rule: str
+    content: str
+    timestamp: float = field(default_factory=time.time)
+
+    def to_dict(self) -> Dict:
+        return {
+            "user_id": self.user_id,
+            "rule": self.rule,
+            "content": self.content[:200],
+            "timestamp": self.timestamp,
+        }
+
+
+class AutoMod:
+    """
+    Client-side Discord auto-moderation engine.
+
+    Checks messages against configurable rules:
+    - Blocked words and phrases
+    - Regex patterns
+    - Invite links
+    - Excessive caps
+    - Mass mentions
+    - Emoji spam
+    - Repeated messages (spam)
+    - Link blacklist / whitelist
+
+    Usage:
+        from kroxy import AutoMod
+
+        mod = AutoMod()
+        mod.add_blocked_word("badword")
+        mod.set_caps_threshold(70)
+        mod.set_mention_limit(5)
+
+        result = mod.scan_message(user_id=123, content="HEY @everyone!!!")
+        if result["flagged"]:
+            print(result["reasons"])
+    """
+
+    def __init__(self):
+        self._blocked_words: Set[str] = set()
+        self._blocked_patterns: List[re.Pattern] = []
+        self._link_blacklist: Set[str] = set()
+        self._link_whitelist: Set[str] = set()
+        self._exempt_roles: Set[int] = set()
+        self._exempt_channels: Set[int] = set()
+        self._caps_threshold: int = 70
+        self._mention_limit: int = 5
+        self._emoji_limit: int = 10
+        self._spam_window: int = 5
+        self._spam_limit: int = 5
+        self._violations: List[Violation] = []
+        self._recent_messages: Dict[int, List[float]] = {}
+        self._invite_pattern = re.compile(
+            r"discord(?:\.gg|app\.com/invite|\.com/invite)/[\w-]+", re.IGNORECASE
+        )
+        self._url_pattern = re.compile(
+            r"https?://([a-zA-Z0-9.-]+)", re.IGNORECASE
+        )
+        self._emoji_pattern = re.compile(
+            r"<a?:[a-zA-Z0-9_]+:\d+>|[\U00010000-\U0010ffff]", re.UNICODE
+        )
+
+    # ── Blocked words ──────────────────────────────────────────────────────────
+
+    def add_blocked_word(self, word: str) -> None:
+        """
+        Add a word or phrase to the block list (case-insensitive).
+
+        Args:
+            word: Word or phrase to block.
+        """
+        self._blocked_words.add(word.lower().strip())
+
+    def remove_blocked_word(self, word: str) -> bool:
+        """
+        Remove a word from the block list.
+
+        Returns:
+            True if removed, False if it wasn't in the list.
+        """
+        word = word.lower().strip()
+        if word in self._blocked_words:
+            self._blocked_words.discard(word)
+            return True
+        return False
+
+    def add_blocked_words(self, words: List[str]) -> None:
+        """Add multiple words to the block list at once."""
+        for word in words:
+            self.add_blocked_word(word)
+
+    def clear_blocked_words(self) -> None:
+        """Remove all blocked words."""
+        self._blocked_words.clear()
+
+    def check_blocked_words(self, content: str) -> List[str]:
+        """
+        Check a message for blocked words.
+
+        Returns:
+            List of matched blocked words (empty if none found).
+        """
+        lower = content.lower()
+        return [w for w in self._blocked_words if w in lower]
+
+    # ── Regex patterns ─────────────────────────────────────────────────────────
+
+    def add_blocked_pattern(self, pattern: str, flags: int = re.IGNORECASE) -> None:
+        """
+        Add a regex pattern to the block list.
+
+        Args:
+            pattern: Regex pattern string.
+            flags: Regex flags (default: re.IGNORECASE).
+        """
+        self._blocked_patterns.append(re.compile(pattern, flags))
+
+    def clear_blocked_patterns(self) -> None:
+        """Remove all blocked regex patterns."""
+        self._blocked_patterns.clear()
+
+    def check_patterns(self, content: str) -> List[str]:
+        """
+        Check a message against all blocked regex patterns.
+
+        Returns:
+            List of matched pattern strings (empty if none found).
+        """
+        matched = []
+        for pattern in self._blocked_patterns:
+            if pattern.search(content):
+                matched.append(pattern.pattern)
+        return matched
+
+    # ── Invite links ───────────────────────────────────────────────────────────
+
+    def is_invite_link(self, content: str) -> bool:
+        """
+        Check if a message contains a Discord invite link.
+
+        Returns:
+            True if an invite link is detected.
+        """
+        return bool(self._invite_pattern.search(content))
+
+    def strip_invites(self, content: str) -> str:
+        """
+        Remove Discord invite links from a message.
+
+        Returns:
+            Cleaned message string.
+        """
+        return self._invite_pattern.sub("[invite removed]", content)
+
+    # ── Caps check ─────────────────────────────────────────────────────────────
+
+    def set_caps_threshold(self, percent: int) -> None:
+        """
+        Set the uppercase-character percentage that triggers the caps filter.
+
+        Args:
+            percent: Integer 0–100. Default is 70.
+        """
+        self._caps_threshold = max(0, min(100, percent))
+
+    def check_caps(self, content: str, min_length: int = 8) -> bool:
+        """
+        Check if a message exceeds the caps threshold.
+
+        Args:
+            content: Message text.
+            min_length: Minimum message length to apply the rule (default 8).
+
+        Returns:
+            True if the message is flagged for excessive caps.
+        """
+        letters = [c for c in content if c.isalpha()]
+        if len(letters) < min_length:
+            return False
+        upper_pct = (sum(1 for c in letters if c.isupper()) / len(letters)) * 100
+        return upper_pct >= self._caps_threshold
+
+    def caps_percentage(self, content: str) -> float:
+        """
+        Calculate the uppercase percentage of a message.
+
+        Returns:
+            Float 0.0–100.0, or 0.0 if no alphabetic characters.
+        """
+        letters = [c for c in content if c.isalpha()]
+        if not letters:
+            return 0.0
+        return round((sum(1 for c in letters if c.isupper()) / len(letters)) * 100, 1)
+
+    # ── Mention spam ───────────────────────────────────────────────────────────
+
+    def set_mention_limit(self, limit: int) -> None:
+        """
+        Set the maximum number of unique @mentions allowed per message.
+
+        Args:
+            limit: Maximum mention count. Default is 5.
+        """
+        self._mention_limit = max(1, limit)
+
+    def count_mentions(self, content: str) -> int:
+        """
+        Count the number of @user and @role mentions in a message.
+
+        Returns:
+            Integer mention count.
+        """
+        return len(re.findall(r"<@[!&]?\d+>|@everyone|@here", content))
+
+    def check_mentions(self, content: str) -> bool:
+        """
+        Check if a message exceeds the mention limit.
+
+        Returns:
+            True if flagged for mass mentions.
+        """
+        return self.count_mentions(content) > self._mention_limit
+
+    # ── Emoji spam ─────────────────────────────────────────────────────────────
+
+    def set_emoji_limit(self, limit: int) -> None:
+        """
+        Set the maximum number of emojis allowed per message.
+
+        Args:
+            limit: Maximum emoji count. Default is 10.
+        """
+        self._emoji_limit = max(1, limit)
+
+    def count_emojis(self, content: str) -> int:
+        """
+        Count the number of emojis (custom + Unicode) in a message.
+
+        Returns:
+            Integer emoji count.
+        """
+        return len(self._emoji_pattern.findall(content))
+
+    def check_emojis(self, content: str) -> bool:
+        """
+        Check if a message exceeds the emoji limit.
+
+        Returns:
+            True if flagged for emoji spam.
+        """
+        return self.count_emojis(content) > self._emoji_limit
+
+    # ── Message spam ───────────────────────────────────────────────────────────
+
+    def set_spam_threshold(self, messages: int, window: int = 5) -> None:
+        """
+        Set the spam detection threshold.
+
+        Args:
+            messages: Max messages allowed within the time window.
+            window: Time window in seconds (default 5).
+        """
+        self._spam_limit = max(1, messages)
+        self._spam_window = max(1, window)
+
+    def check_spam(self, user_id: int) -> bool:
+        """
+        Track a message from a user and detect if they are spamming.
+
+        Call this once per message received from the user.
+
+        Returns:
+            True if the user is sending messages faster than the spam threshold.
+        """
+        now = time.time()
+        if user_id not in self._recent_messages:
+            self._recent_messages[user_id] = []
+        self._recent_messages[user_id] = [
+            t for t in self._recent_messages[user_id] if now - t < self._spam_window
+        ]
+        self._recent_messages[user_id].append(now)
+        return len(self._recent_messages[user_id]) > self._spam_limit
+
+    def reset_spam_counter(self, user_id: int) -> None:
+        """Reset the spam counter for a specific user."""
+        self._recent_messages.pop(user_id, None)
+
+    # ── Link filtering ─────────────────────────────────────────────────────────
+
+    def add_link_blacklist(self, domain: str) -> None:
+        """Add a domain to the link blacklist (e.g. 'phishing.com')."""
+        self._link_blacklist.add(domain.lower().strip())
+
+    def add_link_whitelist(self, domain: str) -> None:
+        """Add a domain to the link whitelist (always allowed)."""
+        self._link_whitelist.add(domain.lower().strip())
+
+    def check_links(self, content: str) -> List[str]:
+        """
+        Check a message for blacklisted domains.
+
+        Returns:
+            List of matched blacklisted domains found in the message.
+        """
+        domains = [m.group(1).lower() for m in self._url_pattern.finditer(content)]
+        flagged = []
+        for domain in domains:
+            if domain in self._whitelist_check(domain):
+                continue
+            for blocked in self._link_blacklist:
+                if domain.endswith(blocked) and domain not in self._link_whitelist:
+                    flagged.append(domain)
+                    break
+        return flagged
+
+    def _whitelist_check(self, domain: str) -> Set[str]:
+        return self._link_whitelist if domain in self._link_whitelist else set()
+
+    # ── Exempt roles / channels ────────────────────────────────────────────────
+
+    def add_exempt_role(self, role_id: int) -> None:
+        """Mark a role as exempt from all AutoMod checks."""
+        self._exempt_roles.add(role_id)
+
+    def remove_exempt_role(self, role_id: int) -> None:
+        """Remove a role from the exempt list."""
+        self._exempt_roles.discard(role_id)
+
+    def add_exempt_channel(self, channel_id: int) -> None:
+        """Mark a channel as exempt from all AutoMod checks."""
+        self._exempt_channels.add(channel_id)
+
+    def remove_exempt_channel(self, channel_id: int) -> None:
+        """Remove a channel from the exempt list."""
+        self._exempt_channels.discard(channel_id)
+
+    def is_exempt(self, channel_id: int = None, role_ids: List[int] = None) -> bool:
+        """
+        Check if a channel or any of the provided role IDs are exempt.
+
+        Returns:
+            True if the message source is exempt from AutoMod.
+        """
+        if channel_id and channel_id in self._exempt_channels:
+            return True
+        if role_ids:
+            for rid in role_ids:
+                if rid in self._exempt_roles:
+                    return True
+        return False
+
+    # ── Violation log ──────────────────────────────────────────────────────────
+
+    def _log_violation(self, user_id: int, rule: str, content: str) -> None:
+        self._violations.append(Violation(user_id=user_id, rule=rule, content=content))
+        if len(self._violations) > 1000:
+            self._violations = self._violations[-1000:]
+
+    def get_violations(self, user_id: int = None) -> List[Violation]:
+        """
+        Get the violation log.
+
+        Args:
+            user_id: Filter by specific user (optional).
+
+        Returns:
+            List of Violation objects.
+        """
+        if user_id is not None:
+            return [v for v in self._violations if v.user_id == user_id]
+        return list(self._violations)
+
+    def clear_violations(self, user_id: int = None) -> int:
+        """
+        Clear violations from the log.
+
+        Args:
+            user_id: If provided, clear only violations for this user.
+
+        Returns:
+            Number of violations removed.
+        """
+        if user_id is not None:
+            before = len(self._violations)
+            self._violations = [v for v in self._violations if v.user_id != user_id]
+            return before - len(self._violations)
+        count = len(self._violations)
+        self._violations.clear()
+        return count
+
+    def violation_count(self, user_id: int) -> int:
+        """Return how many violations a user has logged."""
+        return sum(1 for v in self._violations if v.user_id == user_id)
+
+    # ── All-in-one scanner ─────────────────────────────────────────────────────
+
+    def scan_message(
+        self,
+        user_id: int,
+        content: str,
+        channel_id: int = None,
+        role_ids: List[int] = None,
+        check_spam: bool = True,
+    ) -> Dict:
+        """
+        Run all AutoMod checks on a message in one call.
+
+        Args:
+            user_id: Author's Discord user ID.
+            content: Message content string.
+            channel_id: Channel ID (for exemption checks).
+            role_ids: Author's role IDs (for exemption checks).
+            check_spam: Whether to run the message-rate spam check.
+
+        Returns:
+            Dict with:
+                - flagged (bool): True if any rule was violated.
+                - reasons (List[str]): List of rule names that triggered.
+                - details (Dict): Extra detail per rule.
+        """
+        if self.is_exempt(channel_id=channel_id, role_ids=role_ids):
+            return {"flagged": False, "reasons": [], "details": {}, "exempt": True}
+
+        reasons = []
+        details: Dict = {}
+
+        blocked = self.check_blocked_words(content)
+        if blocked:
+            reasons.append("blocked_word")
+            details["blocked_words"] = blocked
+            self._log_violation(user_id, "blocked_word", content)
+
+        patterns = self.check_patterns(content)
+        if patterns:
+            reasons.append("blocked_pattern")
+            details["patterns"] = patterns
+            self._log_violation(user_id, "blocked_pattern", content)
+
+        if self.is_invite_link(content):
+            reasons.append("invite_link")
+            self._log_violation(user_id, "invite_link", content)
+
+        if self.check_caps(content):
+            reasons.append("excessive_caps")
+            details["caps_pct"] = self.caps_percentage(content)
+            self._log_violation(user_id, "excessive_caps", content)
+
+        if self.check_mentions(content):
+            reasons.append("mass_mention")
+            details["mention_count"] = self.count_mentions(content)
+            self._log_violation(user_id, "mass_mention", content)
+
+        if self.check_emojis(content):
+            reasons.append("emoji_spam")
+            details["emoji_count"] = self.count_emojis(content)
+            self._log_violation(user_id, "emoji_spam", content)
+
+        bad_links = self.check_links(content)
+        if bad_links:
+            reasons.append("blacklisted_link")
+            details["domains"] = bad_links
+            self._log_violation(user_id, "blacklisted_link", content)
+
+        if check_spam and self.check_spam(user_id):
+            reasons.append("message_spam")
+            self._log_violation(user_id, "message_spam", content)
+
+        return {
+            "flagged": bool(reasons),
+            "reasons": reasons,
+            "details": details,
+            "exempt": False,
+        }