Execute Slyr Algorithm in a standalone app

Question

I'm trying to execute the Slyr : lyr_to_qml.py script (a script written by NorthRoad) in a standalone app. I'm having trouble running it, I get an "ModuleNotFoundError: No module named 'qgis'". I tried to change my the paths without any success. Here is the script :

from qgis.core import (Qgis,
                   QgsProcessingParameterFile,
                   QgsProcessingParameterFileDestination,
                   QgsProcessingOutputString,
                   QgsProcessingException)
from .algorithm import SlyrAlgorithm
from ..gui_utils import GuiUtils
from ...converters.context import Context
from ...converters.layers import LayerConverter
from ...parser.exceptions import (UnreadableSymbolException,
                                  NotImplementedException,
                                  UnknownClsidException,
                                  RequiresLicenseException)
from ...parser.objects.group_layer import GroupLayer
from ...parser.stream import Stream
try:
    from qgis.core import QgsProcessingOutputBoolean  # pylint: disable=ungrouped-imports
except ImportError:
    QgsProcessingOutputBoolean = None
class LyrToQml(SlyrAlgorithm):
    """
    Converts .lyr to QML
    """
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
CONVERTED = 'CONVERTED'
ERROR = 'ERROR'

# pylint: disable=missing-docstring,unused-argument

def createInstance(self):
    return LyrToQml()

def name(self):
    return 'lyrtoqml'

def displayName(self):
    return 'Convert LYR to QML'

def shortDescription(self):
    return 'Converts an ESRI LYR file to a QGIS QML file (or files)'

def group(self):
    return 'LYR datasets'

def groupId(self):
    return 'lyr'

def shortHelpString(self):
    return "Converts an ESRI LYR file to a QGIS QML file. If multiple layers are present in the LYR file, each will be converted to an individual QML file."

def initAlgorithm(self, config=None):
    self.addParameter(QgsProcessingParameterFile(
        self.INPUT, 'Input LYR file', extension='lyr'))

    self.addParameter(QgsProcessingParameterFileDestination(
        self.OUTPUT, 'Destination QML file', fileFilter='QML files (*.qml)'))

    if QgsProcessingOutputBoolean is not None:
        self.addOutput(QgsProcessingOutputBoolean(self.CONVERTED, 'Converted'))
    self.addOutput(QgsProcessingOutputString(self.ERROR, 'Error message'))

def processAlgorithm(self,  # pylint: disable=too-many-locals,too-many-statements,too-many-return-statements
                     parameters,
                     context,
                     feedback):
    input_file = self.parameterAsString(parameters, self.INPUT, context)
    output_file = self.parameterAsFileOutput(parameters, self.OUTPUT, context)

    warnings = set()
    with open(input_file, 'rb') as f:
        stream = Stream(f, False, force_layer=True, offset=0)
        try:
            obj = stream.read_object()
        except UnknownClsidException as e:
            feedback.reportError(str(e), fatalError=True)
            return {
                self.ERROR: str(e),
                self.CONVERTED: False,
                self.OUTPUT: None
            }
        except RequiresLicenseException as e:
            raise QgsProcessingException('{} - please see https://north-road.com/slyr/ for details'.format(e)) from e
        except UnreadableSymbolException as e:
            err = 'Unreadable object: {}'.format(e)
            feedback.reportError(err, fatalError=True)
            return {
                self.ERROR: err,
                self.CONVERTED: False,
                self.OUTPUT: None
            }
        except NotImplementedException as e:
            feedback.reportError(str(e), fatalError=True)
            return {
                self.ERROR: str(e),
                self.CONVERTED: False,
                self.OUTPUT: None
            }
        except UnicodeDecodeError as e:
            err = 'Unreadable object: {}'.format(e)
            feedback.reportError(err, fatalError=True)
            return {
                self.ERROR: err,
                self.CONVERTED: False,
                self.OUTPUT: None
            }

    if not LayerConverter.is_layer(obj) and not isinstance(obj, GroupLayer):
        err = 'Objects of type {} are not supported'.format(obj.__class__.__name__)
        feedback.reportError(err,
                             fatalError=False)
        return {
            self.ERROR: err,
            self.CONVERTED: False,
            self.OUTPUT: None
        }

    def on_error(error):
        feedback.reportError(error, fatalError=False)

    def unsupported_object_callback(msg, level=Context.WARNING):
        if msg in warnings:
            return

        warnings.add(msg)
        if level == Context.WARNING:
            feedback.reportError('Warning: {}'.format(msg), False)
        elif level == Context.CRITICAL:
            feedback.reportError(msg, False)

    context = Context()
    context.unsupported_object_callback = unsupported_object_callback
    if Qgis.QGIS_VERSION_INT < 30600:
        context.invalid_layer_resolver = GuiUtils.get_valid_mime_uri
    try:
        LayerConverter.layers_to_qml(obj, input_file, output_file, on_error=on_error, context=context)
    except NotImplementedException as e:
        feedback.reportError(str(e), fatalError=True)
        return {
            self.ERROR: str(e),
            self.CONVERTED: False,
            self.OUTPUT: None
        }

    return {
        self.OUTPUT: output_file,
        self.ERROR: None,
        self.CONVERTED: True
    }

# pylint: enable=missing-docstring,unused-argument

My knowledge of Python code is pretty limited.

Answer 1

You're missing a lot of the required environment setup which is needed to import the qgis modules. Depending on the platform this will differ -- see eg Using Plugin in standalone PyQGIS script

A more straightforward approach would be to use the command line qgis_process application to run the tool -- that involves no Python knowledge and will be considerable easier to get working.