FastLBRY-terminal/flbry/plugin.py

#####################################################################
#                                                                   #
#  THIS IS A SOURCE CODE FILE FROM A PROGRAM TO INTERACT WITH THE   #
# LBRY PROTOCOL ( lbry.com ). IT WILL USE THE LBRY SDK ( lbrynet )  #
# FROM THEIR REPOSITORY ( https://github.com/lbryio/lbry-sdk )      #
# WHICH I GONNA PRESENT TO YOU AS A BINARY. SINCE I DID NOT DEVELOP #
# IT AND I'M LAZY TO INTEGRATE IN A MORE SMART WAY. THE SOURCE CODE #
# OF THE SDK IS AVAILABLE IN THE REPOSITORY MENTIONED ABOVE.        #
#                                                                   #
#      ALL THE CODE IN THIS REPOSITORY INCLUDING THIS FILE IS       #
# (C) J.Y.Amihud and Other Contributors 2021. EXCEPT THE LBRY SDK.  #
# YOU CAN USE THIS FILE AND ANY OTHER FILE IN THIS REPOSITORY UNDER #
# THE TERMS OF GNU GENERAL PUBLIC LICENSE VERSION 3 OR ANY LATER    #
# VERSION. TO FIND THE FULL TEXT OF THE LICENSE GO TO THE GNU.ORG   #
# WEBSITE AT ( https://www.gnu.org/licenses/gpl-3.0.html ).         #
#                                                                   #
# THE LBRY SDK IS UNFORTUNATELY UNDER THE MIT LICENSE. IF YOU ARE   #
# NOT INTENDING TO USE MY CODE AND JUST THE SDK. YOU CAN FIND IT ON #
# THEIR OFFICIAL REPOSITORY ABOVE. THEIR LICENSE CHOICE DOES NOT    #
# SPREAD ONTO THIS PROJECT. DON'T GET A FALSE ASSUMPTION THAT SINCE #
# THEY USE A PUSH-OVER LICENSE, I GONNA DO THE SAME. I'M NOT.       #
#                                                                   #
# THE LICENSE CHOSEN FOR THIS PROJECT WILL PROTECT THE 4 ESSENTIAL  #
# FREEDOMS OF THE USER FURTHER, BY NOT ALLOWING ANY WHO TO CHANGE   #
# THE LICENSE AT WILL. SO NO PROPRIETARY SOFTWARE DEVELOPER COULD   #
# TAKE THIS CODE AND MAKE THEIR USER-SUBJUGATING SOFTWARE FROM IT.  #
#                                                                   #
#####################################################################

# This file will be dealing with handling extensions aka plugins.

import inspect
import hashlib
import json
import sys
import os
import urllib.request

from flbry import settings
from flbry.variables import *
from flbry import markdown
from flbry import publish

def run(args=[], command=False, address=None, execute=True, run_only=None):

    # This function will pass arguments to the plugin function.
    # The plugin will edit those arguments and return them back.
    # This is when we return those arguments back to the function
    # from where the plugin.run() was called.

    # To make it so anybody could extend any part of the software
    # without adding new paths to things inside the software code,
    # we are going to use an address of the function.

    # So for example from 'flbry' you've imported 'markdown' and
    # now it runs the Open() function. If inside that function we
    # will add plugin.run(), the resulting function address will be
    # 'flbry.markdwon.Open'

    # This is how we get the address:
    if not address:
        address = inspect.stack()[1].filename
        address = address.replace(os.getcwd(), "").replace(".py", "")
        address = address.replace("/",".")[1:]
        address = address +"."+ inspect.stack()[1].function


    # Now we want to get files from the plugins folder.
    plugins_folder = settings.get_settings_folder("flbry/plugins/")
    sys.path.append(settings.get_settings_folder())

    # Before we import we need to make sure that __init__.py exists
    # this is an empty file that will tell python that this folder is
    # indeed a module.
    if not os.path.exists(plugins_folder+"__init__.py"):
        t = open(plugins_folder+"__init__.py", "w")
        t.close()

    # Now let's import the files from plugins
    for p in os.listdir(plugins_folder):
        m = p[:-3]

        # If only a certain plugin is to run
        if run_only and m != run_only:
            continue
        

        # Ignore the __init__.py
        if m == "__init__":
            continue
        
        if p.endswith(".py") and enabled(m):

            exec("from plugins import "+m)

            # Let's get the plugin_data of the plugin
            try:
                plugin_data = eval(m+".plugin_data")
            except:
                continue

            # Now let's update the data of the plugin_data
            # into the info of the plugin settings.
            plugin_info = {}
            for i in plugin_data:
                if i != "functions":
                    plugin_info[i] = plugin_data[i]

            enabled(m, plugin_info=plugin_info)
            
            # Now that we have it let's compare it to the
            # address of the function from which it's running
            for func in plugin_data["functions"]:
                if address in func and not command and not func["command"] and execute:
                    args = func[address](args)
                elif address in func and command and command.startswith(func["command"]) and execute:
                    args = func[address](command, args)

                # Adding functions into completer
                if address in func and func["command"]:
                    complete([func["command"]], add=True)

        # If we run only one plugin and the plugin is disabled.
        elif run_only and run_only == m:
            center("Plugin '"+m+"' is disabled!", "bdrd")

    return args

def check_settings_exists():
    
    # Insures that ~/.local/share/flbry plugins.json exits
    if not os.path.exists(settings.get_settings_folder()+"plugins.json"):
        with open(settings.get_settings_folder()+"plugins.json", 'w') as f:
                json.dump({}, f, indent=4, sort_keys=True)
        
    

def enabled(plugin_name, full_report=False, flip=False, plugin_info={}):

    # This function will check whether the plugin is enabled in
    # plugin settings.

    # Firs let's make sure that the file exist
    check_settings_exists()

    # Then let's open the file

    with open(settings.get_settings_folder()+"plugins.json") as f:
            data = json.load(f)


    # Adding a missing plugin
    default = {"active":False,
               "info":{"title":plugin_name,
                       "author":None,
                       "license":None,
                       "flbry":"terminal",
                       "description":None}}
    
    if plugin_name not in data:
        data[plugin_name] = default

    # Overwriting
    if flip:
        data[plugin_name]["active"] = not data[plugin_name]["active"]

    # Updating info
    if plugin_info:
        data[plugin_name]["info"] = plugin_info

    # Saving plugins file
    with open(settings.get_settings_folder()+"plugins.json", 'w') as f:
                json.dump(data, f, indent=4, sort_keys=True)

    # Returning data
    if full_report:
        return data[plugin_name]
    else:
        return data[plugin_name]["active"]

def manager(search=""):

    # This function gives a settings promt to set various
    # settings on plugins.

    to_text = True

    plugins_commands = [
        "help",
        "read",
        "set",
        "publish",
        "description"
        
    ]

    
    
    while True:

        complete(plugins_commands)
        print()
        
        check_settings_exists()
        with open(settings.get_settings_folder()+"plugins.json") as f:
                data = json.load(f)


        data = run(data) # Updating the plugins

        d = {"categories":["Active", "Title", "Author", "License"],
             "size":[1, 3, 2, 2],
             "data":[]}

        for plugin in data:

            # Make sure you can get the nessesary data
            # even if it's somewhat corrupted.

            active = "[ ]"
            title = plugin
            description = ""
            LICENSE = ""
            author = ""
            try:
                active = data[plugin]["active"]
            except:
                pass
            try:
                if data[plugin]["info"]["title"]:
                    title = data[plugin]["info"]["title"]
            except:
                pass
            try:
                if data[plugin]["info"]["description"]:
                    description = data[plugin]["info"]["description"]
            except:
                pass
            try:
                if data[plugin]["info"]["license"]:
                    LICENSE = data[plugin]["info"]["license"]
            except:
                pass
            try:
                if data[plugin]["info"]["author"]:
                    author = data[plugin]["info"]["author"]
            except:
                pass

            # Make so the search works.
            if search and \
             search.lower() not in title.lower() \
             and search.lower() not in author.lower() \
             and search.lower() not in description.lower() \
             and search.lower() not in LICENSE.lower():
                continue

            # Let's add the plugin into the data
            d["data"].append([active, title, author, LICENSE])

        table(d)
        center("")

        # Now let's start the madness

        print()
        c = input(typing_dots("Type 'help' for more info.", to_text))
        to_text = False
        
        if not c:
            break

        try:
            c = int(c)
            enabled(list(data.keys())[c], flip=True)
            continue
        except:
            pass
    
        if c.startswith("description"):

            cn = get_cn(c, "Which plugin?")
            
            try:
                description = list(data.values())[cn]["info"]["description"]
                savedes = open("/tmp/fastlbrylastdescription.md", "w")
                savedes.write(description)
                savedes.close()
                markdown.draw("/tmp/fastlbrylastdescription.md", "Description")
            except:
                
                center("This plugin has no description.")

        elif c.startswith("read"):
            
            cn = get_cn(c, "Which plugin?")

            try:
                
                plugin_name = list(data.keys())[cn]
                plugin_file = settings.get_settings_folder("flbry/plugins/")+plugin_name+".py"
                markdown.draw(plugin_file, plugin_name+" Source Code", False)
            except:
                center("Plugin is deleted or corrupted", "bdrd")

        elif c.startswith("set"):

            cn = get_cn(c, "Which plugin?")

            run([None], address="settings", run_only=list(data.keys())[cn])
            
        elif c.startswith("publish"):

            cn = get_cn(c, "Which plugin?")

            try:
                plugin_name = list(data.keys())[cn]
                plugin_file = settings.get_settings_folder("flbry/plugins/")+plugin_name+".py"
                publish_plugin(plugin_file, list(data.values())[cn]["info"])
            except:
                center("Plugin is deleted or corrupted", "bdrd")
            
        elif c == "help":
            markdown.draw("help/plugins.md", "Plugins Help")

def publish_plugin(filename, info):
    """Helps the user publish a plugin"""

    print()

    # Check if the plugin has a license in the info and get the name and link to it
    # Getting the link only works if the license it a SPDX Lincense Identifier: https://spdx.org/licenses/
    if "license" in info:
        l = spdx_license(info["license"])
        if "link" in l:
            info["license_url"] = l["link"]
        info["license_name"] = l["name"]
        info.pop("license")

    info["file"] = filename

    if not "version" in info:
        info["version"] = 1.0

    if not "fee" in info:
        info["fee"] = 0

    to_text = True

    publish_commands = [
        "help",
        "file",
        "link",
        "title",
        "author",
        "license",
        "description",
        "publish",
        "fastlbry",
        "version",
        "fee",
        "publish_file"
    ]

    while True:
        complete(publish_commands)

        if "license_name" in info:
            d_license = info["license_name"]
        elif "license" in info:
            d_license = info["license"]
        else:
            d_license = "[no license]"

        d = {"categories":[ "Title", "Version", "Fee", "Author", "License"],
             "size":[ 3, 1, 1, 2, 2],
             "data":[[
                 info["title"],
                 info["version"],
                 str(info["fee"]),
                 info["author"],
                 d_license
             ]]}

        table(d, False)

        if not "description" in info:
            info["description"] = ""

        d = {"categories": ["Description"],
                "size": [1],
                "data": [[info["description"]]]}

        table(d, False)

        d = {"categories": ["File or Link", "FastLBRY Variant"],
                "size": [3, 1],
                "data": [[info["file"], info["flbry"]]]}

        table(d, False)
        center("")

        c = input(typing_dots("Type 'help' for more info.", to_text, give_space=True))
        to_text = False

        if not c:
            break

        elif c == "publish_file":
            
            try:
                info["file"] = publish.configure(info["file"])['outputs'][0]['permanent_url']
            except Exception as e:
                center("Error: "+str(e), "bdrd")

        
        elif c.startswith(("file", "link")):
            if " " in c:
                info["file"] = c[c.find(" ")+1:]
            else:
                info["file"] = input(typing_dots("File or URL", give_space=True, to_add_dots=True))

        
        elif c.startswith("title"):
            if " " in c:
                info["title"] = c[c.find(" ")+1:]
            else:
                info["title"] = input(typing_dots("Plugin title", give_space=True, to_add_dots=True))

        elif c.startswith("author"):
            if " " in c:
                info["author"] = c[c.find(" ")+1:]
            else:
                info["author"] = input(typing_dots("Author", give_space=True, to_add_dots=True))

        elif c == "license":
            info.pop("license", None)
            info["license_name"], info["license_url"] = choose_license()

        elif c.startswith("description"):
            c = c + ' '
            a = c[c.find(" "):]
            if len(a) > 1:
                info["description"] = file_or_editor(a, "Type the description here. Don't forget to save. Then return to FastLBRY.")
            else:
                info["description"] = input(typing_dots("Description", give_space=True, to_add_dots=True))

        elif c.startswith("version"):
            if " " in c:
                info["version"] = c[c.find(" ")+1:]
            else:
                info["version"] = input(typing_dots("Version number", give_space=True, to_add_dots=True))

        elif c.startswith("fee"):
            if " " in c:
                info["fee"] = c[c.find(" ")+1:]
            else:
                info["fee"] = input(typing_dots("Fee", give_space=True, to_add_dots=True))

        elif c.startswith("fastlbry"):
            if " " in c:
                info["flbry"] = c[c.find(" ")+1:]
            else:
                complete(["terminal", "gtk", "all"])
                info["flbry"] = input(typing_dots("FastLBRY variant", give_space=True, to_add_dots=True))

        elif c == "publish":
            try:
                x = publish_plugin_blob(info["file"], info)
                if x:
                    return
            except Exception as e:
                center("Error publishing plugin: "+str(e), "bdrd")

        elif c == "help":
            markdown.draw("help/publish_plugins.md", "Plugin Publishing Help")
            
def publish_plugin_blob(filename, info):
    """Creates and publishes blobs for FastLBRY plugins"""

    filename = os.path.expanduser(filename)

    

    # Try to open the file and if that fails treat it as a URL
    try:
        pf = open(filename, "rb")
    except FileNotFoundError:
        if filename.startswith("lbry://"):
            filename = filename.replace("lbry://", "https://spee.ch/")

        try:
            pf = urllib.request.urlopen(filename)
            if not info["fee"] in [0, "0"]:
                center("Plugin file is a link, fee will be ignored", "bdrd")
        except urllib.error.URLError:
            center("File is not a valid file or URL", "bdrd")
            return

    # We need a hash of the file for security reasons
    pf = pf.read()

    sha512 = hashlib.sha512(pf).hexdigest()
    info["sha512"] = sha512

    # Try to upload the plugin to LBRY
    info["file"] = publish.speech_upload(info["file"], name=sha512, fee=info["fee"])

    # Saving it to json for publishing
    with open('/tmp/flbrypublishpluginblob.json', 'w') as f:
                json.dump(info, f, indent=4, sort_keys=True)

    data = {"name":info["title"],
            "bid":0.001,
            "file_path":'/tmp/flbrypublishpluginblob.json',
            "title":info["title"],
            "license":info["license_name"],
            "thumbnail_url":"",
            "channel_id":"",
            "channel_name":"",
            "fee_amount":0,
            "tags":["FastLBRY-terminal-plugin-blob-json-file"]
        }

    if "description" in info:
        data["description"] = info["description"]

    if "license_url" in info:
        data["license_url"] = info["license_url"],

    publish.configure('/tmp/flbrypublishpluginblob.json', data)
    return True