entscheidomat-decision-kit 1.0.0__tar.gz

entscheidomat_decision_kit-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: entscheidomat-decision-kit
+Version: 1.0.0
+Summary: The ultimate Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators.
+Author-email: Entscheidomat <info@entscheidomat.com>
+License: MIT
+Project-URL: Homepage, https://entscheidomat.com
+Project-URL: Documentation, https://entscheidomat.com
+Project-URL: Repository, https://github.com/knuthtimo-lab/decision-kit-py
+Project-URL: Glücksrad / Wheel, https://entscheidomat.com/gluecksrad
+Project-URL: Münzwurf / Coin Flip, https://entscheidomat.com/muenzwurf
+Project-URL: Würfel / Dice Roller, https://entscheidomat.com/wuerfel
+Project-URL: Ja/Nein Generator, https://entscheidomat.com/ja-nein-generator
+Keywords: decision-maker,random-picker,wheel-of-fortune,spinner-wheel,weighted-random,dice-roller,team-generator,entscheidomat
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🎲 decision-kit (Python)
+
+**The ultimate zero-dependency Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators.**
+
+[![PyPI version](https://img.shields.io/pypi/v/decision-kit.svg?style=for-the-badge&color=blue)](https://pypi.org/project/decision-kit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/decision-kit.svg?style=for-the-badge)](https://pypi.org/project/decision-kit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![Powered by](https://img.shields.io/badge/Powered%20by-Entscheidomat.com-ec4899?style=for-the-badge)](https://entscheidomat.com)
+
+[Interactive Web Tools](https://entscheidomat.com) • [Documentation](#usage) • [CLI Usage](#cli-tool)
+
+</div>
+
+---
+
+## 🚀 Overview
+
+`decision-kit` provides fast, battle-tested algorithms and data structures to build decision-making applications, tabletop RPG tools, and random selection systems in Python.
+
+Maintained and sponsored by **[Entscheidomat.com](https://entscheidomat.com)** — the free online decision suite.
+
+---
+
+## 🌐 Interactive Web Demos
+
+Try these online decision tools powered by **[Entscheidomat.com](https://entscheidomat.com)**:
+
+- 🎡 **[Glücksrad / Wheel of Fortune](https://entscheidomat.com/gluecksrad)**
+- ❓ **[Ja / Nein Generator](https://entscheidomat.com/ja-nein-generator)**
+- 🎲 **[3D Würfel Simulator](https://entscheidomat.com/wuerfel)**
+- 🪙 **[Münzwurf Simulation](https://entscheidomat.com/muenzwurf)**
+- 🎱 **[Magic 8-Ball Orakel](https://entscheidomat.com/magic-8-ball)**
+- 🏷️ **[Namen Auslosung & Team Generator](https://entscheidomat.com/namen-auslosung)**
+- 🔢 **[Zufallszahl Generator](https://entscheidomat.com/zufallszahl-generator)**
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision-kit
+```
+
+---
+
+## 💡 Usage
+
+```python
+from decision_kit import AliasMethod, DiceEngine, TeamBalancer, CoinFlipEngine
+
+# 1. Weighted Random Selection (O(1) Alias Algorithm)
+items = [
+    {"id": "A", "label": "Common Item", "weight": 70},
+    {"id": "B", "label": "Rare Item", "weight": 25},
+    {"id": "C", "label": "Legendary Item", "weight": 5},
+]
+alias = AliasMethod(items)
+winner = alias.next()
+print("Won:", winner["label"])
+
+# 2. Tabletop RPG Dice Parser
+roll = DiceEngine.roll("3d6+2")
+print(roll["total"], roll["breakdown"])
+
+# 3. Fair Team Generator
+teams = TeamBalancer.divide_teams(["Anna", "Ben", "Clara", "Dan"], team_count=2)
+print(teams)
+
+# 4. Coin Flip
+coin = CoinFlipEngine.flip("de")
+print(coin["side"])
+```
+
+---
+
+## 🖥️ CLI Tool
+
+```bash
+# Pick random winner
+decision-kit pick "Pizza" "Sushi" "Burger"
+
+# Roll dice
+decision-kit roll 2d6+3
+
+# Flip coin
+decision-kit flip
+```
+
+---
+
+## 📄 License
+
+MIT © **[Entscheidomat](https://entscheidomat.com)**

entscheidomat_decision_kit-1.0.0/README.md

@@ -0,0 +1,95 @@
+<div align="center">
+
+# 🎲 decision-kit (Python)
+
+**The ultimate zero-dependency Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators.**
+
+[![PyPI version](https://img.shields.io/pypi/v/decision-kit.svg?style=for-the-badge&color=blue)](https://pypi.org/project/decision-kit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/decision-kit.svg?style=for-the-badge)](https://pypi.org/project/decision-kit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![Powered by](https://img.shields.io/badge/Powered%20by-Entscheidomat.com-ec4899?style=for-the-badge)](https://entscheidomat.com)
+
+[Interactive Web Tools](https://entscheidomat.com) • [Documentation](#usage) • [CLI Usage](#cli-tool)
+
+</div>
+
+---
+
+## 🚀 Overview
+
+`decision-kit` provides fast, battle-tested algorithms and data structures to build decision-making applications, tabletop RPG tools, and random selection systems in Python.
+
+Maintained and sponsored by **[Entscheidomat.com](https://entscheidomat.com)** — the free online decision suite.
+
+---
+
+## 🌐 Interactive Web Demos
+
+Try these online decision tools powered by **[Entscheidomat.com](https://entscheidomat.com)**:
+
+- 🎡 **[Glücksrad / Wheel of Fortune](https://entscheidomat.com/gluecksrad)**
+- ❓ **[Ja / Nein Generator](https://entscheidomat.com/ja-nein-generator)**
+- 🎲 **[3D Würfel Simulator](https://entscheidomat.com/wuerfel)**
+- 🪙 **[Münzwurf Simulation](https://entscheidomat.com/muenzwurf)**
+- 🎱 **[Magic 8-Ball Orakel](https://entscheidomat.com/magic-8-ball)**
+- 🏷️ **[Namen Auslosung & Team Generator](https://entscheidomat.com/namen-auslosung)**
+- 🔢 **[Zufallszahl Generator](https://entscheidomat.com/zufallszahl-generator)**
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision-kit
+```
+
+---
+
+## 💡 Usage
+
+```python
+from decision_kit import AliasMethod, DiceEngine, TeamBalancer, CoinFlipEngine
+
+# 1. Weighted Random Selection (O(1) Alias Algorithm)
+items = [
+    {"id": "A", "label": "Common Item", "weight": 70},
+    {"id": "B", "label": "Rare Item", "weight": 25},
+    {"id": "C", "label": "Legendary Item", "weight": 5},
+]
+alias = AliasMethod(items)
+winner = alias.next()
+print("Won:", winner["label"])
+
+# 2. Tabletop RPG Dice Parser
+roll = DiceEngine.roll("3d6+2")
+print(roll["total"], roll["breakdown"])
+
+# 3. Fair Team Generator
+teams = TeamBalancer.divide_teams(["Anna", "Ben", "Clara", "Dan"], team_count=2)
+print(teams)
+
+# 4. Coin Flip
+coin = CoinFlipEngine.flip("de")
+print(coin["side"])
+```
+
+---
+
+## 🖥️ CLI Tool
+
+```bash
+# Pick random winner
+decision-kit pick "Pizza" "Sushi" "Burger"
+
+# Roll dice
+decision-kit roll 2d6+3
+
+# Flip coin
+decision-kit flip
+```
+
+---
+
+## 📄 License
+
+MIT © **[Entscheidomat](https://entscheidomat.com)**

entscheidomat_decision_kit-1.0.0/decision_kit/__init__.py

@@ -0,0 +1,21 @@
+"""
+decision-kit: Python library for decision-making algorithms, random selection, weighted sampling, and dice notation.
+Powered by https://entscheidomat.com
+"""
+
+from .alias_method import AliasMethod
+from .dice_engine import DiceEngine
+from .wheel_physics import WheelPhysics
+from .team_balancer import TeamBalancer
+from .coin_flip import CoinFlipEngine
+from .magic_8_ball import Magic8BallEngine
+
+__version__ = "1.0.0"
+__all__ = [
+    "AliasMethod",
+    "DiceEngine",
+    "WheelPhysics",
+    "TeamBalancer",
+    "CoinFlipEngine",
+    "Magic8BallEngine",
+]

entscheidomat_decision_kit-1.0.0/decision_kit/alias_method.py

@@ -0,0 +1,65 @@
+import random
+from typing import List, Dict, Any, TypeVar
+
+T = TypeVar("T")
+
+class AliasMethod:
+    """
+    Vose's Alias Method implementation for O(1) weighted random sampling in Python.
+    Preprocessing time: O(N)
+    Sampling time: O(1)
+    """
+
+    def __init__(self, items: List[Dict[str, Any]]):
+        if not items:
+            raise ValueError("AliasMethod requires at least one item.")
+
+        self.items = items
+        n = len(items)
+        self.probabilities = [0.0] * n
+        self.alias = [0] * n
+
+        total_weight = sum(max(0.0, float(item.get("weight", 1.0))) for item in items)
+        if total_weight <= 0:
+            raise ValueError("Total weight must be greater than zero.")
+
+        scaled_probs = [(max(0.0, float(item.get("weight", 1.0))) / total_weight) * n for item in items]
+        small = []
+        large = []
+
+        for i, prob in enumerate(scaled_probs):
+            if prob < 1.0:
+                small.append(i)
+            else:
+                large.append(i)
+
+        while small and large:
+            s = small.pop()
+            l = large.pop()
+
+            self.probabilities[s] = scaled_probs[s]
+            self.alias[s] = l
+
+            scaled_probs[l] = scaled_probs[l] + scaled_probs[s] - 1.0
+
+            if scaled_probs[l] < 1.0:
+                small.append(l)
+            else:
+                large.append(l)
+
+        while large:
+            self.probabilities[large.pop()] = 1.0
+
+        while small:
+            self.probabilities[small.pop()] = 1.0
+
+    def next(self) -> Dict[str, Any]:
+        """Sample an item in O(1) time."""
+        n = len(self.items)
+        column = random.randint(0, n - 1)
+        coin_toss = random.random()
+
+        if coin_toss < self.probabilities[column]:
+            return self.items[column]
+        else:
+            return self.items[self.alias[column]]

entscheidomat_decision_kit-1.0.0/decision_kit/cli.py

@@ -0,0 +1,64 @@
+import sys
+from .alias_method import AliasMethod
+from .dice_engine import DiceEngine
+from .team_balancer import TeamBalancer
+from .coin_flip import CoinFlipEngine
+from .magic_8_ball import Magic8BallEngine
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("--help", "-h"):
+        print("=================================================")
+        print(" 🎲 decision-kit CLI (Powered by entscheidomat.com)")
+        print("=================================================\n")
+        print("Usage:")
+        print("  decision-kit pick <item1> <item2> ...")
+        print("  decision-kit roll <notation> (e.g. 2d6+3, 1d20)")
+        print("  decision-kit flip")
+        print("  decision-kit 8ball [de|en]")
+        print("  decision-kit team --names \"Alice,Bob,Charlie,Dan\" --teams 2")
+        print("\nExplore interactive decision tools online:")
+        print("  🔗 https://entscheidomat.com\n")
+        return
+
+    cmd = args[0].lower()
+
+    if cmd == "pick":
+        items = args[1:]
+        if not items:
+            print("❌ Please provide items to pick from.")
+            sys.exit(1)
+        opts = [{"id": str(i), "label": label, "weight": 1.0} for i, label in enumerate(items)]
+        alias = AliasMethod(opts)
+        winner = alias.next()
+        print(f"\n🎯 Chosen Winner: {winner['label']}\n")
+
+    elif cmd == "roll":
+        notation = args[1] if len(args) > 1 else "1d20"
+        res = DiceEngine.roll(notation)
+        print(f"\n🎲 Roll Result: {res['total']} ({res['breakdown']})\n")
+
+    elif cmd == "flip":
+        res = CoinFlipEngine.flip("de")
+        print(f"\n🪙 Coin Flip Result: {res['side']}\n")
+
+    elif cmd == "8ball":
+        lang = args[1] if len(args) > 1 else "de"
+        res = Magic8BallEngine.ask(lang)
+        print(f"\n🎱 Magic 8-Ball says: \"{res['answer']}\"\n")
+
+    elif cmd == "team":
+        if "--names" in args:
+            idx = args.index("--names")
+            names = [s.strip() for s in args[idx + 1].split(",") if s.strip()]
+            teams_count = int(args[args.index("--teams") + 1]) if "--teams" in args else 2
+            teams = TeamBalancer.divide_teams(names, teams_count)
+            print(f"\n👥 Teams:")
+            for t in teams:
+                print(f"  {t['name']}: {', '.join(t['members'])}")
+            print()
+        else:
+            print("❌ Please specify --names \"Name1,Name2\"")
+
+if __name__ == "__main__":
+    main()

entscheidomat_decision_kit-1.0.0/decision_kit/coin_flip.py

@@ -0,0 +1,17 @@
+import random
+from typing import Dict, Any
+
+class CoinFlipEngine:
+    @classmethod
+    def flip(cls, language: str = "de") -> Dict[str, Any]:
+        outcome = "heads" if random.random() < 0.5 else "tails"
+        if language == "de":
+            side = "Kopf" if outcome == "heads" else "Zahl"
+        else:
+            side = "Heads" if outcome == "heads" else "Tails"
+
+        return {
+            "outcome": outcome,
+            "side": side,
+            "language": language
+        }

entscheidomat_decision_kit-1.0.0/decision_kit/dice_engine.py

@@ -0,0 +1,92 @@
+import re
+import random
+from typing import Dict, Any, List
+
+class DiceEngine:
+    """
+    Parser and evaluator for tabletop RPG dice expressions (e.g., "3d6+2", "1d20 advantage", "4d6kh3").
+    """
+
+    @classmethod
+    def roll(cls, expression: str) -> Dict[str, Any]:
+        clean_expr = expression.strip().lower()
+
+        # Advantage / Disadvantage
+        if "adv" in clean_expr or "advantage" in clean_expr:
+            r1 = random.randint(1, 20)
+            r2 = random.randint(1, 20)
+            best = max(r1, r2)
+            return {
+                "notation": expression,
+                "rolls": [r1, r2],
+                "modifier": 0,
+                "total": best,
+                "critical_hit": best == 20,
+                "critical_fumble": best == 1,
+                "breakdown": f"Advantage [{r1}, {r2}] -> {best}",
+            }
+
+        if "dis" in clean_expr or "disadvantage" in clean_expr:
+            r1 = random.randint(1, 20)
+            r2 = random.randint(1, 20)
+            worst = min(r1, r2)
+            return {
+                "notation": expression,
+                "rolls": [r1, r2],
+                "modifier": 0,
+                "total": worst,
+                "critical_hit": worst == 20,
+                "critical_fumble": worst == 1,
+                "breakdown": f"Disadvantage [{r1}, {r2}] -> {worst}",
+            }
+
+        pattern = r"^(\d+)?d(\d+)(kh\d+|dl\d+)?([+-]\d+)?$"
+        match = re.match(pattern, clean_expr)
+
+        if not match:
+            if clean_expr.isdigit():
+                sides = int(clean_expr)
+                r = random.randint(1, sides)
+                return {
+                    "notation": f"1d{sides}",
+                    "rolls": [r],
+                    "modifier": 0,
+                    "total": r,
+                    "breakdown": f"1d{sides} ({r})",
+                }
+            raise ValueError(f'Invalid dice notation: "{expression}". Format like "2d6", "1d20+3", "4d6kh3"')
+
+        count = int(match.group(1) or 1)
+        sides = int(match.group(2))
+        keep_drop = match.group(3)
+        static_mod = int(match.group(4) or 0)
+
+        if count <= 0 or sides <= 0:
+            raise ValueError("Dice count and sides must be positive integers.")
+
+        raw_rolls = [random.randint(1, sides) for _ in range(count)]
+        kept_rolls = list(raw_rolls)
+        kd_text = ""
+
+        if keep_drop:
+            if keep_drop.startswith("kh"):
+                k = int(keep_drop.replace("kh", ""))
+                kept_rolls = sorted(raw_rolls, reverse=True)[:k]
+                kd_text = f" (keep highest {k})"
+            elif keep_drop.startswith("dl"):
+                d = int(keep_drop.replace("dl", ""))
+                kept_rolls = sorted(raw_rolls)[d:]
+                kd_text = f" (drop lowest {d})"
+
+        total = sum(kept_rolls) + static_mod
+        mod_text = f"+{static_mod}" if static_mod > 0 else (f"{static_mod}" if static_mod < 0 else "")
+
+        return {
+            "notation": expression,
+            "rolls": raw_rolls,
+            "modifier": static_mod,
+            "total": total,
+            "critical_hit": count == 1 and sides == 20 and raw_rolls[0] == 20,
+            "critical_fumble": count == 1 and sides == 20 and raw_rolls[0] == 1,
+            "breakdown": f"{raw_rolls}{kd_text}{mod_text} = {total}",
+        }

entscheidomat_decision_kit-1.0.0/decision_kit/magic_8_ball.py

@@ -0,0 +1,33 @@
+import random
+from typing import Dict, Any
+
+EN_MAGIC_ANSWERS = [
+    {"text": "It is certain.", "category": "positive"},
+    {"text": "Without a doubt.", "category": "positive"},
+    {"text": "Yes definitely.", "category": "positive"},
+    {"text": "Reply hazy, try again.", "category": "neutral"},
+    {"text": "Ask again later.", "category": "neutral"},
+    {"text": "Don't count on it.", "category": "negative"},
+    {"text": "My reply is no.", "category": "negative"},
+]
+
+DE_MAGIC_ANSWERS = [
+    {"text": "Es ist ganz sicher so.", "category": "positive"},
+    {"text": "Zweifellos ja.", "category": "positive"},
+    {"text": "Ja, definitiv.", "category": "positive"},
+    {"text": "Antwort verschwommen, versuche es nochmal.", "category": "neutral"},
+    {"text": "Frage später nochmal.", "category": "neutral"},
+    {"text": "Verlass dich nicht darauf.", "category": "negative"},
+    {"text": "Meine Antwort ist Nein.", "category": "negative"},
+]
+
+class Magic8BallEngine:
+    @classmethod
+    def ask(cls, language: str = "en") -> Dict[str, Any]:
+        pool = DE_MAGIC_ANSWERS if language == "de" else EN_MAGIC_ANSWERS
+        selected = random.choice(pool)
+        return {
+            "answer": selected["text"],
+            "category": selected["category"],
+            "language": language
+        }

entscheidomat_decision_kit-1.0.0/decision_kit/team_balancer.py

@@ -0,0 +1,25 @@
+import random
+from typing import List, Dict, Any, TypeVar
+
+T = TypeVar("T")
+
+class TeamBalancer:
+    """Fair team and group partition algorithms in Python."""
+
+    @classmethod
+    def divide_teams(cls, members: List[T], team_count: int) -> List[Dict[str, Any]]:
+        if not members:
+            raise ValueError("Members list cannot be empty.")
+        if team_count <= 0:
+            raise ValueError("Team count must be greater than zero.")
+
+        shuffled = list(members)
+        random.shuffle(shuffled)
+
+        effective_count = min(team_count, len(members))
+        teams = [{"id": i + 1, "name": f"Team {i + 1}", "members": []} for i in range(effective_count)]
+
+        for idx, member in enumerate(shuffled):
+            teams[idx % effective_count]["members"].append(member)
+
+        return teams

entscheidomat_decision_kit-1.0.0/decision_kit/wheel_physics.py

@@ -0,0 +1,38 @@
+import random
+from typing import List, Dict, Any
+from .alias_method import AliasMethod
+
+class WheelPhysics:
+    """Calculates spinner wheel stopping angle, winner, and sector alignment."""
+
+    def __init__(self, min_rotations: int = 5, max_rotations: int = 8):
+        self.min_rotations = min_rotations
+        self.max_rotations = max_rotations
+
+    def calculate_spin(self, items: List[Dict[str, Any]]) -> Dict[str, Any]:
+        if not items:
+            raise ValueError("Cannot calculate spin for an empty list.")
+
+        alias = AliasMethod(items)
+        winner = alias.next()
+        winning_index = items.index(winner)
+
+        segment_angle = 360.0 / len(items)
+        sector_center = winning_index * segment_angle + segment_angle / 2.0
+
+        padding = segment_angle * 0.1
+        variance = (random.random() - 0.5) * (segment_angle - 2 * padding)
+        stop_angle_on_wheel = (sector_center + variance + 360.0) % 360.0
+
+        pointer_offset = 270.0
+        final_angle_offset = (pointer_offset - stop_angle_on_wheel + 360.0) % 360.0
+
+        full_rotations = random.randint(self.min_rotations, self.max_rotations)
+        total_target_rotation = full_rotations * 360.0 + final_angle_offset
+
+        return {
+            "winner": winner,
+            "winning_index": winning_index,
+            "target_angle": total_target_rotation,
+            "rotation_count": full_rotations
+        }

entscheidomat_decision_kit-1.0.0/entscheidomat_decision_kit.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: entscheidomat-decision-kit
+Version: 1.0.0
+Summary: The ultimate Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators.
+Author-email: Entscheidomat <info@entscheidomat.com>
+License: MIT
+Project-URL: Homepage, https://entscheidomat.com
+Project-URL: Documentation, https://entscheidomat.com
+Project-URL: Repository, https://github.com/knuthtimo-lab/decision-kit-py
+Project-URL: Glücksrad / Wheel, https://entscheidomat.com/gluecksrad
+Project-URL: Münzwurf / Coin Flip, https://entscheidomat.com/muenzwurf
+Project-URL: Würfel / Dice Roller, https://entscheidomat.com/wuerfel
+Project-URL: Ja/Nein Generator, https://entscheidomat.com/ja-nein-generator
+Keywords: decision-maker,random-picker,wheel-of-fortune,spinner-wheel,weighted-random,dice-roller,team-generator,entscheidomat
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🎲 decision-kit (Python)
+
+**The ultimate zero-dependency Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators.**
+
+[![PyPI version](https://img.shields.io/pypi/v/decision-kit.svg?style=for-the-badge&color=blue)](https://pypi.org/project/decision-kit/)
+[![Python versions](https://img.shields.io/pypi/pyversions/decision-kit.svg?style=for-the-badge)](https://pypi.org/project/decision-kit/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![Powered by](https://img.shields.io/badge/Powered%20by-Entscheidomat.com-ec4899?style=for-the-badge)](https://entscheidomat.com)
+
+[Interactive Web Tools](https://entscheidomat.com) • [Documentation](#usage) • [CLI Usage](#cli-tool)
+
+</div>
+
+---
+
+## 🚀 Overview
+
+`decision-kit` provides fast, battle-tested algorithms and data structures to build decision-making applications, tabletop RPG tools, and random selection systems in Python.
+
+Maintained and sponsored by **[Entscheidomat.com](https://entscheidomat.com)** — the free online decision suite.
+
+---
+
+## 🌐 Interactive Web Demos
+
+Try these online decision tools powered by **[Entscheidomat.com](https://entscheidomat.com)**:
+
+- 🎡 **[Glücksrad / Wheel of Fortune](https://entscheidomat.com/gluecksrad)**
+- ❓ **[Ja / Nein Generator](https://entscheidomat.com/ja-nein-generator)**
+- 🎲 **[3D Würfel Simulator](https://entscheidomat.com/wuerfel)**
+- 🪙 **[Münzwurf Simulation](https://entscheidomat.com/muenzwurf)**
+- 🎱 **[Magic 8-Ball Orakel](https://entscheidomat.com/magic-8-ball)**
+- 🏷️ **[Namen Auslosung & Team Generator](https://entscheidomat.com/namen-auslosung)**
+- 🔢 **[Zufallszahl Generator](https://entscheidomat.com/zufallszahl-generator)**
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision-kit
+```
+
+---
+
+## 💡 Usage
+
+```python
+from decision_kit import AliasMethod, DiceEngine, TeamBalancer, CoinFlipEngine
+
+# 1. Weighted Random Selection (O(1) Alias Algorithm)
+items = [
+    {"id": "A", "label": "Common Item", "weight": 70},
+    {"id": "B", "label": "Rare Item", "weight": 25},
+    {"id": "C", "label": "Legendary Item", "weight": 5},
+]
+alias = AliasMethod(items)
+winner = alias.next()
+print("Won:", winner["label"])
+
+# 2. Tabletop RPG Dice Parser
+roll = DiceEngine.roll("3d6+2")
+print(roll["total"], roll["breakdown"])
+
+# 3. Fair Team Generator
+teams = TeamBalancer.divide_teams(["Anna", "Ben", "Clara", "Dan"], team_count=2)
+print(teams)
+
+# 4. Coin Flip
+coin = CoinFlipEngine.flip("de")
+print(coin["side"])
+```
+
+---
+
+## 🖥️ CLI Tool
+
+```bash
+# Pick random winner
+decision-kit pick "Pizza" "Sushi" "Burger"
+
+# Roll dice
+decision-kit roll 2d6+3
+
+# Flip coin
+decision-kit flip
+```
+
+---
+
+## 📄 License
+
+MIT © **[Entscheidomat](https://entscheidomat.com)**

entscheidomat_decision_kit-1.0.0/entscheidomat_decision_kit.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+decision_kit/__init__.py
+decision_kit/alias_method.py
+decision_kit/cli.py
+decision_kit/coin_flip.py
+decision_kit/dice_engine.py
+decision_kit/magic_8_ball.py
+decision_kit/team_balancer.py
+decision_kit/wheel_physics.py
+entscheidomat_decision_kit.egg-info/PKG-INFO
+entscheidomat_decision_kit.egg-info/SOURCES.txt
+entscheidomat_decision_kit.egg-info/dependency_links.txt
+entscheidomat_decision_kit.egg-info/entry_points.txt
+entscheidomat_decision_kit.egg-info/top_level.txt
+tests/test_decision_kit.py

entscheidomat_decision_kit-1.0.0/entscheidomat_decision_kit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

entscheidomat_decision_kit-1.0.0/entscheidomat_decision_kit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+decision-kit = decision_kit.cli:main

entscheidomat_decision_kit-1.0.0/entscheidomat_decision_kit.egg-info/top_level.txt

@@ -0,0 +1 @@
+decision_kit

entscheidomat_decision_kit-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "entscheidomat-decision-kit"
+version = "1.0.0"
+description = "The ultimate Python library for decision-making algorithms, spinner wheels, weighted sampling, dice notation, and team generators."
+readme = "README.md"
+authors = [
+    { name = "Entscheidomat", email = "info@entscheidomat.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = ["decision-maker", "random-picker", "wheel-of-fortune", "spinner-wheel", "weighted-random", "dice-roller", "team-generator", "entscheidomat"]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.urls]
+"Homepage" = "https://entscheidomat.com"
+"Documentation" = "https://entscheidomat.com"
+"Repository" = "https://github.com/knuthtimo-lab/decision-kit-py"
+"Glücksrad / Wheel" = "https://entscheidomat.com/gluecksrad"
+"Münzwurf / Coin Flip" = "https://entscheidomat.com/muenzwurf"
+"Würfel / Dice Roller" = "https://entscheidomat.com/wuerfel"
+"Ja/Nein Generator" = "https://entscheidomat.com/ja-nein-generator"
+
+[project.scripts]
+decision-kit = "decision_kit.cli:main"

entscheidomat_decision_kit-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

entscheidomat_decision_kit-1.0.0/tests/test_decision_kit.py

@@ -0,0 +1,47 @@
+import unittest
+from decision_kit import (
+    AliasMethod,
+    DiceEngine,
+    TeamBalancer,
+    CoinFlipEngine,
+    Magic8BallEngine,
+    WheelPhysics,
+)
+
+class TestDecisionKit(unittest.TestCase):
+    def test_alias_method(self):
+        items = [{"id": "A", "weight": 70}, {"id": "B", "weight": 30}]
+        alias = AliasMethod(items)
+        counts = {"A": 0, "B": 0}
+        for _ in range(5000):
+            res = alias.next()
+            counts[res["id"]] += 1
+        self.assertGreater(counts["A"], 2500)
+
+    def test_dice_engine(self):
+        res = DiceEngine.roll("2d6+3")
+        self.assertEqual(len(res["rolls"]), 2)
+        self.assertGreaterEqual(res["total"], 5)
+        self.assertLessEqual(res["total"], 15)
+
+    def test_team_balancer(self):
+        members = ["Alice", "Bob", "Charlie", "Dan"]
+        teams = TeamBalancer.divide_teams(members, 2)
+        self.assertEqual(len(teams), 2)
+
+    def test_coin_flip(self):
+        res = CoinFlipEngine.flip("de")
+        self.assertIn(res["side"], ["Kopf", "Zahl"])
+
+    def test_magic_8_ball(self):
+        res = Magic8BallEngine.ask("de")
+        self.assertTrue(len(res["answer"]) > 0)
+
+    def test_wheel_physics(self):
+        physics = WheelPhysics()
+        items = [{"id": "1", "weight": 1}, {"id": "2", "weight": 1}]
+        spin = physics.calculate_spin(items)
+        self.assertGreater(spin["target_angle"], 1000)
+
+if __name__ == "__main__":
+    unittest.main()