minestrapper 0.1.0__py3-none-any.whl

minestrapper/__init__.py

@@ -0,0 +1,4 @@
+from .server import Server
+from .state_handler import ServerState
+
+__all__ = ["Server", "ServerState"]

minestrapper/config_handler.py

@@ -0,0 +1,50 @@
+import os
+import json
+from enum import Enum
+
+class FileType(Enum):
+    CONFIG = "config"
+    SERVER_PROPERTIES = "server_properties"
+
+def key_value_to_dict(unpacked_string: list) -> dict:
+    dict = {}
+
+    for line in unpacked_string:
+        key_value = line.strip().split('=')
+        if len(key_value) == 2:
+            dict[key_value[0]] = key_value[1]
+
+    return dict
+
+def dict_to_key_value(dictionary: dict) -> str:
+    key_value_string = ""
+    for key, value in dictionary.items():
+        key_value_string += f"{key}={value}\n"
+    return key_value_string
+
+class ConfigHandler:
+    def __init__(self, path: str):
+        self.path = path
+        self.config_json = os.path.join(self.path, "minestrapper", "config.json")
+        self.server_properties_file = os.path.join(self.path, "server.properties")
+
+    def __open(self, file_type: FileType):
+        if file_type == FileType.CONFIG:
+            self.__config = json.load(open(self.config_json, 'r'))
+        elif file_type == FileType.SERVER_PROPERTIES:
+            with open(self.server_properties_file, 'r') as f:
+                self.__server_properties = key_value_to_dict(f.readlines())
+
+    def get_config(self):
+        self.__open(FileType.CONFIG)
+        return self.__config
+    
+    def get_server_properties(self):
+        self.__open(FileType.SERVER_PROPERTIES)
+        return self.__server_properties
+    
+    def set_server_properties(self, key : str, value : str):
+        self.__open(FileType.SERVER_PROPERTIES)
+        self.__server_properties[key] = value
+        with open(self.server_properties_file, 'w') as f:            
+            f.write(dict_to_key_value(self.__server_properties))

minestrapper/features/feature.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..server import Server
+
+class Feature:
+    def __init__(self, name: str, description: str, server: "Server"):
+        self.name = name
+        self.description = description
+        self.server = server
+
+    def run(self):
+        raise NotImplementedError("Feature must implement the run method")

minestrapper/features/handle_built_in_features.py

@@ -0,0 +1,35 @@
+import os
+import sys
+
+from typing import TYPE_CHECKING
+
+from .state_styles.state_styles import StateStyle
+from .server_resource_pack.server_resource_pack import ServerResourcePack
+
+if TYPE_CHECKING:
+    from ..server import Server
+
+FEATURES = {
+    "state_styles": {
+        "class": StateStyle,
+        "enabled_by_default": True
+    },
+    "server_resource_pack": {
+        "class": ServerResourcePack,
+        "enabled_by_default": False
+    }
+}
+
+def handle_built_in_features(server: "Server"):
+    for feature_key, feature_info in FEATURES.items():
+        target_feature = server.config_handler.get_config()["features"].get(feature_key)
+        if target_feature is None: continue
+
+        if target_feature.get("feature_enabled", feature_info["enabled_by_default"]):
+            feature_class = feature_info["class"]
+            feature_instance = feature_class(server)
+            server.logger.info(f"Feature '{feature_instance.name}' has been started.")
+            try:
+                feature_instance.run()
+            except Exception as e:
+                server.logger.error(f"An error occurred while running the feature '{feature_instance.name}': {e}")

minestrapper/features/server_resource_pack/address_validator.py

@@ -0,0 +1,48 @@
+import ipaddress
+import socket
+
+def is_valid_ip(ip_address: str) -> bool:
+    try:
+        ipaddress.ip_address(ip_address)
+    except ValueError:
+        raise ValueError(f"Invalid IP address for server resource pack: {ip_address}")
+    
+    return True
+
+def get_port_integer(port: str) -> int:
+    try:
+        return int(port)
+    except (TypeError, ValueError):
+        raise ValueError(f"Port must be an integer, got {port}")
+
+def is_valid_port(port: int) -> bool:
+    if (port < 1 or port > 65535):
+        raise ValueError(f"Port must be between 1 and 65535, got {port}")
+
+    return True
+
+def is_port_free(ip: str, port: str) -> bool:
+    candidate_port = int(port)
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex((ip, candidate_port)) != 0
+
+def get_clean_address(ip: str, port: str) -> tuple[str, int]:
+    cleaned_ip = ip
+    cleaned_port = port
+
+    if (ip == "localhost"):
+        cleaned_ip = "127.0.0.1"
+    if (ip in [None, ""]):
+        cleaned_ip = "0.0.0.0"
+
+    if (not is_valid_ip(cleaned_ip)):
+        raise ValueError(f"Invalid IP address for server resource pack: {cleaned_ip}")
+    
+    port_int = get_port_integer(port)
+    if (not is_valid_port(port_int)):
+        raise ValueError(f"Invalid port for server resource pack: {port}")
+    
+    if (not is_port_free(cleaned_ip, port)):
+        cleaned_port = 0
+
+    return cleaned_ip, int(cleaned_port)

minestrapper/features/server_resource_pack/path_resolver.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+def resolve_server_path(path_str: str, server_root: str | Path) -> Path:
+    if (not path_str):
+        raise ValueError(
+            "Resource pack path is not set in config."
+            "Did you mean to disable the server_resource_pack feature?"
+        )
+
+    path = Path(path_str)
+
+    if not path.is_absolute():
+        path = Path(server_root) / path
+
+    path = path.resolve()
+
+    if (not path.exists()):
+        raise ValueError(f"Resource pack path {path} does not exist.")
+    
+    if (not path.is_file()):
+        raise ValueError(f"Resource pack path {path} is not a file.")
+    
+    if (path.suffix.lower() != ".zip"):
+        raise ValueError(f"Resource pack path {path} is not a zip file.")
+    
+    return path

minestrapper/features/server_resource_pack/server_resource_pack.py

@@ -0,0 +1,87 @@
+import threading
+
+import os
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from minestrapper.logger import LogLevel
+
+from pathlib import Path
+
+from minestrapper.features.feature import Feature
+
+from typing import TYPE_CHECKING
+
+from minestrapper.features.server_resource_pack.path_resolver import resolve_server_path
+if TYPE_CHECKING:
+    from ....minestrapper.server import Server
+
+from .address_validator import get_clean_address
+
+import hashlib
+
+class ServerResourcePack(Feature):
+    def __init__(self, server: "Server"):
+        super().__init__(
+            "Server Resource Pack", 
+            "An HTTP server to serve a custom resource pack for your Minecraft Server.", 
+            server
+        )
+
+        self.config = self.server.config_handler.get_config()['features']['server_resource_pack']
+
+        self.path = resolve_server_path(self.config["path"], self.server.path)
+        self.ip, self.port = get_clean_address(self.config.get("ip", ""), self.config.get("port", ""))
+
+    def log(self, level: LogLevel, message: str):
+        self.server.logger.log(level, f"Resource Pack Server: {message}")
+
+    def get_sha1(self, file_path: Path) -> str:
+        sha1 = hashlib.sha1()
+
+        with open(file_path, "rb") as f:
+            while chunk := f.read(65536):
+                sha1.update(chunk)
+
+        return sha1.hexdigest()
+
+    def start_resource_pack_server(self):
+        file_path = self.path
+        server_instance = self.server
+        log_method = self.log
+        
+        class ResourcePackRequestHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                log_level = LogLevel.INFO
+                if (len(args) >= 2):
+                    try:
+                        code = int(args[1])
+                        if (code >= 500):
+                            log_level = LogLevel.ERROR
+                        elif (code >= 400):
+                            log_level = LogLevel.WARNING
+                    except Exception as e:
+                        pass
+                log_method(log_level, format % args)
+
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header("Content-Type", "application/zip")
+                self.send_header("Content-Length", str(os.path.getsize(file_path)))
+                self.end_headers()
+                
+                with open(file_path, "rb") as resource_pack_file:
+                    while chunk := resource_pack_file.read(65536):
+                        self.wfile.write(chunk)
+                    
+        server = HTTPServer((self.ip, self.port), ResourcePackRequestHandler)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+
+        return server
+
+    def run(self):
+        self.resource_pack_server = self.start_resource_pack_server()
+        resource_pack_url = f"http://{self.ip}:{self.port}/"
+
+        self.server.logger.info(f"Started resource pack server at {resource_pack_url}.")
+        self.server.config_handler.set_server_properties("resource-pack", resource_pack_url)
+        self.server.config_handler.set_server_properties("resource-pack-sha1", self.get_sha1(self.path))

minestrapper/features/state_styles/state_styles.py

@@ -0,0 +1,59 @@
+import os
+import ctypes
+
+from typing import TYPE_CHECKING, Callable
+
+from minestrapper.features.feature import Feature
+from minestrapper.util.ansi_colors import ANSI_COLORS
+from minestrapper.state_handler import ServerState
+
+if TYPE_CHECKING:
+    from ....minestrapper.server import Server
+
+class StateStyle(Feature):
+    def __init__(self, server: "Server"):
+        super().__init__("State Styles", "Provider for colored text and titles based on different server states", server)
+        self.state_styles_config = self.server.config_handler.get_config()['features']['state_styles']
+        self.styles = self.state_styles_config["styles"]
+        self.title_enabled = self.state_styles_config.get("title_enabled", False)
+        self.color_enabled = self.state_styles_config.get("color_enabled", False)
+
+    def get_colored_text(self, text: str, state: ServerState) -> str:
+        map = {
+            ServerState.STARTING: ANSI_COLORS.get(self.styles["starting"]["color"], ANSI_COLORS["reset"]),
+            ServerState.RUNNING: ANSI_COLORS.get(self.styles["running"]["color"], ANSI_COLORS["reset"]),
+            ServerState.STOPPING: ANSI_COLORS.get(self.styles["stopping"]["color"], ANSI_COLORS["reset"]),
+            ServerState.STOPPED: ANSI_COLORS.get(self.styles["stopped"]["color"], ANSI_COLORS["reset"]),
+            ServerState.PAUSED: ANSI_COLORS.get(self.styles["paused"]["color"], ANSI_COLORS["reset"]),
+        }
+
+        color = map.get(state, ANSI_COLORS["reset"])
+        
+        return f"{color}{text}{ANSI_COLORS['reset']}"
+    
+    def get_title(self, state: ServerState) -> str:
+        map = {
+            ServerState.STARTING: self.styles["starting"].get("title", "Starting"),
+            ServerState.RUNNING: self.styles["running"].get("title", "Running"),
+            ServerState.STOPPING: self.styles["stopping"].get("title", "Stopping"),
+            ServerState.STOPPED: self.styles["stopped"].get("title", "Stopped"),
+            ServerState.PAUSED: self.styles["paused"].get("title", "Paused"),
+        }
+
+        return map.get(state, "Unknown")
+    
+    def run(self):
+        if (self.color_enabled):
+            @self.server.logger.add_line_transformer
+            def state_styles_transformer(line: str):
+                return self.get_colored_text(line, self.server.state_handler.get())
+        
+        if (self.title_enabled):
+            @self.server.state_handler.on_state_change
+            def set_terminal_title():
+                title = self.get_title(self.server.state_handler.get())
+                if (os.name == "nt"):
+                    ctypes.windll.kernel32.SetConsoleTitleW(title)
+                else:
+                    sys.stdout.write(f'\x1b]0;{title}\x07')
+                    sys.stdout.flush()

minestrapper/logger.py

@@ -0,0 +1,76 @@
+import os
+import threading
+
+from enum import Enum
+from pathlib import Path
+from datetime import datetime
+
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from .server import Server
+
+class LogLevel(Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+
+class Logger:
+    def __init__(self, server: "Server"):
+        self.server = server
+        self.line_transformers: list[Callable[[str], str]] = []
+
+        logs_folder = Path(server.path) / "logs"
+        logs_folder.mkdir(parents=True, exist_ok=True)
+        self.log_file = logs_folder / "latest.log"
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        self.minestrapper_log_file = logs_folder / "latest-minestrapper.log"
+        self.minestrapper_log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.minestrapper_log_file.touch(exist_ok=True)
+        with open(self.minestrapper_log_file, "w", encoding="utf-8") as log:
+            log.write("")
+
+        self.info("Initialized Minestrapper Logger successfully.")
+
+    def add_line_transformer(self, transformer: Callable[[str], str]):
+        self.line_transformers.append(transformer)
+        return transformer
+    
+    def __write_line_log(self, line: str):
+        with open(self.minestrapper_log_file, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def print_with_transformation(self, message: str):
+        for transformer in self.line_transformers:
+            message = transformer(message)
+
+        print(message)
+
+    def forwarded_log(self, message: str):
+        self.print_with_transformation(message)
+        self.__write_line_log(message)
+
+    def log(self, level: LogLevel, message: str):
+        timestamp = f"[{datetime.now().strftime('%H:%M:%S')}]"
+        log_level_label = f"[Minestrapper/{level.value}]:"
+        full_line = f"{timestamp} {log_level_label} {message}"
+
+        self.print_with_transformation(full_line)
+        self.__write_line_log(full_line)
+
+    def publish_minestrapper_log(self):
+        with open(self.minestrapper_log_file, "r", encoding="utf-8") as f:
+            minestrapper_log_content = f.read()
+        
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            f.write(minestrapper_log_content)
+
+    def info(self, message: str):
+        self.log(LogLevel.INFO, message)
+
+    def warning(self, message: str):
+        self.log(LogLevel.WARNING, message)
+
+    def error(self, message: str):
+        self.log(LogLevel.ERROR, message)

minestrapper/server.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+import subprocess
+from typing import Callable
+import threading
+
+import os
+
+from .logger import Logger
+
+from .config_handler import ConfigHandler
+from .state_handler import ServerState, StateHandler
+
+from minestrapper.util.get_state_from_line import get_state_from_line
+
+from minestrapper.features.handle_built_in_features import handle_built_in_features
+
+from time import sleep as wait
+
+class Server:
+    def __init__(self, path: str | Path):
+        self.path : str = (str(path) if isinstance(path, Path) else path)
+        self.config_handler : ConfigHandler = ConfigHandler(self.path)
+        self.state_handler : StateHandler = StateHandler(ServerState.STARTING)
+        self.periodic_callbacks : list[Callable] = []
+        self.new_line_callbacks : list[Callable] = []
+        self.server_process : subprocess.Popen | None = None
+
+        self.logger = Logger(self)
+
+        os.chdir(self.path)
+
+    def __start_server_process(self):
+        config = self.config_handler.get_config()
+
+        jar_path = f"{config['server']['jar_name']}.jar"
+
+        full_command = [
+            "java"
+        ]
+        java_args = [
+            f"-Xms{config['server']['min_ram']}",
+            f"-Xmx{config['server']['max_ram']}",
+        ]
+
+        if "other_args" in config['server']:
+            java_args.extend(config['server']['other_args'])
+
+        full_command.extend(java_args)
+        full_command.extend([
+            "-jar", jar_path, "nogui"
+        ])
+
+        server_process = subprocess.Popen(
+            full_command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            encoding="utf-8",
+            errors="replace"
+        )
+
+        return server_process
+
+    def start_server(self):
+        self.server_process = self.__start_server_process()
+
+        def loop():
+            while self.state_handler.get() != ServerState.STOPPED and self.server_process is not None and self.server_process.poll() is None:
+                self.__on_periodic()
+
+                if (self.periodic_callbacks):
+                    for callback in self.periodic_callbacks:
+                        callback()
+                wait(0.020)
+                
+        self.periodic_thread = threading.Thread(target=loop, daemon=True)
+        self.periodic_thread.start()
+
+        def output_loop():
+            assert self.server_process is not None
+            if (self.server_process.stdout is not None):
+                for line in self.server_process.stdout:
+                    self.__on_new_line(line.strip("\n"))
+       
+        self.output_thread = threading.Thread(target=output_loop, daemon=True)
+        self.output_thread.start()
+
+        self.logger.info("Server process started successfully.")
+        handle_built_in_features(self)
+    
+    def wait_loop(self):
+        assert self.server_process is not None
+        self.server_process.wait()
+
+        # If the server process has stopped, this code should now run.
+        self.state_handler.set(ServerState.STOPPED)
+        self.logger.info("Server process has stopped.")
+        self.logger.publish_minestrapper_log()
+        input("Press Enter to exit...")
+
+    def __on_new_line(self, line : str):
+        new_state = get_state_from_line(line)
+        if (new_state is not None and new_state != self.state_handler.get()):
+            self.state_handler.set(new_state)
+
+        self.logger.forwarded_log(line)
+
+        if self.new_line_callbacks:
+            for callback in self.new_line_callbacks:
+                callback(line)
+
+    def on_new_line(self, function: Callable):
+        self.new_line_callbacks.append(function)
+        return function
+
+    def __on_periodic(self):
+        for callback in self.periodic_callbacks:
+            callback()
+
+    def on_periodic(self, function: Callable):
+        self.periodic_callbacks.append(function)
+
+        return function

minestrapper/state_handler.py

@@ -0,0 +1,44 @@
+from enum import Enum
+from typing import Callable
+
+class ServerState(Enum):
+    STARTING = "starting"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+
+class StateHandler:
+    def __init__(self, initial_state: ServerState):
+        self.__server_state = initial_state
+        self.state_callbacks: dict[ServerState | None, list[Callable]] = {}
+
+    def set(self, state: ServerState):
+        if (state == self.__server_state):
+            return
+        
+        self.__server_state = state
+
+        for callback in self.state_callbacks.get(state, []):
+            callback()
+
+        for callback in self.state_callbacks.get(None, []):
+            callback()
+
+    def on_state_change(self, function: Callable, state: ServerState | None = None) -> Callable:
+        def decorator():
+            if state is None or self.get() == state:
+                function()
+
+        if (state is not None and not isinstance(state, ServerState)):
+            raise NameError(f"State {state} is not a valid server state.")
+
+        if state not in self.state_callbacks:
+            self.state_callbacks[state] = []
+        self.state_callbacks[state].append(function)
+
+        decorator() # Call the function immediately if we're already in the correct state
+        return decorator
+
+    def get(self) -> ServerState:
+        return self.__server_state

minestrapper/util/ansi_colors.py

@@ -0,0 +1,19 @@
+ANSI_COLORS = {
+    "reset": "\033[0m",
+    "red": "\033[31m",
+    "bright_red": "\033[91m",
+    "green": "\033[32m",
+    "bright_green": "\033[92m",
+    "yellow": "\033[33m",
+    "bright_yellow": "\033[93m",
+    "blue": "\033[34m",
+    "bright_blue": "\033[94m",
+    "magenta": "\033[35m",
+    "bright_magenta": "\033[95m",
+    "cyan": "\033[36m",
+    "bright_cyan": "\033[96m",
+    "white": "\033[37m",
+    "bright_white": "\033[97m",
+    "black": "\033[30m",
+    "bright_black": "\033[90m",
+}

minestrapper/util/get_state_from_line.py

@@ -0,0 +1,30 @@
+import re
+from ..state_handler import ServerState
+
+# These regex statements were vibe coded 🤤: 
+# "[HH:MM:SS] [Thread/Level]:"
+LOG_PREFIX = re.compile(r"^\[\d{2}:\d{2}:\d{2}\] \[[^\]]+\]: ")
+# "Playername joined the game"
+PLAYER_JOINED_REGEX = r"^[^\s]+ joined the game"
+
+def __strip_prefix(line: str) -> str:
+    return LOG_PREFIX.sub("", line, count=1)
+
+def get_state_from_line(line: str):
+    msg = __strip_prefix(line)
+
+    state_table = {
+        msg.startswith("Done ("): ServerState.RUNNING,
+        msg.startswith("Stopping the server"): ServerState.STOPPING,
+        msg.startswith("Server empty for 60 seconds, pausing"): ServerState.PAUSED,
+        re.match(PLAYER_JOINED_REGEX, msg): ServerState.RUNNING
+    }
+
+    new_state = None
+    for condition in state_table:
+        new_state_value = state_table[condition]
+        if condition:
+            new_state = new_state_value
+            break
+
+    return new_state

minestrapper-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: minestrapper
+Version: 0.1.0
+Summary: Minestrapper is a bootstrapper for Minecraft servers that lets you easily add custom features to your server without needing a full mod/plugin loader.
+Author: Faizaan J
+Requires-Python: >=3.9
+License-File: LICENSE
+Dynamic: license-file

minestrapper-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+minestrapper/__init__.py,sha256=DlUQbX9W9H2yzQeLfTtka4CD9C-3ZQqoOJioPuukzo8,105
+minestrapper/config_handler.py,sha256=JDn10xeuJKLehmSbt0pdYExxaCpMZO1HVPPuWrYmc9A,1726
+minestrapper/logger.py,sha256=VZ8K9kt6S2CzXj6EQRBvo_Efp4us8ieVXDzwwNegzqc,2568
+minestrapper/server.py,sha256=qzsNNebEXH5hJ8uvjs_GVXW4tmEEJ9wnDHUgGMxk7_U,4062
+minestrapper/state_handler.py,sha256=qsiVrV9mONIuI_LP8l90zwVMX9WasoCgAdgMU1fbEwo,1432
+minestrapper/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minestrapper/features/feature.py,sha256=tVvyzEHTgakuzbx8PRsqUXN798qITvV5rxM2SQxY0KY,370
+minestrapper/features/handle_built_in_features.py,sha256=lqGxnZBBeKPSXXnmUpCKwFiE_nECHnWn60z7TgEZFEQ,1204
+minestrapper/features/server_resource_pack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minestrapper/features/server_resource_pack/address_validator.py,sha256=yI_3AaLfqInMo_8JPxoQpYhdYvgS8LPgcIWvboCaGgU,1466
+minestrapper/features/server_resource_pack/path_resolver.py,sha256=NyITlpAlXP_KctMNdOpF_NXZGa-f9_XwF2554Ai9Ync,781
+minestrapper/features/server_resource_pack/server_resource_pack.py,sha256=nxkYnY4y62i4mzQKc5G71dG8BNwlNZt5NV6wzDDccXg,3275
+minestrapper/features/state_styles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minestrapper/features/state_styles/state_styles.py,sha256=Q7iPcGib5po0dEsWLfr1a6z5By7iFF6xnpr7hjXdjLU,2819
+minestrapper/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minestrapper/util/ansi_colors.py,sha256=ifAe1cSPFt2r9gyga3RnSZbYpk4PCDQk1AkggEBprvM,515
+minestrapper/util/get_state_from_line.py,sha256=MSVzgBDlOMIRiR62ugcXWON01i_XvmIqvei7A0DpsP8,962
+minestrapper-0.1.0.dist-info/licenses/LICENSE,sha256=hDJHxQ6zTzazAoRB6Z-rdxVVzl3j1YHjc9K0652RS34,1085
+minestrapper-0.1.0.dist-info/METADATA,sha256=9NoMy33yp4XfjPg1nKb8AfDXevBhTvzmIZuwErtVT18,309
+minestrapper-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+minestrapper-0.1.0.dist-info/top_level.txt,sha256=11eT8b6b6DLNCsPQaGDP4YRPJcVPo5vjulySPw62gds,13
+minestrapper-0.1.0.dist-info/RECORD,,

minestrapper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

minestrapper-0.1.0.dist-info/licenses/LICENSE

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

minestrapper-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+minestrapper