lybic-guiagents 0.1.0__py3-none-any.whl

desktop_env/evaluators/getters/file.py

@@ -0,0 +1,154 @@
+import os
+import logging
+from typing import Dict, List, Set
+from typing import Optional, Any, Union
+from datetime import datetime
+import requests
+import pandas as pd
+
+logger = logging.getLogger("desktopenv.getter.file")
+
+
+def get_content_from_vm_file(env, config: Dict[str, Any]) -> Any:
+    """
+    Config:
+        path (str): absolute path on the VM to fetch
+    """
+
+    path = config["path"]
+    file_path = get_vm_file(env, {"path": path, "dest": os.path.basename(path)})
+    file_type, file_content = config['file_type'], config['file_content']
+    if file_type == 'xlsx':
+        if file_content == 'last_row':
+            df = pd.read_excel(file_path)
+            last_row = df.iloc[-1]
+            last_row_as_list = last_row.astype(str).tolist()
+            return last_row_as_list
+    else:
+        raise NotImplementedError(f"File type {file_type} not supported")
+
+
+def get_cloud_file(env, config: Dict[str, Any]) -> Union[str, List[str]]:
+    """
+    Config:
+        path (str|List[str]): the url to download from
+        dest (str|List[str])): file name of the downloaded file
+        multi (bool) : optional. if path and dest are lists providing
+          information of multiple files. defaults to False
+        gives (List[int]): optional. defaults to [0]. which files are directly
+          returned to the metric. if len==1, str is returned; else, list is
+          returned.
+    """
+
+    if not config.get("multi", False):
+        paths: List[str] = [config["path"]]
+        dests: List[str] = [config["dest"]]
+    else:
+        paths: List[str] = config["path"]
+        dests: List[str] = config["dest"]
+    cache_paths: List[str] = []
+
+    gives: Set[int] = set(config.get("gives", [0]))
+
+    for i, (p, d) in enumerate(zip(paths, dests)):
+        _path = os.path.join(env.cache_dir, d)
+        if i in gives:
+            cache_paths.append(_path)
+
+        if os.path.exists(_path):
+            #return _path
+            continue
+
+        url = p
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        with open(_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+    return cache_paths[0] if len(cache_paths)==1 else cache_paths
+
+
+def get_vm_file(env, config: Dict[str, Any]) -> Union[Optional[str], List[Optional[str]]]:
+    """
+    Config:
+        path (str): absolute path on the VM to fetch
+        dest (str): file name of the downloaded file
+        multi (bool) : optional. if path and dest are lists providing
+          information of multiple files. defaults to False
+        gives (List[int]): optional. defaults to [0]. which files are directly
+          returned to the metric. if len==1, str is returned; else, list is
+          returned.
+        only support for single file now:
+        time_suffix(bool): optional. defaults to False. if True, append the current time in required format.
+        time_format(str): optional. defaults to "%Y%m%d_%H%M%S". format of the time suffix.
+    """
+    time_format = "%Y%m%d_%H%M%S"
+    if not config.get("multi", False):
+        paths: List[str] = [config["path"]]
+        dests: List[str] = [config["dest"]]
+        if config.get("time_suffix", False):
+            time_format = config.get("time_format", time_format)
+            # Insert time before file extension.
+            dests = [f"{os.path.splitext(d)[0]}_{datetime.now().strftime(time_format)}{os.path.splitext(d)[1]}" for d in dests]
+    else:
+        paths: List[str] = config["path"]
+        dests: List[str] = config["dest"]
+
+
+    cache_paths: List[str] = []
+
+    gives: Set[int] = set(config.get("gives", [0]))
+
+    for i, (p, d) in enumerate(zip(paths, dests)):
+        _path = os.path.join(env.cache_dir, d)
+        
+        try:
+            # Try to get file from VM
+            file = env.controller.get_file(p)
+            if file is None:
+                logger.warning(f"Failed to get file from VM: {p}")
+                if i in gives:
+                    cache_paths.append(None)
+                continue
+
+            if i in gives:
+                cache_paths.append(_path)
+                
+            # Write file with robust error handling
+            try:
+                # Ensure cache directory exists
+                os.makedirs(env.cache_dir, exist_ok=True)
+                
+                with open(_path, "wb") as f:
+                    f.write(file)
+                logger.info(f"Successfully saved file: {_path} ({len(file)} bytes)")
+                
+            except IOError as e:
+                logger.error(f"IO error writing file {_path}: {e}")
+                if i in gives:
+                    cache_paths[-1] = None  # Replace the path we just added with None
+            except Exception as e:
+                logger.error(f"Unexpected error writing file {_path}: {e}")
+                if i in gives:
+                    cache_paths[-1] = None
+                    
+        except Exception as e:
+            logger.error(f"Error processing file {p}: {e}")
+            if i in gives:
+                cache_paths.append(None)
+                
+    return cache_paths[0] if len(cache_paths)==1 else cache_paths
+
+
+def get_cache_file(env, config: Dict[str, str]) -> str:
+    """
+    Config:
+        path (str): relative path in cache dir
+    """
+
+    _path = os.path.join(env.cache_dir, config["path"])
+    assert os.path.exists(_path)
+    return _path

desktop_env/evaluators/getters/general.py

@@ -0,0 +1,42 @@
+import logging
+from typing import Dict
+import requests
+
+logger = logging.getLogger("desktopenv.getters.general")
+
+
+def get_vm_command_line(env, config: Dict[str, str]):
+    vm_ip = env.vm_ip
+    port = env.server_port
+    command = config["command"]
+    shell = config.get("shell", False)
+
+    response = requests.post(f"http://{vm_ip}:{port}/execute", json={"command": command, "shell": shell})
+
+    print(response.json())
+
+    if response.status_code == 200:
+        return response.json()["output"]
+    else:
+        logger.error("Failed to get vm command line. Status code: %d", response.status_code)
+        return None
+
+def get_vm_command_error(env, config: Dict[str, str]):
+    vm_ip = env.vm_ip
+    port = env.server_port
+    command = config["command"]
+    shell = config.get("shell", False)
+
+    response = requests.post(f"http://{vm_ip}:{port}/execute", json={"command": command, "shell": shell})
+
+    print(response.json())
+
+    if response.status_code == 200:
+        return response.json()["error"]
+    else:
+        logger.error("Failed to get vm command line error. Status code: %d", response.status_code)
+        return None
+
+
+def get_vm_terminal_output(env, config: Dict[str, str]):
+    return env.controller.get_terminal_output()

desktop_env/evaluators/getters/gimp.py

@@ -0,0 +1,38 @@
+import logging
+import os
+from typing import Dict
+
+logger = logging.getLogger("desktopenv.getters.gimp")
+
+
+def get_gimp_config_file(env, config: Dict[str, str]):
+    """
+    Gets the config setting of GIMP.
+    """
+
+    os_type = env.vm_platform
+    print(os_type)
+
+    if os_type == "Linux":
+        config_path = \
+            env.controller.execute_python_command(f"import os; print("
+                                                  f"os"
+                                                  f".path.expanduser("
+                                                  f"'~/.config/GIMP/2.10/"
+                                                  f"{config['file_name']}'))")[
+                'output'].strip()
+    # TODO: Add support for macOS and Windows
+    else:
+        raise Exception("Unsupported operating system", os_type)
+
+    _path = os.path.join(env.cache_dir, config["dest"])
+    content = env.controller.get_file(config_path)
+
+    if not content:
+        logger.error("Failed to get GIMP config file.")
+        return None
+
+    with open(_path, "wb") as f:
+        f.write(content)
+
+    return _path

desktop_env/evaluators/getters/impress.py

@@ -0,0 +1,126 @@
+import os
+import tempfile
+import xml.etree.ElementTree as ET
+import zipfile
+from typing import Dict
+
+from desktop_env.evaluators.getters.file import get_vm_file
+
+
+def get_background_image_in_slide(env, config: Dict[str, str]):
+    ppt_file_path, slide_index, dest = config["ppt_file_path"], int(config["slide_index"]), config["dest"]
+    image_id, image_file_path = None, None
+
+    ppt_file_localhost_path = get_vm_file(env, {"path": ppt_file_path, "dest": os.path.split(ppt_file_path)[-1]})
+
+    with zipfile.ZipFile(ppt_file_localhost_path, 'r') as myzip:
+        slide1_xml_file = 'ppt/slides/slide{}.xml'.format(slide_index + 1)
+        # firstly, check whether the background image is used in the slide
+        if slide1_xml_file not in myzip.namelist(): return None
+        with myzip.open(slide1_xml_file) as f:
+            # Parse the XML tree from the relationships file
+            tree = ET.parse(f)
+            root = tree.getroot()
+            bg_tag = "{http://schemas.openxmlformats.org/presentationml/2006/main}bgPr"
+            image_tag = "{http://schemas.openxmlformats.org/drawingml/2006/main}blip"
+            attr_tag = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed"
+            for child in root.iter(bg_tag):
+                try:
+                    for element in child.iter(image_tag):
+                        image_id = element.attrib[attr_tag]
+                        break
+                except: pass
+                if image_id is not None: break
+            else: return None
+
+        # next, extract the background image from the slide
+        slide1_rels_file = 'ppt/slides/_rels/slide{}.xml.rels'.format(slide_index + 1)
+        if slide1_rels_file in myzip.namelist():
+            with myzip.open(slide1_rels_file) as f:
+                # Parse the XML tree from the relationships file
+                tree = ET.parse(f)
+                root = tree.getroot()
+                # Define the namespace used in the relationships file
+                namespaces = {'r': 'http://schemas.openxmlformats.org/package/2006/relationships'}
+                # Look for all relationship elements that have a type attribute for image
+                for rel in root.findall('r:Relationship', namespaces):
+                    # Check if the relationship is for an image file
+                    if 'image' in rel.attrib['Type'] and rel.attrib['Id'] == image_id:
+                        target = rel.attrib['Target']
+                        if target.startswith('..'):
+                            # Resolve the relative path to get the correct path within the zip file
+                            image_file_path = os.path.normpath(os.path.join('ppt/slides', target))
+                            # Replace backslashes with forward slashes for ZIP compatibility
+                            image_file_path = image_file_path.replace('\\', '/')
+                            tmpdirname = os.path.dirname(ppt_file_localhost_path)
+                            myzip.extract(image_file_path, tmpdirname)
+                            image_file_path = os.path.join(tmpdirname, image_file_path)
+                            return image_file_path
+                        else: # absolute path
+                            assert target.startswith("file://"), target
+                            image_file_path = target[7:]
+                        break
+    if image_file_path is None:
+        return None
+
+    else:
+        # Get the audio file from vm and return the file path in the host
+        return get_vm_file(env, {"path": image_file_path, "dest": dest})
+
+
+def get_audio_in_slide(env, config: Dict[str, str]):
+    ppt_file_path, slide_index, dest = config["ppt_file_path"], int(config["slide_index"]), config["dest"]
+
+    # Open the .pptx file as a zip file, fixme: now we assume there is only one audio file in the slides
+    audio_file_path = None
+
+    ppt_file_localhost_path = get_vm_file(env, {"path": ppt_file_path, "dest": os.path.split(ppt_file_path)[-1]})
+
+    with zipfile.ZipFile(ppt_file_localhost_path, 'r') as myzip:
+        # Find the relationships XML file for the first slide
+        slide1_rels_file = 'ppt/slides/_rels/slide{}.xml.rels'.format(slide_index + 1)
+        if slide1_rels_file in myzip.namelist():
+            with myzip.open(slide1_rels_file) as f:
+                # Parse the XML tree from the relationships file
+                tree = ET.parse(f)
+                root = tree.getroot()
+                # Define the namespace used in the relationships file
+                namespaces = {'r': 'http://schemas.openxmlformats.org/package/2006/relationships'}
+                # Look for all relationship elements that have a type attribute for audio
+                for rel in root.findall('r:Relationship', namespaces):
+                    # Check if the relationship is for an audio file
+                    if 'audio' in rel.attrib['Type']:
+                        # The audio can be embedded inside the file or linked to an external file
+                        # Get the target attribute which contains the audio file path
+                        target = rel.attrib['Target']
+
+                        if target.startswith('..'):
+                            # Resolve the relative path to get the correct path within the zip file
+                            audio_file_path = os.path.normpath(os.path.join('ppt/slides', target))
+                            # Replace backslashes with forward slashes for ZIP compatibility
+                            audio_file_path = audio_file_path.replace('\\', '/')
+
+                            # Create a temporary directory to extract the audio file
+                            tmpdirname = os.path.dirname(ppt_file_localhost_path)
+                            myzip.extract(audio_file_path, tmpdirname)
+                            audio_file_path = os.path.join(tmpdirname, audio_file_path)
+                            return audio_file_path
+                            # with tempfile.TemporaryDirectory() as tmpdirname:
+                            #     # Extract the audio file
+                            #     myzip.extract(audio_file_path, tmpdirname)
+                            #     # Get the full path of the extracted audio file
+                            #     extracted_audio_path = os.path.join(tmpdirname, audio_file_path)
+                            #     # Return the extracted audio file path
+                            #     audio_file_path = extracted_audio_path
+                        else:
+                            # the audio file is external to the .pptx file
+                            # Return the audio file path
+                            assert target.startswith("file://"), target
+                            audio_file_path = target[7:]
+                        break
+    if audio_file_path is None:
+        return None
+
+    else:
+        # Get the audio file from vm and return the file path in the host
+        return get_vm_file(env, {"path": audio_file_path, "dest": dest})

desktop_env/evaluators/getters/info.py

@@ -0,0 +1,24 @@
+import os
+from typing import Union
+
+
+def get_vm_screen_size(env, config: dict) -> dict:
+    return env.controller.get_vm_screen_size()
+
+
+def get_vm_window_size(env, config: dict) -> dict:
+    return env.controller.get_vm_window_size(app_class_name=config["app_class_name"])
+
+
+def get_vm_wallpaper(env, config: dict) -> Union[str, bytes]:
+    _path = os.path.join(env.cache_dir, config["dest"])
+
+    content = env.controller.get_vm_wallpaper()
+    with open(_path, "wb") as f:
+        f.write(content)
+
+    return _path
+
+
+def get_list_directory(env, config: dict) -> dict:
+    return env.controller.get_vm_directory_tree(config["path"])