File Utilities

from mcdis_rcon.utils.files import read_yml

config = read_yml('md_config.yml')
print(config['Bot Token'])
print(config['Processes']['Servers'])

def read_yml(file_path: str) -> dict:
    with open(file_path, 'r') as file:
        yaml = ruamel.yaml.YAML()
        yaml.indent(mapping = 2, sequence = 4, offset=2)
        yaml.preserve_quotes = True
        return yaml.load(file)

from mcdis_rcon.utils.files import read_properties

props = read_properties('server.properties')
print(f"Server port: {props['server-port']}")
print(f"Max players: {props['max-players']}")

def read_properties(file_path: str):
    if not os.path.exists(file_path): 
        return {}

    properties = {}
    with open(file_path, 'r') as f:
        for line in f:
            if line.strip() and not line.startswith('#'):
                key, value = line.strip().split('=', 1)
                properties[key] = value
    return properties

from mcdis_rcon.utils.files import read_file

content = read_file('README.md')
print(content)

from mcdis_rcon.utils.files import write_in_file

content = "Line 1\nLine 2\nLine 3"
write_in_file('output.txt', content)

from mcdis_rcon.utils.files import dict_to_json

data = {
    "player": "Steve",
    "score": 1000,
    "items": ["diamond_sword", "golden_apple"]
}

dict_to_json('player_data.json', data)

from mcdis_rcon.utils.files import json_to_dict

data = json_to_dict('player_data.json')
print(f"Player: {data['player']}")
print(f"Score: {data['score']}")

from mcdis_rcon.utils.files import read_dat_files

player_data = read_dat_files('world/playerdata/uuid.dat')
print(player_data)

from mcdis_rcon.utils.files import read_dat_files, dat_to_dict
import json

nbt_data = read_dat_files('level.dat')
data_dict = dat_to_dict(nbt_data)

print(json.dumps(data_dict, indent=2))

from mcdis_rcon.utils.files import show_dat_files

show_dat_files(file_path='level.dat')

from mcdis_rcon.utils.files import is_valid_path_name

print(is_valid_path_name("server-1"))     # True
print(is_valid_path_name("My Server"))    # True  
print(is_valid_path_name("server@#$"))    # False

from mcdis_rcon.utils.files import mcdis_path

print(mcdis_path("."))                  # "McDis"
print(mcdis_path("server/world"))       # "McDis/server/world"

from mcdis_rcon.utils.files import un_mcdis_path

print(un_mcdis_path("McDis"))                    # "."
print(un_mcdis_path("McDis/server/world"))       # "server/world"

from mcdis_rcon.utils.files import get_path_size

size_str = get_path_size('world', string=True)
print(f"World size: {size_str}")  # "1.2 GB"

size_bytes = get_path_size('world', string=False)
print(f"World size: {size_bytes} bytes")  # 1234567890 bytes

from mcdis_rcon.utils.files import elements_on

total = elements_on('world')
print(f"Total files and folders: {total}")

files_only = elements_on('world', include_dirs=False)
print(f"Files: {files_only}")

dirs_only = elements_on('world', include_files=False)
print(f"Directories: {dirs_only}")

from mcdis_rcon.utils.files import make_zip

# Simple zip
make_zip('world', 'world_backup.zip')

# With progress tracking
counter = [0, 0]
make_zip('world', 'world_backup.zip', counter)
print(f"Compressed {counter[0]} of {counter[1]} items")

from mcdis_rcon.utils.files import unpack_zip

# Simple extraction
unpack_zip('backup.zip', 'restored_world')

# With progress tracking
counter = [0, 0]
unpack_zip('backup.zip', 'restored_world', counter)
print(f"Extracted {counter[0]} of {counter[1]} files")

import os
from mcdis_rcon.utils.files import (
    read_properties, 
    dict_to_json, 
    json_to_dict,
    get_path_size
)

class mdplugin:
    def __init__(self, process):
        self.process = process
        self.config_file = os.path.join(
            process.path_files, 
            'plugin_config.json'
        )
        self.config = self.load_config()
    
    def load_config(self):
        if os.path.exists(self.config_file):
            return json_to_dict(self.config_file)
        return {"enabled": True, "data": {}}
    
    def save_config(self):
        dict_to_json(self.config_file, self.config)
    
    def listener_events(self, log: str):
        if "Server started" in log:
            # Read server properties
            props_path = os.path.join(
                self.process.path_files, 
                'server.properties'
            )
            props = read_properties(props_path)
            
            # Get world size
            world_path = os.path.join(
                self.process.path_files,
                props.get('level-name', 'world')
            )
            size = get_path_size(world_path)
            
            print(f"World size: {size}")
    
    def unload(self):
        self.save_config()