McDisClient

from mcdis_rcon.classes import McDisClient

class McDisClient(commands.Bot):
    def __init__(self):
        super().__init__(blank_space, intents = discord.Intents().all())

def _load_config(self):
    try:
        self.config = read_yml('md_config.yml')
    except Exception as error:
        print('The file \'md_config.yml\' could not be opened.')
        os._exit(0)

async def _load_processes(self):
    for name in self.config['Processes']['Servers']:
        server = Server(name, self, self.config['Processes']['Servers'][name])
        self.processes.append(server)
        self.servers.append(server)

    for name in self.config['Processes']['Networks']:
        network = Network(name, self, self.config['Processes']['Networks'][name])
        self.processes.append(network)
        self.networks.append(network)

async def _load_addons(self, *, reload: bool = False):
    if reload: 
        self.unload_addons()
    
    files_in_addons_dir = os.listdir(self.path_addons)
    valid_extensions = ['.py', '.mcdis']
    
    addons = [file for file in files_in_addons_dir
              if os.path.splitext(file)[1] in valid_extensions or
              os.path.exists(os.path.join(self.path_addons, file, '__init__.py'))]

async def call_addons(self, function: str, args: tuple = tuple()):
    for name, addon in self.addons.items():
        try:
            func = getattr(addon, function, None)
            if func:
                await func(*args)
        except Exception:
            await self.error_report(
                title=f'{function}() of {addon}',
                error=traceback.format_exc()
            )

async def error_report(self, *, title: str, error: str, should_print: bool = True):
    error_log = f'- Error Report [{title}]:\n\n{error}'.replace('`',''')
    mrkd_error = f'```diff\n{truncate(error_log, 1980)}\n```'
    error_reports = await thread('Error Reports', self.panel)
    error_report = await error_reports.send(mrkd_error)
    if should_print: 
        print(f'\n{error_log}')
    
    return error_report.jump_url

async def on_ready(self):
    if self.is_running: 
        return
    
    self._load_panel()
    print(self._('Logged in as {}!').format(self.user))
    
    await self._load_processes()
    await self._load_addons()
    await self._load_behaviours()
    
    self.flask = FlaskManager(self)
    asyncio.create_task(self._load_banner())
    
    self.is_running = True
    await execute_and_wait(self.console_listener)

async def panel_interface(self, message: discord.Message):
    if message.author.bot: 
        return

    if message.channel.id == self.panel.id:
        if self.is_command(message.content.lower(), 'start-all'):
            await message.delete()
            response = await message.channel.send(
                self._('✔ Initializing processes.'))
            await response.delete(delay = 2)
            
            for process in self.processes: 
                process.start()

def is_command(self, message: str, command: str, console: bool = False):
    dummy = message + ' '
    return dummy.startswith(f'{self.prefix}{command} ') if not console else dummy.startswith(command)

def is_valid_mcdis_path(self, path: str, *, check_if_file: bool = False, check_if_dir: bool = False):
    real_path = un_mcdis_path(path)
    new_path = os.path.join(self.cwd, real_path)
    
    if not path.split(os.sep)[0] == 'McDis':
        return self._('✖ The path must be a McDis path. E.g.: `McDis/Backups`.')
    if not new_path.startswith(self.cwd):
        return self._('✖ You must work within the directory where McDis is running.')

def on_stop(self):
    self.unload_addons()
    
    if any([process.is_running() for process in self.processes]):
        print(self._('Closing processes...'))
        
        for process in self.processes:
            process.stop(omit_task=True)
        
        # Wait up to 60 seconds
        i = 60
        while i > 0 and any([process.is_running() for process in self.processes]):
            i -= 1
            time.sleep(1)
        
        # Force kill if needed
        if any([process.is_running() for process in self.processes]):
            for process in self.processes:
                process.kill(omit_task=True)
    
    os._exit(0)

from mcdis_rcon.classes import McDisClient

# Accessing the client in a plugin
class mdplugin:
    def __init__(self, process):
        self.process = process
        self.client = process.client  # McDisClient instance
        
        # Access client features
        print(f"Panel ID: {self.client.panel.id}")
        print(f"Config: {self.client.config}")
        print(f"Processes: {len(self.client.processes)}")