mclog-parser 0.1.0__tar.gz

mclog_parser-0.1.0/LICENSE

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

mclog_parser-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: mclog-parser
+Version: 0.1.0
+Summary: Parse and analyze Minecraft server log files
+License: MIT
+Keywords: minecraft,log,parser,server,analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mclog-parser
+Analyze Minecraft server logs instantly — turn raw log files into structured data.
+# mclog-parser 🎮
+
+**Analyze Minecraft server logs instantly — turn raw log files into structured data.**
+
+```bash
+pip install mclog-parser
+```
+
+---
+
+## Why?
+
+Every Minecraft server generates thousands of log lines. Finding crashes, tracking players, or spotting lag spikes means scrolling through walls of text manually.
+
+`mclog-parser` does it in one line.
+
+---
+
+## Quickstart
+
+```python
+from mclog_parser import LogParser
+
+log = LogParser("latest.log")
+
+log.summary()        # full overview
+log.crashes()        # all errors & crashes
+log.lag_spikes()     # lag warnings
+log.player_stats()   # per-player stats
+log.export_json()    # save report as JSON
+```
+
+### Example Output
+
+```json
+{
+  "unique_players": 3,
+  "total_sessions": 5,
+  "crash_count": 1,
+  "lag_spike_count": 2,
+  "top_players": [
+    { "player": "Ahmed99", "sessions": 2, "deaths": 1 }
+  ]
+}
+```
+
+---
+
+## CLI
+
+No Python needed — run directly from your terminal:
+
+```bash
+mclog latest.log                        # summary
+mclog latest.log --crashes              # errors only
+mclog latest.log --players              # player stats table
+mclog latest.log --player Ahmed99       # one player's sessions
+mclog latest.log --export report.json   # export to JSON
+```
+
+---
+
+## Supported Servers
+
+| Server | Status |
+|--------|--------|
+| Paper  | ✅ |
+| Spigot | ✅ |
+| Vanilla | ✅ |
+| Fabric | ✅ |
+| Forge  | 🔜 |
+
+---
+
+## Install
+
+```bash
+pip install mclog-parser
+```
+
+Requires Python 3.10+
+
+---
+
+## Roadmap
+
+- [x] Core parser (crashes, lag, sessions)
+- [x] Player stats
+- [x] JSON export
+- [x] CLI
+- [ ] Web dashboard
+- [ ] Discord bot integration
+- [ ] Real-time log watching
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.

mclog_parser-0.1.0/README.md

@@ -0,0 +1,101 @@
+# mclog-parser
+Analyze Minecraft server logs instantly — turn raw log files into structured data.
+# mclog-parser 🎮
+
+**Analyze Minecraft server logs instantly — turn raw log files into structured data.**
+
+```bash
+pip install mclog-parser
+```
+
+---
+
+## Why?
+
+Every Minecraft server generates thousands of log lines. Finding crashes, tracking players, or spotting lag spikes means scrolling through walls of text manually.
+
+`mclog-parser` does it in one line.
+
+---
+
+## Quickstart
+
+```python
+from mclog_parser import LogParser
+
+log = LogParser("latest.log")
+
+log.summary()        # full overview
+log.crashes()        # all errors & crashes
+log.lag_spikes()     # lag warnings
+log.player_stats()   # per-player stats
+log.export_json()    # save report as JSON
+```
+
+### Example Output
+
+```json
+{
+  "unique_players": 3,
+  "total_sessions": 5,
+  "crash_count": 1,
+  "lag_spike_count": 2,
+  "top_players": [
+    { "player": "Ahmed99", "sessions": 2, "deaths": 1 }
+  ]
+}
+```
+
+---
+
+## CLI
+
+No Python needed — run directly from your terminal:
+
+```bash
+mclog latest.log                        # summary
+mclog latest.log --crashes              # errors only
+mclog latest.log --players              # player stats table
+mclog latest.log --player Ahmed99       # one player's sessions
+mclog latest.log --export report.json   # export to JSON
+```
+
+---
+
+## Supported Servers
+
+| Server | Status |
+|--------|--------|
+| Paper  | ✅ |
+| Spigot | ✅ |
+| Vanilla | ✅ |
+| Fabric | ✅ |
+| Forge  | 🔜 |
+
+---
+
+## Install
+
+```bash
+pip install mclog-parser
+```
+
+Requires Python 3.10+
+
+---
+
+## Roadmap
+
+- [x] Core parser (crashes, lag, sessions)
+- [x] Player stats
+- [x] JSON export
+- [x] CLI
+- [ ] Web dashboard
+- [ ] Discord bot integration
+- [ ] Real-time log watching
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.

mclog_parser-0.1.0/mclog_parser/__init__.py

@@ -0,0 +1,4 @@
+from .parser import LogParser
+
+__version__ = "0.1.0"
+__all__ = ["LogParser"]

mclog_parser-0.1.0/mclog_parser/cli.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import sys
+from mclog_parser import LogParser
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="mclog",
+        description="🎮 Minecraft Log Parser — Analyze your server logs instantly"
+    )
+    parser.add_argument("logfile", help="Path to latest.log or any MC log file")
+    parser.add_argument("--crashes",  action="store_true", help="Show crashes and errors")
+    parser.add_argument("--lags",     action="store_true", help="Show lag spikes")
+    parser.add_argument("--players",  action="store_true", help="Show player stats")
+    parser.add_argument("--player",   metavar="NAME",      help="Sessions for a specific player")
+    parser.add_argument("--export",   metavar="FILE",      help="Export full report to JSON")
+    parser.add_argument("--summary",  action="store_true", help="Show summary (default)", default=True)
+
+    args = parser.parse_args()
+
+    try:
+        log = LogParser(args.logfile)
+    except FileNotFoundError as e:
+        print(f"❌ {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if args.crashes:
+        crashes = log.crashes()
+        print(f"\n💥 Crashes & Errors ({len(crashes)} total)\n" + "─" * 40)
+        for c in crashes:
+            print(f"[{c['time']}] {c['level']}: {c['message']}")
+            for t in c["trace"][:3]:
+                print(f"  {t}")
+        return
+
+    if args.lags:
+        lags = log.lag_spikes()
+        print(f"\n⚠️  Lag Spikes ({len(lags)} total)\n" + "─" * 40)
+        for l in lags:
+            print(f"[{l['time']}] {l['message']}")
+        return
+
+    if args.players:
+        stats = log.player_stats()
+        print(f"\n👥 Player Stats ({len(stats)} players)\n" + "─" * 40)
+        print(f"{'Player':<20} {'Sessions':>8} {'Deaths':>7} {'Chat':>6}")
+        print("─" * 44)
+        for p in stats:
+            print(f"{p['player']:<20} {p['sessions']:>8} {p['deaths']:>7} {p['chat_messages']:>6}")
+        return
+
+    if args.player:
+        sessions = log.player_sessions(args.player)
+        data = sessions.get(args.player, [])
+        print(f"\n🎮 Sessions for {args.player} ({len(data)} total)\n" + "─" * 40)
+        for s in data:
+            left = s["left"] or "still online"
+            print(f"  Joined: {s['joined']}  →  Left: {left}")
+        return
+
+    if args.export:
+        path = log.export_json(args.export)
+        print(f"✅ Report exported to: {path}")
+        return
+
+    # Default: summary
+    s = log.summary()
+    print(f"""
+🎮 Minecraft Log Summary
+{"─" * 40}
+📁 File          : {s['file']}
+📄 Total Lines   : {s['total_lines']:,}
+👥 Players       : {s['unique_players']}
+🔗 Sessions      : {s['total_sessions']}
+💥 Crashes       : {s['crash_count']}
+⚠️  Lag Spikes   : {s['lag_spike_count']}
+
+🏆 Top Players:
+""")
+    for p in s["top_players"]:
+        print(f"  {p['player']:<20} {p['sessions']} sessions  |  {p['deaths']} deaths")
+
+    if s["crashes"]:
+        print(f"\n💥 Latest Crash:")
+        c = s["crashes"][-1]
+        print(f"  [{c['time']}] {c['message']}")
+
+
+if __name__ == "__main__":
+    main()

mclog_parser-0.1.0/mclog_parser/parser.py

@@ -0,0 +1,175 @@
+import re
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+from collections import defaultdict
+from typing import Optional
+
+
+# ─── Regex Patterns ───────────────────────────────────────────────
+_LINE_RE = re.compile(
+    r"^\[(?P<time>\d{2}:\d{2}:\d{2})\] \[(?P<thread>[^\]]+)/(?P<level>[A-Z]+)\]: (?P<msg>.+)$"
+)
+_JOIN_RE     = re.compile(r"^(?P<player>\w+) joined the game$")
+_LEAVE_RE    = re.compile(r"^(?P<player>\w+) left the game$")
+_DEATH_RE    = re.compile(r"^(?P<player>\w+) (?:was|died|fell|drowned|burned|blew|hit|tried|walked|withered|starved|suffocated|kinetic).+$")
+_CHAT_RE     = re.compile(r"^<(?P<player>\w+)> (?P<message>.+)$")
+_LAG_RE      = re.compile(r"Can't keep up!")
+_CRASH_RE    = re.compile(r"(?:java\.\w+Exception|java\.lang\.Error|Caused by:|FATAL)")
+
+
+class LogParser:
+    """
+    Parse Minecraft server log files and extract structured data.
+
+    Usage:
+        log = LogParser("latest.log")
+        print(log.summary())
+        log.export_json("report.json")
+    """
+
+    def __init__(self, filepath: str):
+        self.filepath = Path(filepath)
+        if not self.filepath.exists():
+            raise FileNotFoundError(f"Log file not found: {filepath}")
+
+        self._lines: list[dict] = []
+        self._parse()
+
+    # ─── Internal ──────────────────────────────────────────────────
+
+    def _parse(self):
+        with open(self.filepath, "r", encoding="utf-8", errors="replace") as f:
+            for raw in f:
+                raw = raw.rstrip("\n")
+                m = _LINE_RE.match(raw)
+                if m:
+                    self._lines.append({
+                        "time":   m.group("time"),
+                        "thread": m.group("thread"),
+                        "level":  m.group("level"),
+                        "msg":    m.group("msg"),
+                        "raw":    raw,
+                    })
+                else:
+                    # continuation lines (stack traces etc.)
+                    if self._lines:
+                        self._lines[-1].setdefault("extra", []).append(raw)
+
+    # ─── Public API ────────────────────────────────────────────────
+
+    def crashes(self) -> list[dict]:
+        """Return all crash/error events with context."""
+        results = []
+        for i, line in enumerate(self._lines):
+            if _CRASH_RE.search(line["msg"]) or line["level"] in ("ERROR", "FATAL"):
+                results.append({
+                    "time":    line["time"],
+                    "level":   line["level"],
+                    "message": line["msg"],
+                    "trace":   line.get("extra", []),
+                })
+        return results
+
+    def lag_spikes(self) -> list[dict]:
+        """Return all lag spike warnings."""
+        return [
+            {"time": l["time"], "message": l["msg"]}
+            for l in self._lines if _LAG_RE.search(l["msg"])
+        ]
+
+    def player_sessions(self, player: Optional[str] = None) -> dict:
+        """
+        Return join/leave sessions per player.
+        If player is given, filter to that player only.
+        """
+        sessions: dict[str, list] = defaultdict(list)
+        last_join: dict[str, str] = {}
+
+        for line in self._lines:
+            jm = _JOIN_RE.match(line["msg"])
+            lm = _LEAVE_RE.match(line["msg"])
+
+            if jm:
+                p = jm.group("player")
+                last_join[p] = line["time"]
+
+            elif lm:
+                p = lm.group("player")
+                sessions[p].append({
+                    "joined": last_join.pop(p, None),
+                    "left":   line["time"],
+                })
+
+        # players still online (no leave event)
+        for p, t in last_join.items():
+            sessions[p].append({"joined": t, "left": None})
+
+        if player:
+            return {player: sessions.get(player, [])}
+        return dict(sessions)
+
+    def player_stats(self) -> list[dict]:
+        """Return per-player statistics sorted by session count."""
+        sessions = self.player_sessions()
+        deaths = defaultdict(int)
+        messages = defaultdict(int)
+
+        for line in self._lines:
+            dm = _DEATH_RE.match(line["msg"])
+            cm = _CHAT_RE.match(line["msg"])
+            if dm:
+                deaths[dm.group("player")] += 1
+            if cm:
+                messages[cm.group("player")] += 1
+
+        stats = []
+        all_players = set(sessions) | set(deaths) | set(messages)
+        for p in all_players:
+            s = sessions.get(p, [])
+            stats.append({
+                "player":       p,
+                "sessions":     len(s),
+                "deaths":       deaths[p],
+                "chat_messages": messages[p],
+            })
+
+        return sorted(stats, key=lambda x: x["sessions"], reverse=True)
+
+    def top_players(self, n: int = 10) -> list[dict]:
+        """Return top N players by sessions."""
+        return self.player_stats()[:n]
+
+    def summary(self) -> dict:
+        """Return a full summary of the log file."""
+        stats   = self.player_stats()
+        crashes = self.crashes()
+        lags    = self.lag_spikes()
+
+        unique_players = len(stats)
+        total_sessions = sum(p["sessions"] for p in stats)
+
+        return {
+            "file":            str(self.filepath),
+            "total_lines":     len(self._lines),
+            "unique_players":  unique_players,
+            "total_sessions":  total_sessions,
+            "crash_count":     len(crashes),
+            "lag_spike_count": len(lags),
+            "top_players":     self.top_players(5),
+            "crashes":         crashes[:5],  # first 5 only in summary
+        }
+
+    def export_json(self, output_path: str = "mc_report.json") -> str:
+        """Export full analysis to a JSON file."""
+        report = {
+            "summary":        self.summary(),
+            "player_stats":   self.player_stats(),
+            "all_crashes":    self.crashes(),
+            "all_lag_spikes": self.lag_spikes(),
+            "player_sessions": self.player_sessions(),
+        }
+        path = Path(output_path)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+        return str(path)

mclog_parser-0.1.0/mclog_parser.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: mclog-parser
+Version: 0.1.0
+Summary: Parse and analyze Minecraft server log files
+License: MIT
+Keywords: minecraft,log,parser,server,analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mclog-parser
+Analyze Minecraft server logs instantly — turn raw log files into structured data.
+# mclog-parser 🎮
+
+**Analyze Minecraft server logs instantly — turn raw log files into structured data.**
+
+```bash
+pip install mclog-parser
+```
+
+---
+
+## Why?
+
+Every Minecraft server generates thousands of log lines. Finding crashes, tracking players, or spotting lag spikes means scrolling through walls of text manually.
+
+`mclog-parser` does it in one line.
+
+---
+
+## Quickstart
+
+```python
+from mclog_parser import LogParser
+
+log = LogParser("latest.log")
+
+log.summary()        # full overview
+log.crashes()        # all errors & crashes
+log.lag_spikes()     # lag warnings
+log.player_stats()   # per-player stats
+log.export_json()    # save report as JSON
+```
+
+### Example Output
+
+```json
+{
+  "unique_players": 3,
+  "total_sessions": 5,
+  "crash_count": 1,
+  "lag_spike_count": 2,
+  "top_players": [
+    { "player": "Ahmed99", "sessions": 2, "deaths": 1 }
+  ]
+}
+```
+
+---
+
+## CLI
+
+No Python needed — run directly from your terminal:
+
+```bash
+mclog latest.log                        # summary
+mclog latest.log --crashes              # errors only
+mclog latest.log --players              # player stats table
+mclog latest.log --player Ahmed99       # one player's sessions
+mclog latest.log --export report.json   # export to JSON
+```
+
+---
+
+## Supported Servers
+
+| Server | Status |
+|--------|--------|
+| Paper  | ✅ |
+| Spigot | ✅ |
+| Vanilla | ✅ |
+| Fabric | ✅ |
+| Forge  | 🔜 |
+
+---
+
+## Install
+
+```bash
+pip install mclog-parser
+```
+
+Requires Python 3.10+
+
+---
+
+## Roadmap
+
+- [x] Core parser (crashes, lag, sessions)
+- [x] Player stats
+- [x] JSON export
+- [x] CLI
+- [ ] Web dashboard
+- [ ] Discord bot integration
+- [ ] Real-time log watching
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.

mclog_parser-0.1.0/mclog_parser.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+mclog_parser/__init__.py
+mclog_parser/cli.py
+mclog_parser/parser.py
+mclog_parser.egg-info/PKG-INFO
+mclog_parser.egg-info/SOURCES.txt
+mclog_parser.egg-info/dependency_links.txt
+mclog_parser.egg-info/entry_points.txt
+mclog_parser.egg-info/top_level.txt

mclog_parser-0.1.0/mclog_parser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mclog_parser-0.1.0/mclog_parser.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mclog = mclog_parser.cli:main

mclog_parser-0.1.0/mclog_parser.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+dist
+mclog_parser
+tests

mclog_parser-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mclog-parser"
+version = "0.1.0"
+description = "Parse and analyze Minecraft server log files"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["minecraft", "log", "parser", "server", "analysis"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Games/Entertainment",
+]
+
+[project.scripts]
+mclog = "mclog_parser.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]

mclog_parser-0.1.0/setup.cfg

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