<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def load_compressed(file_obj, file_type=None, resolver=None, mixed=False, **kwargs):
 """ Given a compressed archive load all the geometry that we can from it. Parameters file_obj : open file-like object Containing compressed data file_type : str Type of the archive file mixed : bool If False, for archives containing both 2D and 3D data will only load the 3D data into the Scene. Returns scene : trimesh.Scene Geometry loaded in to a Scene object """


    # parse the file arguments into clean loadable form
    (file_obj,  # file- like object
     file_type,  # str, what kind of file
     metadata,  # dict, any metadata from file name
     opened,    # bool, did we open the file ourselves
     resolver   # object to load referenced resources
     ) = parse_file_args(file_obj=file_obj,
                         file_type=file_type,
                         resolver=resolver)

    try:
        # a dict of 'name' : file-like object
        files = util.decompress(file_obj=file_obj,
                                file_type=file_type)
        # store loaded geometries as a list
        geometries = []

        # so loaders can access textures/etc
        resolver = visual.resolvers.ZipResolver(files)

        # try to save the files with meaningful metadata
        if 'file_path' in metadata:
            archive_name = metadata['file_path']
        else:
            archive_name = 'archive'

        # populate our available formats
        if mixed:
            available = available_formats()
        else:
            # all types contained in ZIP archive
            contains = set(util.split_extension(n).lower()
                           for n in files.keys())
            # if there are no mesh formats available
            if contains.isdisjoint(mesh_formats()):
                available = path_formats()
            else:
                available = mesh_formats()

        for name, data in files.items():
            # only load formats that we support
            compressed_type = util.split_extension(name).lower()
            if compressed_type not in available:
                # don't raise an exception, just try the next one
                continue
            # store the file name relative to the archive
            metadata['file_name'] = (archive_name + '/' +
                                     os.path.basename(name))
            # load the individual geometry
            loaded = load(file_obj=data,
                          file_type=compressed_type,
                          resolver=resolver,
                          metadata=metadata,
                          **kwargs)

            # some loaders return multiple geometries
            if util.is_sequence(loaded):
                # if the loader has returned a list of meshes
                geometries.extend(loaded)
            else:
                # if the loader has returned a single geometry
                geometries.append(loaded)

    finally:
        # if we opened the file in this function
        # clean up after ourselves
        if opened:
            file_obj.close()

    # append meshes or scenes into a single Scene object
    result = append_scenes(geometries)

    return result