Module `tf.advanced.find`

Functions

def findAppClass(appName, appPath)

Expand source code Browse git

def findAppClass(appName, appPath):
    """Find the class definition of an app.

    The file `app.py` in the app directory will be looked up,
    if it exists, it will be loaded as a Python module, and from
    this module we try to get the class `TfApp`.

    Returns
    -------
    class | None
        If `TfApp` can be found and imported, it is the result.
        Otherwise we return `None`.
    """

    appPath = normpath(appPath)
    appClass = None
    moduleName = f"tf.apps.{appName}.app"
    filePath = f"{appPath}/app.py"
    if not fileExists(filePath):
        return None

    try:
        spec = util.spec_from_file_location(moduleName, f"{appPath}/app.py")
        code = util.module_from_spec(spec)
        sys.path.insert(0, appPath)
        spec.loader.exec_module(code)
        sys.path.pop(0)
        appClass = code.TfApp
    except Exception as e:
        console(f"findAppClass: {str(e)}", error=True)
        console(f'findAppClass: Api for "{appName}" not loaded')
        appClass = None
    return appClass

Find the class definition of an app.

The file app.py in the app directory will be looked up, if it exists, it will be loaded as a Python module, and from this module we try to get the class TfApp.

Returns

class | None: If TfApp can be found and imported, it is the result. Otherwise we return None.

def findAppConfig(appName, appPath, commit, release, local, backend, org=None, repo=None, version=None, relative=None, straight=False)

Expand source code Browse git

def findAppConfig(
    appName,
    appPath,
    commit,
    release,
    local,
    backend,
    org=None,
    repo=None,
    version=None,
    relative=None,
    straight=False,
):
    """Find the configuration information of an app.

    If there is a `config.yaml` file, read it and check the compatibility
    of the configuration settings with the current version of TF.

    If there is no such file but a `config.py` is present,
    conclude that this is an older app, not compatible with TF v8.0.0 or higher.

    If there are no such configuration files, fill in a few basic settings.

    See Also
    --------
    tf.advanced.settings: options allowed in `config.yaml`
    """

    appPath = normpath(appPath)
    configPath = f"{appPath}/{APP_CONFIG}"
    configPathOld = f"{appPath}/{APP_CONFIG_OLD}"
    cssPath = f"{appPath}/{APP_DISPLAY}"

    checkApiVersion = True

    isCompatible = None

    cfg = readYaml(asFile=configPath, plain=True)

    if cfg is None or cfg == {}:
        cfg = {}
        checkApiVersion = False
        if fileExists(configPathOld):
            isCompatible = False
    if straight:
        return cfg

    cfg.update(
        appName=appName, appPath=appPath, commit=commit, release=release, local=local
    )

    if version is None:
        version = cfg.setdefault("provenanceSpec", {}).get("version", None)
    else:
        cfg.setdefault("provenanceSpec", {})["version"] = version

    if org is None:
        org = cfg.get("provenanceSpec", {}).get("org", None)
    else:
        cfg["provenanceSpec"]["org"] = org

    if repo is None:
        repo = cfg.get("provenanceSpec", {}).get("repo", None)
    else:
        cfg["provenanceSpec"]["repo"] = repo

    if relative is None:
        relative = prefixSlash(cfg.get("provenanceSpec", {}).get("relative", None))
    else:
        cfg["provenanceSpec"]["relative"] = prefixSlash(relative)

    cfg["local"] = local
    cfg["localDir"] = getLocalDir(backend, cfg, local, version)

    avA = cfg.get("apiVersion", None)
    if isCompatible is None and checkApiVersion:
        isCompatible = avA is not None and avA == avTf
    if not isCompatible:
        if isCompatible is None:
            pass
        elif avA is None or avA < avTf:
            console(
                f"""
App `{appName}` requires API version {avA or 0} but TF provides {avTf}.
Your copy of the TF app `{appName}` is outdated for this version of TF.
Recommendation: obtain a newer version of `{appName}`.
Hint: load the app in one of the following ways:

    {org}/{repo}
    {org}/{repo}:latest
    {org}/{repo}:hot

    For example:

    The TF browser:

        tf {org}/{repo}:latest

    In a program / notebook:

        A = use('{org}/{repo}:latest', hoist=globals())

""",
                error=True,
            )
        else:
            console(
                f"""
App `{appName}` or rather `{org}/{repo}` requires API version {avA or 0}
but TF provides {avTf}.
Your TF is outdated and cannot use this version of the TF app `{org}/{repo}`.
Recommendation: upgrade TF.
Hint:

    pip install --upgrade text-fabric

""",
                error=True,
            )

    cfg["isCompatible"] = isCompatible

    if fileExists(cssPath):
        with fileOpen(cssPath) as fh:
            cfg["css"] = fh.read()
    else:
        cfg["css"] = ""

    return cfg

Find the configuration information of an app.

If there is a config.yaml file, read it and check the compatibility of the configuration settings with the current version of TF.

If there is no such file but a config.py is present, conclude that this is an older app, not compatible with TF v8.0.0 or higher.

If there are no such configuration files, fill in a few basic settings.

Parameters

moduleName : string: Name of a module under a TF app that needs to be imported.
args : mixed: The same list of arguments that is passed to App of which only the appName and the appPath are used.