kroxy 0.1.0__tar.gz

kroxy-0.1.0/LICENSE

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

kroxy-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include kroxy *.py

kroxy-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: kroxy
+Version: 0.1.0
+Summary: A professional Discord utility library by @kroxy
+Author-email: kroxy <kroxy@example.com>
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/kroxy
+Project-URL: Repository, https://github.com/kroxy/kroxy
+Keywords: discord,bot,antinuke,giveaway,music,utility
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# kroxy
+
+A professional Discord utility library by **@kroxy**.
+
+## Install
+
+```bash
+pip install kroxy
+```
+
+## Modules
+
+### `kroxy.discord`
+
+| Module | Description |
+|---|---|
+| `api` | Async Discord REST API client |
+| `commands` | Slash & prefix command builders |
+| `utils` | Embed builder, mentions, timestamps, permissions |
+| `antinuke` | Anti-nuke protection with rate-limit tracking |
+| `checkers` | Permission & role checks with hierarchy validation |
+| `giveaway` | Full-featured weighted giveaway system |
+| `music` | Queue-based music player state manager |
+
+### `kroxy.website` *(coming soon)*
+
+---
+
+## Quick Examples
+
+### Anti-Nuke
+
+```python
+from kroxy.discord import AntiNuke
+
+antinuke = AntiNuke(whitelist=[OWNER_ID])
+
+async def punish(action, user_id, guild):
+    print(f"NUKE DETECTED: {action} by {user_id}")
+
+antinuke.on_trigger = punish
+antinuke.punishment = "ban"
+
+# In your event handler:
+await antinuke.on_member_ban(user_id=some_user_id, guild=guild)
+```
+
+### Giveaway
+
+```python
+from kroxy.discord.giveaway import GiveawayManager
+
+manager = GiveawayManager()
+
+async def on_giveaway_end(giveaway, winners):
+    print(f"Winners of {giveaway.prize}: {winners}")
+
+manager.on_end = on_giveaway_end
+
+giveaway = await manager.create(
+    prize="Discord Nitro",
+    host_id=123456789,
+    channel_id=987654321,
+    guild_id=111111111,
+    duration=3600,     # 1 hour
+    winner_count=2,
+)
+```
+
+### Embed Builder
+
+```python
+from kroxy.discord import Utils
+
+embed = Utils.build_embed(
+    title="Hello from kroxy!",
+    description="This is a professional embed.",
+    color=0x5865F2,
+    fields=[{"name": "Field", "value": "Value", "inline": True}],
+    footer="kroxy library",
+    timestamp=True,
+)
+```
+
+### Slash Command
+
+```python
+from kroxy.discord.commands import SlashCommand, Option
+
+@SlashCommand.decorator(
+    name="ping",
+    description="Check bot latency",
+)
+async def ping(interaction):
+    await interaction.response.send_message("Pong!")
+```
+
+### Music Player
+
+```python
+from kroxy.discord.music import MusicPlayerManager, Track
+
+manager = MusicPlayerManager()
+player = manager.get_or_create(guild_id=111111111, channel_id=222222222)
+
+track = Track(
+    title="My Song",
+    url="https://youtube.com/...",
+    stream_url="https://...",
+    duration=240,
+    requester_id=123456789,
+)
+player.queue.add(track)
+await player.play_next()
+```
+
+---
+
+## License
+
+MIT © kroxy

kroxy-0.1.0/README.md

@@ -0,0 +1,121 @@
+# kroxy
+
+A professional Discord utility library by **@kroxy**.
+
+## Install
+
+```bash
+pip install kroxy
+```
+
+## Modules
+
+### `kroxy.discord`
+
+| Module | Description |
+|---|---|
+| `api` | Async Discord REST API client |
+| `commands` | Slash & prefix command builders |
+| `utils` | Embed builder, mentions, timestamps, permissions |
+| `antinuke` | Anti-nuke protection with rate-limit tracking |
+| `checkers` | Permission & role checks with hierarchy validation |
+| `giveaway` | Full-featured weighted giveaway system |
+| `music` | Queue-based music player state manager |
+
+### `kroxy.website` *(coming soon)*
+
+---
+
+## Quick Examples
+
+### Anti-Nuke
+
+```python
+from kroxy.discord import AntiNuke
+
+antinuke = AntiNuke(whitelist=[OWNER_ID])
+
+async def punish(action, user_id, guild):
+    print(f"NUKE DETECTED: {action} by {user_id}")
+
+antinuke.on_trigger = punish
+antinuke.punishment = "ban"
+
+# In your event handler:
+await antinuke.on_member_ban(user_id=some_user_id, guild=guild)
+```
+
+### Giveaway
+
+```python
+from kroxy.discord.giveaway import GiveawayManager
+
+manager = GiveawayManager()
+
+async def on_giveaway_end(giveaway, winners):
+    print(f"Winners of {giveaway.prize}: {winners}")
+
+manager.on_end = on_giveaway_end
+
+giveaway = await manager.create(
+    prize="Discord Nitro",
+    host_id=123456789,
+    channel_id=987654321,
+    guild_id=111111111,
+    duration=3600,     # 1 hour
+    winner_count=2,
+)
+```
+
+### Embed Builder
+
+```python
+from kroxy.discord import Utils
+
+embed = Utils.build_embed(
+    title="Hello from kroxy!",
+    description="This is a professional embed.",
+    color=0x5865F2,
+    fields=[{"name": "Field", "value": "Value", "inline": True}],
+    footer="kroxy library",
+    timestamp=True,
+)
+```
+
+### Slash Command
+
+```python
+from kroxy.discord.commands import SlashCommand, Option
+
+@SlashCommand.decorator(
+    name="ping",
+    description="Check bot latency",
+)
+async def ping(interaction):
+    await interaction.response.send_message("Pong!")
+```
+
+### Music Player
+
+```python
+from kroxy.discord.music import MusicPlayerManager, Track
+
+manager = MusicPlayerManager()
+player = manager.get_or_create(guild_id=111111111, channel_id=222222222)
+
+track = Track(
+    title="My Song",
+    url="https://youtube.com/...",
+    stream_url="https://...",
+    duration=240,
+    requester_id=123456789,
+)
+player.queue.add(track)
+await player.play_next()
+```
+
+---
+
+## License
+
+MIT © kroxy

kroxy-0.1.0/kroxy/__init__.py

@@ -0,0 +1,13 @@
+"""
+kroxy - A professional Python utility library.
+Author: @kroxy
+"""
+
+__version__ = "0.1.0"
+__author__ = "kroxy"
+__license__ = "MIT"
+
+from kroxy import discord
+from kroxy import website
+
+__all__ = ["discord", "website"]

kroxy-0.1.0/kroxy/discord/__init__.py

@@ -0,0 +1,22 @@
+"""
+kroxy.discord - Professional Discord utilities and helpers.
+"""
+
+from kroxy.discord.api import DiscordAPI
+from kroxy.discord.commands import SlashCommand, PrefixCommand
+from kroxy.discord.utils import Utils
+from kroxy.discord.antinuke import AntiNuke
+from kroxy.discord.checkers import Checkers
+from kroxy.discord.giveaway import Giveaway
+from kroxy.discord.music import MusicPlayer
+
+__all__ = [
+    "DiscordAPI",
+    "SlashCommand",
+    "PrefixCommand",
+    "Utils",
+    "AntiNuke",
+    "Checkers",
+    "Giveaway",
+    "MusicPlayer",
+]

kroxy-0.1.0/kroxy/discord/antinuke.py

@@ -0,0 +1,146 @@
+"""
+kroxy.discord.antinuke - Anti-nuke protection system for Discord servers.
+"""
+
+import asyncio
+import time
+from collections import defaultdict
+from typing import Dict, List, Optional, Callable, Any
+
+
+class ActionLog:
+    """Tracks recent actions per user for rate-limit detection."""
+
+    def __init__(self, threshold: int, window: int):
+        self.threshold = threshold
+        self.window = window  # seconds
+        self._log: Dict[int, List[float]] = defaultdict(list)
+
+    def record(self, user_id: int) -> int:
+        """Record an action and return the count within the window."""
+        now = time.time()
+        self._log[user_id] = [t for t in self._log[user_id] if now - t < self.window]
+        self._log[user_id].append(now)
+        return len(self._log[user_id])
+
+    def exceeded(self, user_id: int) -> bool:
+        """Return True if the user has exceeded the threshold."""
+        return self.record(user_id) >= self.threshold
+
+    def reset(self, user_id: int):
+        self._log.pop(user_id, None)
+
+
+class AntiNuke:
+    """
+    Anti-nuke system that monitors destructive actions and auto-punishes abusers.
+
+    Usage:
+        antinuke = AntiNuke(bot, whitelist=[owner_id])
+        antinuke.on_trigger = my_punishment_callback
+    """
+
+    DEFAULT_LIMITS = {
+        "ban": (3, 10),           # 3 bans in 10s
+        "kick": (3, 10),
+        "channel_delete": (3, 10),
+        "channel_create": (5, 10),
+        "role_delete": (3, 10),
+        "role_create": (5, 10),
+        "webhook_create": (3, 10),
+        "webhook_delete": (3, 10),
+        "invite_delete": (5, 10),
+        "mass_mention": (5, 5),
+        "bot_add": (2, 30),
+    }
+
+    def __init__(self, whitelist: List[int] = None, limits: Dict = None):
+        self.whitelist: List[int] = whitelist or []
+        limits = limits or {}
+        merged = {**self.DEFAULT_LIMITS, **limits}
+        self._trackers: Dict[str, ActionLog] = {
+            action: ActionLog(threshold, window)
+            for action, (threshold, window) in merged.items()
+        }
+        self._punished: set = set()
+        self.on_trigger: Optional[Callable] = None
+        self.punishment: str = "ban"  # "ban" | "kick" | "strip_roles"
+
+    def is_whitelisted(self, user_id: int) -> bool:
+        return user_id in self.whitelist
+
+    def add_whitelist(self, user_id: int):
+        if user_id not in self.whitelist:
+            self.whitelist.append(user_id)
+
+    def remove_whitelist(self, user_id: int):
+        self.whitelist = [u for u in self.whitelist if u != user_id]
+
+    async def check(self, action: str, user_id: int, guild: Any = None) -> bool:
+        """
+        Check an action for a user. Returns True if limit exceeded.
+        Calls self.on_trigger(action, user_id, guild) if set.
+        """
+        if self.is_whitelisted(user_id):
+            return False
+        if user_id in self._punished:
+            return True
+
+        tracker = self._trackers.get(action)
+        if tracker is None:
+            return False
+
+        if tracker.exceeded(user_id):
+            self._punished.add(user_id)
+            if self.on_trigger:
+                try:
+                    await self.on_trigger(action=action, user_id=user_id, guild=guild)
+                except Exception:
+                    pass
+            return True
+        return False
+
+    def reset_user(self, user_id: int):
+        """Clear all action logs and punishment flag for a user."""
+        for tracker in self._trackers.values():
+            tracker.reset(user_id)
+        self._punished.discard(user_id)
+
+    def get_stats(self) -> Dict:
+        """Return current limits configuration."""
+        return {
+            action: {"threshold": t.threshold, "window": t.window}
+            for action, t in self._trackers.items()
+        }
+
+    # ── Convenience event handlers (wire these to your event system) ──────────
+
+    async def on_member_ban(self, user_id: int, guild: Any = None):
+        return await self.check("ban", user_id, guild)
+
+    async def on_member_kick(self, user_id: int, guild: Any = None):
+        return await self.check("kick", user_id, guild)
+
+    async def on_channel_delete(self, user_id: int, guild: Any = None):
+        return await self.check("channel_delete", user_id, guild)
+
+    async def on_channel_create(self, user_id: int, guild: Any = None):
+        return await self.check("channel_create", user_id, guild)
+
+    async def on_role_delete(self, user_id: int, guild: Any = None):
+        return await self.check("role_delete", user_id, guild)
+
+    async def on_role_create(self, user_id: int, guild: Any = None):
+        return await self.check("role_create", user_id, guild)
+
+    async def on_webhook_create(self, user_id: int, guild: Any = None):
+        return await self.check("webhook_create", user_id, guild)
+
+    async def on_webhook_delete(self, user_id: int, guild: Any = None):
+        return await self.check("webhook_delete", user_id, guild)
+
+    async def on_bot_add(self, user_id: int, guild: Any = None):
+        return await self.check("bot_add", user_id, guild)
+
+    async def on_mass_mention(self, user_id: int, guild: Any = None):
+        return await self.check("mass_mention", user_id, guild)

kroxy-0.1.0/kroxy/discord/api.py

@@ -0,0 +1,128 @@
+"""
+kroxy.discord.api - Discord REST API wrapper helpers.
+"""
+
+import aiohttp
+import asyncio
+from typing import Optional, Any, Dict
+
+DISCORD_API_BASE = "https://discord.com/api/v10"
+
+
+class DiscordAPI:
+    """Async Discord REST API client."""
+
+    def __init__(self, token: str, bot: bool = True):
+        prefix = "Bot" if bot else "Bearer"
+        self.headers = {
+            "Authorization": f"{prefix} {token}",
+            "Content-Type": "application/json",
+        }
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(headers=self.headers)
+        return self._session
+
+    async def close(self):
+        """Close the underlying HTTP session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def request(self, method: str, endpoint: str, **kwargs) -> Any:
+        """Make a raw API request."""
+        session = await self._get_session()
+        url = f"{DISCORD_API_BASE}{endpoint}"
+        async with session.request(method, url, **kwargs) as resp:
+            resp.raise_for_status()
+            return await resp.json()
+
+    async def get_guild(self, guild_id: int) -> Dict:
+        """Fetch a guild by ID."""
+        return await self.request("GET", f"/guilds/{guild_id}")
+
+    async def get_channel(self, channel_id: int) -> Dict:
+        """Fetch a channel by ID."""
+        return await self.request("GET", f"/channels/{channel_id}")
+
+    async def get_user(self, user_id: int) -> Dict:
+        """Fetch a user by ID."""
+        return await self.request("GET", f"/users/{user_id}")
+
+    async def send_message(self, channel_id: int, content: str = None,
+                           embed: Dict = None, components: list = None) -> Dict:
+        """Send a message to a channel."""
+        payload: Dict[str, Any] = {}
+        if content:
+            payload["content"] = content
+        if embed:
+            payload["embeds"] = [embed]
+        if components:
+            payload["components"] = components
+        return await self.request("POST", f"/channels/{channel_id}/messages", json=payload)
+
+    async def delete_message(self, channel_id: int, message_id: int) -> None:
+        """Delete a message."""
+        await self.request("DELETE", f"/channels/{channel_id}/messages/{message_id}")
+
+    async def ban_member(self, guild_id: int, user_id: int,
+                         reason: str = None, delete_message_days: int = 0) -> None:
+        """Ban a member from a guild."""
+        payload = {"delete_message_days": delete_message_days}
+        headers = {}
+        if reason:
+            headers["X-Audit-Log-Reason"] = reason
+        await self.request("PUT", f"/guilds/{guild_id}/bans/{user_id}",
+                           json=payload, headers=headers)
+
+    async def unban_member(self, guild_id: int, user_id: int) -> None:
+        """Unban a member."""
+        await self.request("DELETE", f"/guilds/{guild_id}/bans/{user_id}")
+
+    async def kick_member(self, guild_id: int, user_id: int, reason: str = None) -> None:
+        """Kick a member from a guild."""
+        headers = {}
+        if reason:
+            headers["X-Audit-Log-Reason"] = reason
+        await self.request("DELETE", f"/guilds/{guild_id}/members/{user_id}",
+                           headers=headers)
+
+    async def add_role(self, guild_id: int, user_id: int, role_id: int) -> None:
+        """Add a role to a member."""
+        await self.request("PUT", f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def remove_role(self, guild_id: int, user_id: int, role_id: int) -> None:
+        """Remove a role from a member."""
+        await self.request("DELETE", f"/guilds/{guild_id}/members/{user_id}/roles/{role_id}")
+
+    async def create_channel(self, guild_id: int, name: str,
+                             channel_type: int = 0, **kwargs) -> Dict:
+        """Create a guild channel."""
+        payload = {"name": name, "type": channel_type, **kwargs}
+        return await self.request("POST", f"/guilds/{guild_id}/channels", json=payload)
+
+    async def delete_channel(self, channel_id: int) -> Dict:
+        """Delete a channel."""
+        return await self.request("DELETE", f"/channels/{channel_id}")
+
+    async def get_audit_logs(self, guild_id: int, limit: int = 50) -> Dict:
+        """Fetch guild audit logs."""
+        return await self.request("GET", f"/guilds/{guild_id}/audit-logs",
+                                  params={"limit": limit})
+
+    async def get_invites(self, guild_id: int) -> list:
+        """Get all guild invites."""
+        return await self.request("GET", f"/guilds/{guild_id}/invites")
+
+    async def delete_invite(self, invite_code: str) -> None:
+        """Delete an invite by code."""
+        await self.request("DELETE", f"/invites/{invite_code}")
+
+    async def get_webhooks(self, guild_id: int) -> list:
+        """Get all webhooks in a guild."""
+        return await self.request("GET", f"/guilds/{guild_id}/webhooks")
+
+    async def delete_webhook(self, webhook_id: int) -> None:
+        """Delete a webhook."""
+        await self.request("DELETE", f"/webhooks/{webhook_id}")