Ordinamento Server

core/autoplay.py

@@ -39,166 +39,20 @@ def start(itemlist, item):
     if not config.is_xbmc():
         return itemlist
 
+    # Save the current value of "Action and Player Mode" in preferences
+    user_config_setting_action = config.get_setting("default_action")
+    # user_config_setting_player = config.get_setting("player_mode")
+
+    # Enable the "View in high quality" action (if the server returns more than one quality, eg gdrive)
+    if not user_config_setting_action: config.set_setting("default_action", 2)
+
     if config.get_setting('autoplay'):
-        url_list_valid = []
+        from core.servertools import sort_servers
-        autoplay_list = []
+        autoplay_list = sort_servers(itemlist)
-        autoplay_b = []
-        favorite_quality = []
-        favorite_servers = []
-        blacklisted_servers = config.get_setting("black_list", server='servers', default = [])
-        favorite_servers = config.get_setting('favorites_servers_list', server='servers', default = [])
 
-        from core import servertools
+        if autoplay_list:
-
+            max_intents = 5
-        servers_list = list(servertools.get_servers_list().items())
+            max_intents_servers = {}
-        for server, server_parameters in servers_list:
-            if config.get_setting('favorites_servers_list', server=server) and server.lower() not in favorite_servers:
-                favorite_servers.append(server.lower())
-
-        if not favorite_servers:
-            config.set_setting('favorites_servers_list', [], server='servers')
-            favorite_servers = []
-        else:
-            s_list = []
-            for s in favorite_servers:
-                if s not in blacklisted_servers:
-                    s_list.append(s)
-            favorite_servers = s_list
-
-        # Save the current value of "Action and Player Mode" in preferences
-        user_config_setting_action = config.get_setting("default_action")
-        # user_config_setting_player = config.get_setting("player_mode")
-
-        # Enable the "View in high quality" action (if the server returns more than one quality, eg gdrive)
-        if not user_config_setting_action: config.set_setting("default_action", 2)
-
-        # if user_config_setting_player != 0: config.set_setting("player_mode", 0)
-
-        # Priorities when ordering itemlist:
-        #       0: Servers and qualities
-        #       1: Qualities and servers
-        #       2: Servers only
-        #       3: Only qualities
-        #       4: Do not order
-
-        if config.get_setting('favorites_servers') and favorite_servers and config.get_setting('default_action'):
-            priority = 0  # 0: Servers and qualities or 1: Qualities and servers
-        elif config.get_setting('favorites_servers') and favorite_servers:
-            priority = 2  # Servers only
-        elif config.get_setting('default_action'):
-            priority = 3  # Only qualities
-        else:
-            priority = 4  # Do not order
-
-        if config.get_setting('default_action') == 1:
-            quality_list.reverse()
-        favorite_quality = quality_list
-        for item in itemlist:
-            autoplay_elem = dict()
-            b_dict = dict()
-
-            # We check that it is a video item
-            if 'server' not in item:
-                continue
-
-            if item.server.lower() in blacklisted_servers:
-                continue
-
-            # If it does not have a defined quality, it assigns a 'default' quality.
-            if item.quality.lower() not in quality_list:
-                item.quality = 'default'
-            # The list for custom settings is created
-
-            if priority < 2:  # 0: Servers and qualities or 1: Qualities and servers
-
-                # if the server and the quality are not in the favorites lists or the url is repeated, we discard the item
-                if item.server.lower() not in favorite_servers or item.quality.lower() not in favorite_quality or item.url in url_list_valid:
-                    item.type_b = True
-                    item.window = base_item.window
-                    b_dict['videoitem']= item
-                    autoplay_b.append(b_dict)
-                    continue
-                autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
-                autoplay_elem["indice_quality"] = favorite_quality.index(item.quality.lower())
-
-            elif priority == 2:  # Servers only
-
-                # if the server is not in the favorites list or the url is repeated, we discard the item
-                if item.server.lower() not in favorite_servers or item.url in url_list_valid:
-                    item.type_b = True
-                    item.window = base_item.window
-                    b_dict['videoitem'] = item
-                    autoplay_b.append(b_dict)
-                    continue
-                autoplay_elem["indice_server"] = favorite_servers.index(item.server.lower())
-
-            elif priority == 3:  # Only qualities
-
-                # if the quality is not in the favorites list or the url is repeated, we discard the item
-                if item.quality.lower() not in favorite_quality or item.url in url_list_valid:
-                    item.type_b = True
-                    item.window = base_item.window
-                    b_dict['videoitem'] = item
-                    autoplay_b.append(b_dict)
-                    continue
-                autoplay_elem["indice_quality"] = favorite_quality.index(item.quality.lower())
-
-            else:  # Do not order
-
-                # if the url is repeated, we discard the item
-                item.window = base_item.window
-                if item.url in url_list_valid:
-                    continue
-
-            # If the item reaches here we add it to the list of valid urls and to autoplay_list
-            url_list_valid.append(item.url)
-            item.plan_b=True
-            item.window = base_item.window
-            autoplay_elem['videoitem'] = item
-            autoplay_list.append(autoplay_elem)
-
-        # We order according to priority
-        if priority == 0: autoplay_list.sort(key=lambda orden: ((orden['indice_server'], orden['indice_quality']))) # Servers and qualities
-        elif priority == 1: autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server'])) # Qualities and servers
-        elif priority == 2: autoplay_list.sort(key=lambda orden: (orden['indice_server'])) # Servers only
-        elif priority == 3: autoplay_list.sort(key=lambda orden: (orden['indice_quality'])) # Only qualities
-
-        logger.debug('PRIORITY',priority, autoplay_list)
-
-        # if quality priority is active
-        if priority == 0 and config.get_setting('quality_priority'):
-            max_quality = autoplay_list[0]["indice_quality"] if autoplay_list and "indice_quality" in autoplay_list[0] else 0
-            for n, item in enumerate(itemlist):
-                if 'server' not in item:
-                    continue
-
-                if item.server.lower() in blacklisted_servers:
-                    continue
-
-                # If it does not have a defined quality, it assigns a 'default' quality.
-                if item.quality == '':
-                    item.quality = 'default'
-
-                if favorite_quality.index(item.quality.lower()) < max_quality:
-                    item.type_b = False
-                    autoplay_elem["indice_server"] = n
-                    autoplay_elem["indice_quality"] = favorite_quality.index(item.quality.lower())
-                    autoplay_elem['videoitem'] = item
-                    autoplay_list.append(autoplay_elem)
-            autoplay_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server']))
-
-        # Plan b is prepared, in case it is active the non-favorite elements are added at the end
-        # try: plan_b = settings_node['plan_b']
-        # except: 
-        plan_b = True
-        text_b = ''
-        if plan_b: autoplay_list.extend(autoplay_b)
-        # If there are elements in the autoplay list, an attempt is made to reproduce each element, until one is found or all fail.
-
-        if autoplay_list or (plan_b and autoplay_b):
-
-            max_intentos = 5
-            max_intentos_servers = {}
 
             # If something is playing it stops playing
             if platformtools.is_playing():
@@ -206,27 +60,23 @@ def start(itemlist, item):
 
             for autoplay_elem in autoplay_list:
                 play_item = Item
-                channel_id = autoplay_elem['videoitem'].channel
+                channel_id = autoplay_elem.channel
-                if autoplay_elem['videoitem'].channel == 'videolibrary':
+                if autoplay_elem.channel == 'videolibrary':
-                    channel_id = autoplay_elem['videoitem'].contentChannel
+                    channel_id = autoplay_elem.contentChannel
 
-                # If it is not a favorite element if you add the text plan b
-                if autoplay_elem['videoitem'].type_b:
-                    text_b = '(Plan B)'
                 if not platformtools.is_playing() and not PLAYED:
-                    videoitem = autoplay_elem['videoitem']
+                    videoitem = autoplay_elem
-                    if videoitem.server.lower() not in max_intentos_servers:
+                    if videoitem.server.lower() not in max_intents_servers:
-                        max_intentos_servers[videoitem.server.lower()] = max_intentos
+                        max_intents_servers[videoitem.server.lower()] = max_intents
 
                     # If the maximum number of attempts of this server have been reached, we jump to the next
-                    if max_intentos_servers[videoitem.server.lower()] == 0:
+                    if max_intents_servers[videoitem.server.lower()] == 0:
                         continue
 
-                    lang = " "
+                    lang = " [{}]".format(videoitem.language) if videoitem.language else ''
-                    if hasattr(videoitem, 'language') and videoitem.language != "":
+                    quality = ' [{}]'.format(videoitem.quality) if videoitem.quality and videoitem.quality != 'default' else ''
-                        lang = " '%s' " % videoitem.language
                     name = servername(videoitem.server) 
-                    platformtools.dialog_notification("AutoPlay %s" %text_b, "%s%s%s" % (name, lang, videoitem.quality.upper()), sound=False)
+                    platformtools.dialog_notification('AutoPlay', '{}{}{}'.format(name, lang, quality), sound=False)
 
                     # Try to play the links If the channel has its own play method, use it
                     try: channel = __import__('channels.%s' % channel_id, None, None, ["channels.%s" % channel_id])
@@ -251,7 +101,7 @@ def start(itemlist, item):
                             platformtools.play_video(videoitem, autoplay=True)
                     except:
                         pass
-                    sleep(3)
+                    # sleep(3)
                     try:
                         if platformtools.is_playing():
                             PLAYED = True
@@ -260,13 +110,13 @@ def start(itemlist, item):
                         logger.debug(str(len(autoplay_list)))
 
                     # If we have come this far, it is because it could not be reproduced
-                    max_intentos_servers[videoitem.server.lower()] -= 1
+                    max_intents_servers[videoitem.server.lower()] -= 1
 
                     # If the maximum number of attempts of this server has been reached, ask if we want to continue testing or ignore it.
-                    if max_intentos_servers[videoitem.server.lower()] == 0:
+                    if max_intents_servers[videoitem.server.lower()] == 0:
                         text = config.get_localized_string(60072) % name
                         if not platformtools.dialog_yesno("AutoPlay", text, config.get_localized_string(60073)):
-                            max_intentos_servers[videoitem.server.lower()] = max_intentos
+                            max_intents_servers[videoitem.server.lower()] = max_intents
 
                     # If there are no items in the list, it is reported
                     if autoplay_elem == autoplay_list[-1]:

core/servertools.py

@@ -9,24 +9,17 @@ import sys
 PY3 = False
 if sys.version_info[0] >= 3: PY3 = True; unicode = str; unichr = chr; long = int
 
-if PY3:
+if PY3: import urllib.parse as urlparse
-    #from future import standard_library
+else: import urlparse
-    #standard_library.install_aliases()
-    import urllib.parse as urlparse                             #It is very slow in PY2. In PY3 it is native
-else:
-    import urlparse                                             # We use the native of PY2 which is faster
 
 from future.builtins import range
 from past.utils import old_div
 
 import re
 
-from core import filetools
+from core import filetools, httptools, jsontools
-from core import httptools
-from core import jsontools
 from core.item import Item
-from platformcode import config, logger
+from platformcode import config, logger, platformtools
-from platformcode import platformtools
 from lib import unshortenit
 
 dict_servers_parameters = {}
@@ -522,26 +515,6 @@ def get_server_parameters(server):
     return dict_servers_parameters[server]
 
 
-# def get_server_json(server_name):
-#     # logger.info("server_name=" + server_name)
-#     try:
-#         server_path = filetools.join(config.get_runtime_path(), "servers", server_name + ".json")
-#         if not filetools.exists(server_path):
-#             server_path = filetools.join(config.get_runtime_path(), "servers", "debriders", server_name + ".json")
-#
-#         # logger.info("server_path=" + server_path)
-#         server_json = jsontools.load(filetools.read(server_path))
-#         # logger.info("server_json= %s" % server_json)
-#
-#     except Exception as ex:
-#         template = "An exception of type %s occured. Arguments:\n%r"
-#         message = template % (type(ex).__name__, ex.args)
-#         logger.error(" %s" % message)
-#         server_json = None
-#
-#     return server_json
-
-
 def get_server_host(server_name):
     from core import scrapertools
     return [scrapertools.get_domain_from_url(pattern['url']) for pattern in get_server_parameters(server_name)['find_videos']['patterns']]
@@ -669,9 +642,10 @@ def get_servers_list():
         for server in filetools.listdir(filetools.join(config.get_runtime_path(), "servers")):
             if server.endswith(".json") and not server == "version.json":
                 server_parameters = get_server_parameters(server)
-                server_list[server.split(".")[0]] = server_parameters
+                if server_parameters['active']:
+                    server_list[server.split(".")[0]] = server_parameters
 
-        # if type(server_list) != dict: server_list = sort_servers(server_list)
+        if type(server_list) != dict: server_list = sort_servers(server_list)
     return server_list
 
 
@@ -699,13 +673,96 @@ def sort_servers(servers_list):
     :param servers_list: List of servers to order. The items in the servers_list can be strings or Item objects. In which case it is necessary that they have an item.server attribute of type str.
     :return: List of the same type of objects as servers_list ordered according to the favorite servers.
     """
-    if servers_list:
+    if not servers_list:
-        if isinstance(servers_list[0], Item):
+        return []
-            servers_list = sorted(servers_list, key=lambda x: config.get_setting("favorites_servers_list", server=x.server, default=999))
-        else:
-            servers_list = sorted(servers_list, key=lambda x: config.get_setting("favorites_servers_list", server=x, default=999))
 
-    return servers_list
+    blacklisted_servers = config.get_setting("black_list", server='servers', default=[])
+    favorite_servers = config.get_setting('favorites_servers_list', server='servers', default=[])
+    favorite_servers = [s for s in favorite_servers if s not in blacklisted_servers]
+    if isinstance(servers_list[0], str):
+        servers_list = sorted(servers_list, key=lambda x: favorite_servers.index(x) if x in favorite_servers else 999)
+        return servers_list
+
+    quality_list = ['4k', '2160p', '2160', '4k2160p', '4k2160', '4k 2160p', '4k 2160', '2k',
+                    'fullhd', 'fullhd 1080', 'fullhd 1080p', 'full hd', 'full hd 1080', 'full hd 1080p', 'hd1080', 'hd1080p', 'hd 1080', 'hd 1080p', '1080', '1080p',
+                    'hd', 'hd720', 'hd720p', 'hd 720', 'hd 720p', '720', '720p', 'hdtv',
+                    'sd', '480p', '480', '360p', '360', '240p', '240',
+                    '']
+
+    sorted_list = []
+    url_list_valid = []
+    favorite_quality = []
+
+    # Priorities when ordering itemlist:
+    #       0: Servers and qualities
+    #       1: Servers only
+    #       2: Only qualities
+    #       3: Do not order
+
+    if config.get_setting('favorites_servers') and favorite_servers and config.get_setting('default_action'):
+        priority = 0  # 0: Servers and qualities
+    elif config.get_setting('favorites_servers') and favorite_servers:
+        priority = 1  # Servers only
+    elif config.get_setting('default_action'):
+        priority = 2  # Only qualities
+    else:
+        priority = 3  # Do not order
+
+    if config.get_setting('default_action') == 1:
+        quality_list.reverse()
+    favorite_quality = quality_list
+    for item in servers_list:
+        element = dict()
+
+        # We check that it is a video item
+        if 'server' not in item:
+            continue
+
+        if item.server.lower() in blacklisted_servers:
+            continue
+
+
+        if priority < 2:  # 0: Servers and qualities or 1: Qualities and servers
+            element["indice_server"] = favorite_servers.index(item.server.lower()) if item.server.lower() in favorite_servers else 999
+            element["indice_quality"] = favorite_quality.index(item.quality.lower())
+
+        elif priority == 2:  # Servers only
+            element["indice_server"] = favorite_servers.index(item.server.lower())
+
+        elif priority == 3:  # Only qualities
+            element["indice_quality"] = favorite_quality.index(item.quality.lower())
+
+        else:  # Do not order
+            if item.url in url_list_valid:
+                continue
+
+        element['videoitem'] = item
+        sorted_list.append(element)
+
+
+    # We order according to priority
+    if priority == 0: sorted_list.sort(key=lambda orden: ((orden['indice_server'], orden['indice_quality']))) # Servers and qualities
+    elif priority == 1: sorted_list.sort(key=lambda orden: (orden['indice_server'])) # Servers only
+    elif priority == 3: sorted_list.sort(key=lambda orden: (orden['indice_quality'])) # Only qualities
+
+
+    # if quality priority is active
+    if priority == 0 and config.get_setting('quality_priority'):
+        max_quality = sorted_list[0]["indice_quality"] if sorted_list and "indice_quality" in sorted_list[0] else 0
+        for n, item in enumerate(servers_list):
+
+            if not item.server or item.server.lower() in blacklisted_servers:
+                continue
+
+            if favorite_quality.index(item.quality.lower()) < max_quality:
+                element["indice_server"] = n
+                element["indice_quality"] = favorite_quality.index(item.quality.lower())
+                element['videoitem'] = item
+                sorted_list.append(element)
+
+        sorted_list.sort(key=lambda orden: (orden['indice_quality'], orden['indice_server']))
+
+    return [v['videoitem'] for v in sorted_list if v]
 
 
 # Checking links
@@ -733,10 +790,11 @@ def check_list_links(itemlist, numero='', timeout=3):
                 it = res[0]
                 verificacion = res[1]
                 it.title = verificacion + ' ' + it.title.strip()
-                logger.info('VERIFICATION= ' + verificacion)
+                logger.debug('VERIFICATION= ' + verificacion)
                 it.alive = verificacion
     return itemlist
 
+
 def check_video_link(item, timeout=3):
     """
         Check if the link to a video is valid and return a 2-position string with verification.
@@ -777,11 +835,30 @@ def check_video_link(item, timeout=3):
             httptools.HTTPTOOLS_DEFAULT_DOWNLOAD_TIMEOUT = ant_timeout  # Restore download time
             return item, resultado
 
-    logger.debug("[check_video_link] There is no test_video_exists for server: %s" % server)
+    logger.debug("[check_video_link] There is no test_video_exists for server:", server)
     return item, NK
 
+
 def translate_server_name(name):
-    if '@' in name:
+    if '@' in name: return config.get_localized_string(int(name.replace('@','')))
-        return config.get_localized_string(int(name.replace('@','')))
+    else: return name
-    else:
+
-        return name
+
+# def get_server_json(server_name):
+#     # logger.info("server_name=" + server_name)
+#     try:
+#         server_path = filetools.join(config.get_runtime_path(), "servers", server_name + ".json")
+#         if not filetools.exists(server_path):
+#             server_path = filetools.join(config.get_runtime_path(), "servers", "debriders", server_name + ".json")
+#
+#         # logger.info("server_path=" + server_path)
+#         server_json = jsontools.load(filetools.read(server_path))
+#         # logger.info("server_json= %s" % server_json)
+#
+#     except Exception as ex:
+#         template = "An exception of type %s occured. Arguments:\n%r"
+#         message = template % (type(ex).__name__, ex.args)
+#         logger.error(" %s" % message)
+#         server_json = None
+#
+#     return server_json

resources/settings.xml

@@ -21,8 +21,8 @@
         <setting id="player_mode" type="select" lvalues="30026|30027|30028|30029" label="30044" default="1"/>
         <setting id="default_action" type="select" lvalues="30006|30007|30008" label="30005" default="0"/>
         <setting id="autoplay" type="bool" label="70562" default="false" visible="true"/>
-        <setting id="servers_favorites" visible="eq(-1,true)" subsetting="true" type="action" label="60551" action="RunPlugin(plugin://plugin.video.kod/?ew0KICAgICJhY3Rpb24iOiAic2VydmVyc19mYXZvcml0ZXMiLA0KICAgICJjaGFubmVsIjogInNldHRpbmciDQp9==)"/>
+        <setting id="servers_favorites" visible="true" type="action" label="60551" action="RunPlugin(plugin://plugin.video.kod/?ew0KICAgICJhY3Rpb24iOiAic2VydmVyc19mYXZvcml0ZXMiLA0KICAgICJjaGFubmVsIjogInNldHRpbmciDQp9==)"/>
-        <setting id="servers_blacklist" visible="eq(-2,true)" subsetting="true" type="action" label="60550" action="RunPlugin(plugin://plugin.video.kod/?ew0KICAgICJhY3Rpb24iOiAic2VydmVyc19ibGFja2xpc3QiLA0KICAgICJjaGFubmVsIjogInNldHRpbmciDQp9==)"/>
+        <setting id="servers_blacklist" visible="true" type="action" label="60550" action="RunPlugin(plugin://plugin.video.kod/?ew0KICAgICJhY3Rpb24iOiAic2VydmVyc19ibGFja2xpc3QiLA0KICAgICJjaGFubmVsIjogInNldHRpbmciDQp9==)"/>
 
         <!-- <setting id="hide_servers" type="bool" label="70747" default="false" visible="eq(-1,true)" subsetting="true"/> -->
         <setting id="checklinks" type="bool" label="30020" default="false"/>

specials/setting.py

@@ -265,19 +265,19 @@ def servers_blacklist(item):
 
 
 def cb_servers_blacklist(dict_values):
-    blaklisted = []
+    blaklisted = [k for k in dict_values.keys()]
-    progreso = platformtools.dialog_progress(config.get_localized_string(60557), config.get_localized_string(60558))
+    # progreso = platformtools.dialog_progress(config.get_localized_string(60557), config.get_localized_string(60558))
-    n = len(dict_values)
+    # n = len(dict_values)
-    i = 1
+    # i = 1
-    for k, v in list(dict_values.items()):
+    # for k, v in list(dict_values.items()):
-        if v:  # If the server is blacklisted it cannot be in the favorites list
+    #     if v:  # If the server is blacklisted it cannot be in the favorites list
-            config.set_setting("favorites_servers_list", 0, server=k)
+    #         config.set_setting("favorites_servers_list", 0, server=k)
-            blaklisted.append(k)
+    #         blaklisted.append(k)
-            progreso.update(old_div((i * 100), n), config.get_localized_string(60559) % k)
+    #         progreso.update(old_div((i * 100), n), config.get_localized_string(60559) % k)
-        i += 1
+    #     i += 1
-    config.set_setting("black_list", blaklisted, server='servers')
+    # config.set_setting("black_list", blaklisted, server='servers')
 
-    progreso.close()
+    # progreso.close()
 
 
 def servers_favorites(item):
@@ -302,16 +302,16 @@ def servers_favorites(item):
         dict_values['favorites_servers'] = False
 
     server_names = [config.get_localized_string(59992)]
+    favorites = config.get_setting("favorites_servers_list", server='servers', default=[])
+    blacklisted = config.get_setting("black_list", server='servers', default=[])
 
     for server in sorted(server_list.keys()):
-        if config.get_setting("black_list", server=server):
+        if server in blacklisted or config.get_setting("black_list", server=server):
             continue
 
         server_names.append(server_list[server]['name'])
-
+        if server in favorites:
-        orden = config.get_setting("favorites_servers_list", server=server, default=999)
+            orden = favorites.index(server) + 1
-        if type(orden) != int: orden = 999
-        if orden > 0:
             dict_values[orden] = len(server_names) - 1
 
     for x in range(1, 12):
@@ -331,7 +331,6 @@ def servers_favorites(item):
 def cb_servers_favorites(server_names, dict_values):
     dict_name = {}
     dict_favorites = {}
-    progreso = platformtools.dialog_progress(config.get_localized_string(60557), config.get_localized_string(60558))
 
     for i, v in list(dict_values.items()):
         if i == "favorites_servers":
@@ -342,30 +341,17 @@ def cb_servers_favorites(server_names, dict_values):
             dict_name[server_names[v]] = int(i)
 
     servers_list = list(servertools.get_servers_list().items())
-    n = len(servers_list)
-    i = 1
     for server, server_parameters in servers_list:
         if server_parameters['name'] in list(dict_name.keys()):
             dict_favorites[dict_name[server_parameters['name']]] = server
-            config.set_setting("favorites_servers_list", dict_name[server_parameters['name']], server=server)
-        else:
-            config.set_setting("favorites_servers_list", 999, server=server)
-        progreso.update(old_div((i * 100), n), config.get_localized_string(60559) % server_parameters['name'])
-        i += 1
 
-    c = 1
+    favorites_servers_list = [dict_favorites[k] for k in sorted(dict_favorites.keys())]
-    logger.debug(dict_favorites)
+
-    favorites_servers_list = []
-    while c in dict_favorites:
-        favorites_servers_list.append(dict_favorites[c])
-        c += 1
     config.set_setting("favorites_servers_list", favorites_servers_list, server='servers')
 
-    if not dict_name:  # If there is no server in the list, deactivate it
+    if not favorites_servers_list:  # If there is no server in the list, deactivate it
         config.set_setting("favorites_servers", False)
 
-    progreso.close()
-
 
 def settings(item):
     config.open_settings()