How to use the classes.logger.log.error function in classes

# If statement is required, as if the user hits "Cancel"
                # on the "load file" dialog, it is interpreted as trying
                # to open a file with a blank name. This could use some
                # improvement.
                if file_path != "":
                    # Prepare to use status bar
                    self.statusBar = QStatusBar()
                    self.setStatusBar(self.statusBar)

                    log.info("File not found at {}".format(file_path))
                    self.statusBar.showMessage(_("Project {} is missing (it may have been moved or deleted). It has been removed from the Recent Projects menu.".format(file_path)), 5000)
                    self.remove_recent_project(file_path)
                    self.load_recent_menu()

        except Exception as ex:
            log.error("Couldn't open project {}".format(file_path))
            QMessageBox.warning(self, _("Error Opening Project"), str(ex))

        # Restore normal cursor
        get_app().restoreOverrideCursor()

# Create an instance of a libopenshot Timeline object
            self.clip_reader = openshot.Timeline(width, height, openshot.Fraction(fps["num"], fps["den"]), sample_rate, channels, channel_layout)
            self.clip_reader.info.channel_layout = channel_layout
            self.clip_reader.info.has_audio = True
            self.clip_reader.info.has_video = True
            self.clip_reader.info.video_length = 999999
            self.clip_reader.info.duration = 999999
            self.clip_reader.info.sample_rate = sample_rate
            self.clip_reader.info.channels = channels

            try:
                # Add clip for current preview file
                new_clip = openshot.Clip(path)
                self.clip_reader.AddClip(new_clip)
            except:
                log.error('Failed to load media file into video player: %s' % path)
                return

            # Assign new clip_reader
            self.clip_path = path

            # Keep track of previous clip readers (so we can Close it later)
            self.previous_clips.append(new_clip)
            self.previous_clip_readers.append(self.clip_reader)

            # Open and set reader
            self.clip_reader.Open()
            self.player.Reader(self.clip_reader)

        # Close and destroy old clip readers (leaving the 3 most recent)
        while len(self.previous_clip_readers) > 3:
            log.info('Removing old clips from preview: %s' % self.previous_clip_readers[0])

if not key:
            log.warning("Cannot get empty key.")
            return None
        if not isinstance(key, list):
            key = [key]

        # Get reference to internal data structure
        obj = self._data

        # Iterate through key list finding sub-objects either by name or by an object match criteria such as {"id":"ADB34"}.
        for key_index in range(len(key)):
            key_part = key[key_index]

            # Key_part must be a string or dictionary
            if not isinstance(key_part, dict) and not isinstance(key_part, str):
                log.error("Unexpected key part type: {}".format(type(key_part).__name__))
                return None

            # If key_part is a dictionary and obj is a list or dict, each key is tested as a property of the items in the current object
            # in the project data structure, and the first match is returned.
            if isinstance(key_part, dict) and isinstance(obj, list):
                # Overall status of finding a matching sub-object
                found = False
                # Loop through each item in object to find match
                for item_index in range(len(obj)):
                    item = obj[item_index]
                    # True until something disqualifies this as a match
                    match = True
                    # Check each key in key_part dictionary and if not found to be equal as a property in item, move on to next item in list
                    for subkey in key_part.keys():
                        # Get each key in dictionary (i.e. "id", "layer", etc...)
                        subkey = subkey.lower()

def convert_paths_to_absolute(self, file_path, data):
        """ Convert all paths to absolute using regex """
        try:
            # Get project folder
            path_context["new_project_folder"] = os.path.dirname(file_path)
            path_context["existing_project_folder"] = os.path.dirname(file_path)
            path_context["new_project_assets"] = get_assets_path(file_path, create_paths=False)
            path_context["existing_project_assets"] = get_assets_path(file_path, create_paths=False)

            # Optimized regex replacement
            data = re.sub(path_regex, self.replace_string_to_absolute, data)

        except Exception as ex:
            log.error("Error while converting relative paths to absolute paths: %s" % str(ex))

        return data

""" Convert all paths relative to this filepath """
        try:
            # Get project folder
            path_context["new_project_folder"] = os.path.dirname(file_path)
            path_context["new_project_assets"] = get_assets_path(file_path, create_paths=False)
            path_context["existing_project_folder"] = os.path.dirname(file_path)
            path_context["existing_project_assets"] = get_assets_path(file_path, create_paths=False)
            if previous_path and file_path != previous_path:
                path_context["existing_project_folder"] = os.path.dirname(previous_path)
                path_context["existing_project_assets"] = get_assets_path(previous_path, create_paths=False)

            # Optimized regex replacement
            data = re.sub(path_regex, self.replace_string_to_relative, data)

        except Exception as ex:
            log.error("Error while converting absolute paths to relative paths: %s" % str(ex))

        return data

s = settings.get_settings()
            app.updates.save_history(app.project, s.get("history-limit"))

            # Save project to file
            app.project.save(file_path)

            # Set Window title
            self.SetWindowTitle()

            # Load recent projects again
            self.load_recent_menu()

            log.info("Saved project {}".format(file_path))

        except Exception as ex:
            log.error("Couldn't save project %s. %s" % (file_path, str(ex)))
            QMessageBox.warning(self, _("Error Saving Project"), str(ex))

def ExceptionHandler(exeception_type, exeception_value, exeception_traceback):
    """Callback for any unhandled exceptions"""
    log.error('Unhandled Exception', exc_info=(exeception_type, exeception_value, exeception_traceback))

    # Build string of stack trace
    stacktrace = "Python %s" % "".join(traceback.format_exception(exeception_type, exeception_value, exeception_traceback))

    # Report traceback to webservice (if enabled)
    track_exception_stacktrace(stacktrace, "openshot-qt")

def read_from_file(self, file_path, path_mode="ignore"):
        """ Load JSON settings from a file """
        try:
            with open(file_path, 'r') as f:
                contents = f.read()
                if contents:
                    if path_mode == "absolute":
                        # Convert any paths to absolute
                        contents = self.convert_paths_to_absolute(file_path, contents)
                    return json.loads(contents, strict=False)
        except Exception as ex:
            msg = ("Couldn't load {} file: {}".format(self.data_type, ex))
            log.error(msg)
            raise Exception(msg)
        msg = ("Couldn't load {} file, no data.".format(self.data_type))
        log.warning(msg)
        raise Exception(msg)

found_track = True
                continue

        # Calculate new track number (based on gap delta)
        new_track_number = selected_layer_number
        if track_number_delta > 2:
            # New track number (pick mid point in track number gap)
            new_track_number = selected_layer_number - int(round(track_number_delta / 2.0))
        else:
            # Loop through tracks from insert point and above
            for track in reversed(sorted(all_tracks, key=itemgetter('number'))):
                if track.get("number") >= selected_layer_number:
                    existing_track = Track.get(number=track.get("number"))
                    if not existing_track:
                        # Log error and fail silently, and continue
                        log.error('No track object found with number: %s' % track.get("number"))
                        continue
                    existing_layer = existing_track.data["number"]
                    existing_track.data["number"] = existing_layer + 1000000
                    existing_track.save()

                    # Loop through clips and transitions for track, moving up to new layer
                    for clip in Clip.filter(layer=existing_layer):
                        clip.data["layer"] = int(clip.data["layer"]) + 1000000
                        clip.save()

                    for trans in Transition.filter(layer=existing_layer):
                        trans.data["layer"] = int(trans.data["layer"]) + 1000000
                        trans.save()

        # Create new track at vacated layer
        track = Track()