Ignore:
Timestamp:
Apr 18, 2018, 2:28:43 PM (2 years ago)
Author:
Juanma
Message:

Restored version from ppa

Location:
lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/appImageManager.py

    r7139 r7143  
    11#The name of the main class must match the file name in lowercase
    2 import re
    32import urllib
    43from urllib.request import Request
    … …  
    76import json
    87import os
     8from subprocess import call
    99import sys
    1010import threading
    11 import queue
     11from bs4 import BeautifulSoup
     12import random
    1213import time
    13 import random
    1414import gi
    1515from gi.repository import Gio
    1616gi.require_version('AppStreamGlib', '1.0')
    1717from gi.repository import AppStreamGlib as appstream
    18 from bs4 import BeautifulSoup
    19 #from subprocess import call
    2018
    2119class appimagemanager:
    2220        def __init__(self):
    23                 self.dbg=True
     21                self.dbg=False
    2422                self.progress=0
    2523                self.partial_progress=0
    … …  
    2826                self.result['data']={}
    2927                self.result['status']={}
    30                 self.cache_dir=os.getenv("HOME")+"/.cache/lliurex-store"
    31                 self.icons_dir=self.cache_dir+"/icons"
    32                 self.bundles_dir=self.cache_dir+"/bundles/appimage"
     28                self.conf_dir=os.getenv("HOME")+"/.cache/lliurex-store"
     29                self.bundles_dir=self.conf_dir+"/bundles"
    3330                self.bundle_types=['appimg']
    34                 self.appimage_dir=os.getenv("HOME")+"/.lliurex-store/appimg"
     31                self.appimage_dir=os.getenv("HOME")+"/.local/bin/"
    3532                #To get the description of an app we must go to a specific url defined in url_info.
    3633                #$(appname) we'll be replaced with the appname so the url matches the right one.
    3734                #If other site has other url naming convention it'll be mandatory to define it with the appropiate replacements
    38                 self.repos={'appimagehub':{'type':'json','url':'https://appimage.github.io/feed.json','url_info':''}}
    39                 #Appimges not stored in a repo must be listed in this file, providing the download url and the info url (if there's any)
     35                self.repos={'probono':{'url':'https://dl.bintray.com/probono/AppImages', 'url_info':'https://bintray.com/probono/AppImages/$(appname)'}}
     36                #Appimges not stored in a repo must be listed here, providing the download url and the info url (if there's any)
    4037                self.external_appimages="/usr/share/lliurex-store/files/external_appimages.json"
    41                 #Queue pool
    42                 self.queue=queue.Queue()
    4338                self.disabled=False
     39                self.count=0
    4440        #def __init__
    4541
    … …  
    6561                else:
    6662                        self.store=appstream.Store()
    67                 self.appimage_store=appstream.Store()
    6863                self.progress=0
    6964                self.result['status']={'status':-1,'msg':''}
    … …  
    7671                        self._chk_installDir()
    7772                        if action=='load':
    78                                 self.result['data']=self._load_appimage_store()
     73                                self.result['data']=self._load_appimage_store(self.store)
    7974                        else:
    8075                                for app_info in applist:
    … …  
    168163        #def _remove_appimage
    169164
    170         def _load_appimage_store(self,store=None):
    171                 self._get_bundles_catalogue()
     165        def _get_info(self,app_info):
     166                app_info['state']='available'
     167                if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
     168                        app_info['state']='installed'
     169                #Get size
     170                appimage_url=app_info['homepage']+'/'+app_info['package']
     171                dest_path=self.appimage_dir+'/'+app_info['package']
     172                if appimage_url:
     173                        try:
     174                                with urllib.request.urlopen(appimage_url) as response:
     175                                        app_info['size']=(response.info()['Content-Length'])
     176                        except:
     177                                app_info['size']=0
     178                self._set_status(0)
     179                self.partial_progress=100
     180                return(app_info)
     181        #def _get_info
     182
     183        def _load_appimage_store(self,store):
     184                self._download_bundles_catalogue()
    172185                if os.path.exists(self.bundles_dir):
    173186                        for bundle_type in self.bundle_types:
    … …  
    194207        #def _generic_file_load
    195208
    196         def _get_bundles_catalogue(self):
     209        def _download_bundles_catalogue(self):
     210                CURSOR_UP='\033[F'
     211                ERASE_LINE='\033[K'
     212                content=''
    197213                applist=[]
    198                 appdict={}
     214                progress_bar="#"
     215                self.descriptions_dict={}
    199216                all_apps=[]
    200217                outdir=self.bundles_dir+'/appimg/'
    201218                #Load repos
    202219                for repo_name,repo_info in self.repos.items():
    203                         if not os.path.isdir(self.bundles_dir):
    204                                 try:
    205                                         os.makedirs(self.bundles_dir)
    206                                 except:
     220                        if self._chk_bundle_dir(outdir):
     221                                self._debug("Fetching repo %s"%repo_info['url'])
     222##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     223##                                      progress_bar=progress_bar+"#"
     224##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     225                                applist=self._generate_applist(self._fetch_repo(repo_info['url']),repo_name)
     226##                                      progress_bar=progress_bar+"##"
     227##                                      print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     228                                self._debug("Processing info...")
     229                                self._th_generate_xml_catalog(applist,outdir,repo_info['url_info'],repo_info['url'],repo_name,progress_bar)
     230                                self._debug("Fetched repo "+repo_info['url'])
     231                                all_apps.extend(applist)
     232                        else:
    207233                                        self._debug("appImage catalogue could not be fetched: Permission denied")
    208                         self._debug("Fetching repo %s"%repo_info['url'])
    209                         if repo_info['type']=='json':
    210                                 applist=self._process_appimage_json(self._fetch_repo(repo_info['url']),repo_name)
    211 
    212                         self._debug("Fetched repo "+repo_info['url'])
    213                         self._th_generate_xml_catalog(applist,outdir,repo_info['url_info'],repo_info['url'],repo_name)
    214                         all_apps.extend(applist)
    215234                #Load external apps
    216235                for app_name,app_info in self._get_external_appimages().items():
    217                         if os.path.isdir(self.bundles_dir):
    218                                 appinfo=self._init_appinfo()
    219                                 appinfo['name']=app_info['url'].split('/')[-1]
    220                                 appinfo['package']=app_info['url'].split('/')[-1]
    221                                 appinfo['homepage']='/'.join(app_info['url'].split('/')[0:-1])
     236                        if self._chk_bundle_dir(outdir):
     237                                appimage=app_info['url'].split('/')[-1]
     238                                appimage_url='/'.join(app_info['url'].split('/')[0:-1])
    222239                                self._debug("Fetching external appimage %s"%app_info['url'])
    223                                 appinfo['bundle']='appimage'
    224                                 applist=[appinfo]
    225                                 self._th_generate_xml_catalog(applist,outdir,app_info['url_info'],app_info['url'],app_name)
     240                                applist=[appimage]
     241                                self._debug("Processing info...")
     242                                self._th_generate_xml_catalog(applist,outdir,app_info['url_info'],appimage_url,app_name,progress_bar)
    226243                                self._debug("Fetched appimage "+app_info['url'])
    227244                                all_apps.extend(applist)
    228245                        else:
    229246                                self._debug("External appImage could not be fetched: Permission denied")
    230                 self._debug("Removing old entries...")
    231 #               self._clean_bundle_catalogue(all_apps,outdir)
     247
     248
     249##              print (("Removing old entries..."))
     250                self._clean_bundle_catalogue(all_apps,outdir)
    232251                return(True)
    233         #def _get_bundles_catalogue
    234        
     252        #def _download_bundles_catalogue
     253
     254        def _get_external_appimages(self):
     255                external_appimages={}
     256                if os.path.isfile(self.external_appimages):
     257                        try:
     258                                with open(self.external_appimages) as appimages:
     259                                        external_appimages=json.load(appimages)
     260                        except:
     261                                self._debug("Can't load %s"%self.external_appimages)
     262                self._debug(external_appimages)
     263                return external_appimages
     264
     265        def _chk_bundle_dir(self,outdir):
     266                msg_status=True
     267                if not os.path.isdir(outdir):
     268                        try:
     269                                os.makedirs(outdir)
     270                        except Exception as e:
     271                                msg_status=False
     272                                print(e)
     273                return(os.access(outdir,os.W_OK|os.R_OK|os.X_OK|os.F_OK))
     274        #def _chk_bundle_dir
     275
    235276        def _fetch_repo(self,repo):
    236277                req=Request(repo, headers={'User-Agent':'Mozilla/5.0'})
    … …  
    240281                return(content)
    241282        #def _fetch_repo
    242        
    243         def _get_external_appimages(self):
    244                 external_appimages={}
    245                 if os.path.isfile(self.external_appimages):
    246                         try:
    247                                 with open(self.external_appimages) as appimages:
    248                                         external_appimages=json.load(appimages)
    249                         except:
    250                                 self._debug("Can't load %s"%self.external_appimages)
    251                 self._debug(external_appimages)
    252                 return external_appimages
    253         #def _get_external_appimages
    254        
    255         def _process_appimage_json(self,data,repo_name):
    256                 maxconnections = 10
    257                 semaphore = threading.BoundedSemaphore(value=maxconnections)
     283
     284        def _generate_applist(self,content,repo_name):
     285                garbage_list=[]
    258286                applist=[]
    259                 json_data=json.loads(data)
    260                 if 'items' in json_data.keys():
    261                         for appimage in json_data['items']:
    262                                 appinfo=self._th_process_appimage(appimage,semaphore)
    263                                 if appinfo:
    264                                         applist.append(appinfo)
    265                                         #                               th=threading.Thread(target=self._th_process_appimage, args = (appimage,semaphore))
    266 #                               th.start()
    267 
    268 #               while threading.active_count()>1:
    269 #                       print("%s"%threading.active_count())
    270 #                       time.sleep(0.1)
    271 
    272 #               while not self.queue.empty():
    273 #                       applist.append(self.queue.get())
    274 #                       self._debug("Added %s"%applist[-1])
    275 #               self._debug("JSON: %s"%applist)
    276                 return (applist)
    277         #_process_appimage_json
    278 
    279         def _th_process_appimage(self,appimage,semaphore):
    280                 appinfo=None
    281 #               semaphore.acquire()
    282 #               lock=threading.Lock()
    283                 releases=[]
    284                 if 'links' in appimage.keys():
    285                         if appimage['links']:
    286                                 appinfo=self.load_json_appinfo(appimage)
    287 #Deprecated. appImage releases will be load on the info stage
    288 #                       releases=self._get_releases_from_json(appimage)
    289 #                       if releases:
    290 #                               appinfo['releases']=releases
    291 #                               for release in releases:
    292 #                                       #Release has the direct download url
    293 #                                       tmp_release=release.split('/')
    294 #                                       tmp_appinfo=appinfo.copy()
    295 #                                       rel_number=tmp_release[-2]
    296 #                                       rel_name=tmp_release[-1].lower().replace('.appimage','')
    297 #                                       self._debug("Release: %s"%release)
    298 #                                       tmp_appinfo['name']=rel_name
    299 #                                       tmp_appinfo['package']=tmp_release[-1]
    300 #                                       tmp_appinfo['homepage']='/'.join(tmp_release[0:-1])
    301 #                                       self.queue.put(tmp_appinfo)
    302 #Threading disabled
    303 #                               self.queue.put(appinfo)
    304                 return(appinfo)
    305         #def _th_process_appimage
    306 
    307         def load_json_appinfo(self,appimage):
    308                 appinfo=self._init_appinfo()
    309                 appinfo['name']=appimage['name']
    310                 appinfo['package']=appimage['name']
    311                 if 'license' in appimage.keys():
    312                         appinfo['license']=appimage['license']
    313                 appinfo['summary']=''
    314                 if 'description' in appimage.keys():
    315                         appinfo['description']=appimage['description']
    316                 if 'categories' in appimage.keys():
    317                         appinfo['categories']=appimage['categories']
    318                 if 'icon' in appimage.keys():
    319                         appinfo['icon']=appimage['icon']
    320                 if 'screenshots' in appimage.keys():
    321                         appinfo['thumbnails']=appimage['screenshots']
    322                 if 'links' in appimage.keys():
    323                         if appimage['links']:
    324                                 for link in appimage['links']:
    325                                         if 'url' in link.keys() and link['type']=='Download':
    326                                                 appinfo['homepage']=link['url']
    327                 elif 'authors' in appimage.keys():
    328                         if appimage['authors']:
    329                                 for author in appimage['authors']:
    330                                         if 'url' in author.keys():
    331                                                 appinfo['homepage']=author['url']
    332                 appinfo['bundle']=['appimage']
    333                 return appinfo
    334         #def load_json_appinfo
    335 
    336         def _th_generate_xml_catalog(self,applist,outdir,info_url,repo,repo_name):
     287                #webscrapping for probono repo
     288                if repo_name=='probono':
     289                        garbage_list=content.split(' ')
     290                        for garbage_line in garbage_list:
     291                                if garbage_line.endswith('AppImage"'):
     292                                        app=garbage_line.replace('href=":','')
     293                                        applist.append(app.replace('"',''))
     294                #Example of a webscrapping from another site
     295#               if repo_name='other_repo_name':
     296#                       for garbage_line in garbage_list:
     297#                                       if garbage_line.startswith('file="'):
     298#                                               if 'appimage' in garbage_line:
     299#                                                       app=garbage_line.replace('file="','')
     300#                                                       app=app.replace('\n','')
     301#                                                       self._debug("Add %s"%app)
     302#                                                       applist.append(app.replace('"',''))
     303
     304                return(applist)
     305        #def _generate_applist
     306
     307        def _th_generate_xml_catalog(self,applist,outdir,info_url,repo,repo_name,progress_bar=''):
     308                CURSOR_UP='\033[F'
     309                ERASE_LINE='\033[K'
    337310                maxconnections = 10
    338311                semaphore = threading.BoundedSemaphore(value=maxconnections)
    339312                random_applist = list(applist)
    340313                random.shuffle(random_applist)
    341                 for app in applist:
    342                         th=threading.Thread(target=self._th_write_xml, args = (app,outdir,info_url,repo,repo_name,semaphore))
     314                len_applist=len(random_applist)
     315                inc=30/len_applist
     316#               print (CURSOR_UP)
     317                for app in random_applist:
     318                        th=threading.Thread(target=self._th_write_xml, args = (app,outdir,info_url,repo,repo_name,semaphore,inc))
    343319                        th.start()
     320#               os.system('setterm -cursor off')
     321#               while threading.active_count()>2: #Discard both main and own threads
     322#                       for i in range(len(progress_bar),int(self.progress)):
     323#                               progress_bar='#'+progress_bar
     324#                       print (CURSOR_UP)
     325#                       print (("Fetching %s catalogue: "+progress_bar)%repo_type,end="\r")
     326#               os.system('setterm -cursor on')
    344327        #def _th_generate_xml_catalog
    345328
    346         def _th_write_xml(self,appinfo,outdir,info_url,repo,repo_name,semaphore):
     329        def _th_write_xml(self,app,outdir,info_url,repo,repo_name,semaphore,inc):
    347330                semaphore.acquire()
    348331                lock=threading.Lock()
    349 #               self._debug("Populating %s"%appinfo)
    350                 package=appinfo['name'].lower().replace(".appimage","")
    351                 if len(package)>40:
    352                         tmp_package=package.split('-')
    353                         tam=0
    354                         pos=1
    355                         index=0
    356                         banned=['linux32','linux64','i386','x86_64','ia32','amd64']
    357                         for tmp_name in tmp_package:
    358                                 if (tam<len(tmp_name) and pos<index) and tmp_name not in banned:
    359                                         tam=len(tmp_name)
    360                                         pos=index
    361                                 index+=1
    362                         print("Removed: %s"%tmp_package[pos])
    363                         tmp_package[pos]=''
    364                         package='-'.join(tmp_package)
    365                         package=package.replace("--","-")
    366                         package=package.replace("-.",".")
    367 
    368 #               filename=outdir+package.lower().replace('appimage',"appdata")+".xml"
    369 #               self._debug("checking if we need to download "+filename)
    370 #               if not os.path.isfile(filename):
    371                 repo_info={'info_url':info_url,'repo':repo,repo_name:'repo_name'}
    372                 self._add_appimage(appinfo,repo_info,lock)
     332                name_splitted=app.split('-')
     333                name=name_splitted[0]
     334                version=name_splitted[1]
     335                arch=name_splitted[2]
     336                filename=outdir+app.lower().replace('appimage',"appdata.xml")
     337                self._debug("checking if we need to download "+filename)
     338                if not os.path.isfile(filename):
     339                        self._write_xml_file(filename,app,name,version,info_url,repo,repo_name,lock)
     340                with lock:
     341                        self.progress=self.progress+inc
    373342                semaphore.release()
    374343        #def _th_write_xml
    375344
    376         def _add_appimage(self,appinfo,repo_info,lock):
    377                 #Search in local store for the app
    378                 sw_new=False
    379                 app=self.store.get_app_by_pkgname(appinfo['package'].lower())
    380                 if not app:
    381                         self._debug("Searching for %s"%appinfo['package'])
    382                         app=self.store.get_app_by_id(appinfo['package'].lower()+".desktop")
    383                 if not app:
    384                         self._debug("Generating new %s"%appinfo['package'])
    385                         app=appstream.App()
    386                         sw_new=True
    387                 bundle=appstream.Bundle()
    388                 icon=appstream.Icon()
    389                 screenshot=appstream.Screenshot()
    390                 bundle.set_kind(bundle.kind_from_string('APPIMAGE'))
    391                 bundle.set_id(appinfo['package']+'.appimage')
    392                 app.add_bundle(bundle)
    393                 app.add_keyword("C","appimage")
    394                 app.add_category("appimage")
    395                 app.add_pkgname(appinfo['package'].lower()+".appimage")
    396                 app.add_url(appstream.UrlKind.UNKNOWN,appinfo['homepage'])
    397                 if sw_new:
    398                         app.add_keyword("C",appinfo['package'])
    399                         app.set_name("C",appinfo['name'])
    400                         app.add_pkgname(appinfo['package'].lower()+".appimage")
    401                         app.set_id("appimagehub.%s"%appinfo['name'].lower()+'.appimage')
    402                         app.set_id_kind=appstream.IdKind.DESKTOP
    403                         description="This is an AppImage bundle of app %s. It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully.\n%s"%(appinfo['name'],appinfo['description'])
     345        def _write_xml_file(self,filename,app,name,version,info_url,repo,repo_name,lock):
     346                        self._debug("Generating "+app+" xml")
     347                        f=open(filename,'w')
     348                        f.write('<?xml version="1.0" encoding="UTF-8"?>'+"\n")
     349                        f.write("<components version=\"0.10\">\n")
     350                        f.write("<component  type=\"desktop-application\">\n")
     351                        f.write("  <id>"+app.lower()+"</id>\n")
     352                        f.write("  <pkgname>"+app+"</pkgname>\n")
     353                        f.write("  <name>"+name+"</name>\n")
     354                        f.write("  <metadata_license>CC0-1.0</metadata_license>\n")
     355                        f.write("  <provides><binary>"+app+"</binary></provides>\n")
     356                        f.write("  <releases>\n")
     357                        f.write("  <release version=\""+version+"\" timestamp=\"1408573857\"></release>\n")
     358                        f.write("  </releases>\n")
     359                        f.write("  <launchable type=\"desktop-id\">"+name+".desktop</launchable>\n")
     360                        with lock:
     361                                try:
     362                                        if name in self.descriptions_dict.keys():
     363                                                description=self.descriptions_dict[name]
     364                                        else:
     365                                                description=self._get_description(name,info_url,repo_name)
     366                                                self.descriptions_dict.update({name:description})
     367                                except:
     368                                        description=''
    404369                        summary=' '.join(list(description.split(' ')[:8]))
    405                         if len(description.split(' '))>8:
    406                                 summary+="... "
    407                         app.set_description("C",description)
    408                         app.set_comment("C",summary)
    409                         for category in appinfo['categories']:
    410                                 app.add_category(category)
    411                         self.store.add_app(app)
    412                 gioFile=Gio.File.new_for_path('%s/%s.xml'%(self.bundles_dir,app.get_id_filename()))
    413                 app.to_file(gioFile)
    414 #               self.appimage_store.to_file(gioFile,appstream.NodeToXmlFlags.ADD_HEADER)
    415 #               self.appimage_store.add_app(app)
    416                 return(app)
    417         #def _add_appimage
    418 
    419         def _get_description_icon(self,app_name,info_url,repo_name):
     370                        description="This is an AppImage bundle of app "+name+". It hasn't been tested by our developers and comes from a 3rd party dev team. Please use it carefully.\n"+description
     371                        if not summary:
     372                                summary=' '.join(list(description.split(' ')[:8]))
     373                        f.write("  <description><p></p><p>"+description+"</p></description>\n")
     374                        f.write("  <summary>"+summary+"...</summary>\n")
     375                        f.write('  <url type="homepage">'+repo+'</url>\n')
     376                        f.write("  <bundle type=\"appimage\">"+app+"</bundle>\n")
     377                        f.write("  <keywords>\n")
     378                        f.write("       <keyword>"+name+"</keyword>\n")
     379                        f.write("       <keyword>appimage</keyword>\n")
     380                        f.write("  </keywords>\n")
     381                        f.write("  <categories>\n")
     382                        f.write("       <category>AppImage</category>\n")
     383#                       f.write("       <category>GTK</category>\n")
     384                        f.write("  </categories>\n")
     385                        f.write("<icon type=\"cached\">"+name+"_"+name+".png</icon>\n")
     386                        f.write("</component>\n")
     387                        f.write("</components>\n")
     388                        f.close()
     389        #def _write_xml_file
     390
     391        def _get_description(self,app_name,info_url,repo_name):
    420392                desc=''
    421                 icon=''
     393                if '$(appname)' in info_url:
     394                        info_url=info_url.replace('$(appname)',app_name)
    422395                if info_url:
    423                         if '$(appname)' in info_url:
    424                                 info_url=info_url.replace('$(appname)',app_name)
    425396                        self._debug("Getting description from repo/app %s - %s "%(repo_name,info_url))
    426397                        try:
    … …  
    430401                                                soup=BeautifulSoup(content,"html.parser")
    431402                                                description_div=soup.findAll('div', attrs={ "class" : "description-text"})
    432                                                 icon_div=soup.findAll('div', attrs={ "class" : "avatar-icon avatar-large description-icon "})
    433403                                if len(description_div)>0:
    434404                                        desc=description_div[0].text
    435405                                        desc=desc.replace(':','.')
    436406                                        desc=desc.replace('&','&amp;')
    437                                 if len(icon_div)>0:
    438                                         icon_str=str(icon_div[0])
    439                                         icon=icon_str.split(' ')[9]
    440                                         icon=icon.lstrip('url(')
    441                                         if icon.startswith('http'):
    442                                                 icon=icon.rstrip(');"></div>')
    443                                                 icon=self._download_file(icon,app_name)
    444                                         print("Icon: %s"%icon)
    445407                        except Exception as e:
    446408                                print("Can't get description from "+info_url)
    447409                                print(str(e))
    448410                                pass
    449                 return([desc,icon])
     411                return(desc)
    450412        #def _get_description
    451413
    … …  
    463425        #def _clean_bunlde_catalogue
    464426
    465         def _download_file(self,url,app_name):
    466 #               target_file=self.icons_folder+'/'+app_name+".png"
    467                 target_file=self.icons_dir+'/'+app_name+".png"
    468                 if not os.path.isfile(target_file):
    469 #                       shutil.copy("/usr/share/icons/hicolor/128x128/apps/lliurex-store.png",target_file)
    470 #                       if not os.fork():
    471                         if not os.path.isfile(target_file):
    472                                 self._debug("Downloading %s to %s"%(url,target_file))
    473                                 try:
    474                                         with urllib.request.urlopen(url) as response, open(target_file, 'wb') as out_file:
    475                                                 bf=16*1024
    476                                                 acumbf=0
    477                                                 file_size=int(response.info()['Content-Length'])
    478                                                 while True:
    479                                                         if acumbf>=file_size:
    480                                                             break
    481                                                         shutil.copyfileobj(response, out_file,bf)
    482                                                         acumbf=acumbf+bf
    483                                         st = os.stat(target_file)
    484                                 except Exception as e:
    485                                         self._debug("Unable to download %s"%url)
    486                                         self._debug("Reason: %s"%e)
    487                                         target_file=url
    488 #                               os._exit(0)
    489                 return(target_file)
    490         #def _download_file
    491        
    492         def _chk_bundle_dir(self,outdir):
    493                 msg_status=True
    494                 if not os.path.isdir(outdir):
    495                         try:
    496                                 os.makedirs(outdir)
    497                         except Exception as e:
    498                                 msg_status=False
    499                                 print(e)
    500                 return(os.access(outdir,os.W_OK|os.R_OK|os.X_OK|os.F_OK))
    501         #def _chk_bundle_dir
    502        
    503         def _init_appinfo(self):
    504                 appInfo={'appstream_id':'',\
    505                 'id':'',\
    506                 'name':'',\
    507                 'version':'',\
    508                 'releases':[],\
    509                 'package':'',\
    510                 'license':'',\
    511                 'summary':'',\
    512                 'description':'',\
    513                 'categories':[],\
    514                 'icon':'',\
    515                 'screenshot':'',\
    516                 'thumbnails':[],\
    517                 'video':'',\
    518                 'homepage':'',\
    519                 'installerUrl':'',\
    520                 'state':'',\
    521                 'depends':'',\
    522                 'kudos':'',\
    523                 'suggests':'',\
    524                 'extraInfo':'',\
    525                 'size':'',\
    526                 'bundle':'',\
    527                 'updatable':'',\
    528                 }
    529                 return(appInfo)
    530         #def _init_appinfo
    531        
    532         def _get_info(self,app_info):
    533                 app_info=self._get_releases(app_info)
    534                 app_info['state']='available'
    535                 if os.path.isfile(self.appimage_dir+'/'+app_info['package']):
    536                         app_info['state']='installed'
    537                 #Get size
    538                 appimage_url=app_info['homepage']+'/'+app_info['package']
    539                 dest_path=self.appimage_dir+'/'+app_info['package']
    540                 if appimage_url:
    541                         try:
    542                                 with urllib.request.urlopen(appimage_url) as response:
    543                                         app_info['size']=(response.info()['Content-Length'])
    544                         except:
    545                                 app_info['size']=0
    546                 self._set_status(0)
    547                 self.partial_progress=100
    548                 return(app_info)
    549         #def _get_info
    550 
    551         def _get_releases(self,app_info):
    552                 releases=[]
    553                 if app_info['installerUrl']:
    554                         self._debug("Info url: %s"%app_info['installerUrl'])
    555                         try:
    556                                 sw_git=False
    557                                 if 'github' in app_info['installerUrl']:
    558                                         sw_git=True
    559 #                                       app_info['installerUrl']=app_info['installerUrl']+"/download"
    560 
    561                                 with urllib.request.urlopen(app_info['installerUrl']) as f:
    562                                         content=(f.read().decode('utf-8'))
    563                                         soup=BeautifulSoup(content,"html.parser")
    564                                         package_a=soup.findAll('a', attrs={ "href" : re.compile(r'.*\.[aA]pp[iI]mage$')})
    565                                         for package_data in package_a:
    566                                                 package_name=package_data.findAll('strong', attrs={ "class" : "pl-1"})
    567                                                 package_link=package_data['href']
    568                                                 if sw_git:
    569                                                         package_link="https://github.com"+package_link
    570                                                         releases.append(package_link)
    571                                                         self._debug("Link: %s"%package_link)
    572                         except Exception as e:
    573                                 print(e)
    574                 app_info['releases']=releases
    575                 return app_info
    576         #def _get_releases
    577        
    578         def _get_releases_from_json(self,appimage):
    579                 releases=[]
    580                 if appimage['links']:
    581                         for link in appimage['links']:
    582                                 if 'type' in link.keys():
    583                                         if link['type']=='Download':
    584                                                 self._debug("Info url: %s"%link['url'])
    585                                                 try:
    586                                                         sw_git=False
    587                                                         with urllib.request.urlopen(link['url']) as f:
    588                                                                 if 'github' in link['url']:
    589                                                                         sw_git=True
    590                                                                 content=(f.read().decode('utf-8'))
    591                                                                 soup=BeautifulSoup(content,"html.parser")
    592                                                                 package_a=soup.findAll('a', attrs={ "href" : re.compile(r'.*[aA]pp[iI]mage$')})
    593                                                                 for package_data in package_a:
    594                                                                         package_name=package_data.findAll('strong', attrs={ "class" : "pl-1"})
    595                                                                         package_link=package_data['href']
    596                                                                         if sw_git:
    597                                                                                 package_link="https://github.com"+package_link
    598                                                                                 releases.append(package_link)
    599                                                                                 self._debug("Link: %s"%package_link)
    600                                                 except Exception as e:
    601                                                         print(e)
    602                 return releases
    603         #def _get_releases_from_json
    604 

  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/infoManager.py

    r7137 r7143  
    33class infomanager:
    44        def __init__(self):
    5                 self.dbg=True
     5                self.dbg=False
    66                self.plugin_actions={'get_info':'*'}
    77                self.result={}
    … …  
    7575                        if app.get_pkgname_default():
    7676                                appInfo['package']=app.get_pkgname_default()
    77                         if len(app.get_pkgnames())>1:
    78                                 appInfo['packages']=app.get_pkgnames()
    7977                        if app.get_project_license():
    8078                                appInfo['license']=app.get_project_license()
    … …  
    9694                                appInfo['categories']=app.get_categories()
    9795                        if app.get_icon_default():
    98                                 if app.get_icon_default().get_filename():
    99                                         appInfo['icon']=app.get_icon_default().get_filename()
    100                                 else:
    101                                         appInfo['icon']=app.get_icon_default().get_name()
     96                                appInfo['icon']=app.get_icon_default().get_name()
    10297                                if appInfo['icon']==None:
    10398                                        icons=app.get_icons()
    … …  
    108103                                        else:
    109104                                                appInfo['icon']=''
    110                         if appInfo['icon']==None:       
    111                                 appInfo['icon']=''
     105                               
    112106                        if app.get_screenshots():       
    113107                                thumbnails_list=[]
    … …  
    140134                                appInfo["screenshots"]=screenshots_list
    141135                        #The values are the values of appstream.UrlKind. 1=HOMEPAGE, 0=UNKNOWN
    142                         self._debug(app.get_url_item(0))
    143136                        if app.get_url_item(1):
    144137                                appInfo['homepage']=app.get_url_item(1).strip()
    … …  
    168161                                if bundle.get_kind()==0:
    169162                                        kind=bundle.get_id().split('.')[-1]
    170                                         appInfo['bundle'].append(kind.lower())
     163                                        appInfo['bundle']=kind.lower()
    171164                                        if kind.lower=='sh':
    172165                                                appInfo['installerUrl']=bundle.get_id()
    … …  
    199192                'extraInfo':'',\
    200193                'size':'',\
    201                 'bundle':[],\
     194                'bundle':'',\
    202195                'updatable':'',\
    203                 'component':'',\
    204                 'releases':[]
    205196                }
    206197                return(appInfo)

  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/searchManager.py

    r7137 r7143  
    77        def __init__(self):
    88                self.locale=locale.getlocale()[0]
    9                 self.dbg=True
     9                self.dbg=False
    1010                self.store=''
    1111                self.plugin_actions={'search':'*','list':'*','list_sections':'*','info':'*'}
    … …  
    183183                #4.- Try exact match by pkgname
    184184                        app=self.store.get_app_by_pkgname(app_name)
    185                 if not app:
    186                         app=self.store.get_app_by_id_ignore_prefix(app_name)
    187185                self._debug("App found %s"%app)
    188186                return(app)
    189187
    190188        def _get_apps_by_match(self,tokens,applist=[]):
    191                 #Add items with match >= self.precision
     189                #Add items witch match >= self.precision
    192190                self._debug("Searching app by fuzzy match")
    193191                if not applist:

  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/plugins/snapManager.py

    r7132 r7143  
    116116                self._set_status(1)
    117117                for pkg in pkgs:
    118                         app=self.store.get_app_by_pkgname(pkg.get_name())
    119                         if not app:
    120                                 self._debug("Searching for %s"%pkg.get_name())
    121                                 app=self.store.get_app_by_id(pkg.get_name().lower()+".desktop")
    122                         if app:
    123                                 bundle=appstream.Bundle()
    124                                 bundle.set_kind(bundle.kind_from_string('SNAP'))
    125                                 bundle.set_id(pkg.get_name()+'.snap')
    126                                 app.add_bundle(bundle)
    127                                 app.add_category("Snap")
    128 #                               store.add_app(self._generate_appstream_app_from_snap(pkg))
    129                         else:
    130                                 store.add_app(self._generate_appstream_app_from_snap(pkg))
     118                        store.add_app(self._generate_appstream_app(pkg))
    131119                return(store)
    132120
    133         def _generate_appstream_app_from_snap(self,pkg):
     121        def _generate_appstream_app(self,pkg):
    134122                bundle=appstream.Bundle()
    135123                app=appstream.App()
    … …  
    142130                app.add_bundle(bundle)
    143131                app.set_name("C",pkg.get_name())
    144 #               app.add_pkgname(pkg.get_name()+'.snap')
    145                 app.add_pkgname(pkg.get_name())
     132                app.add_pkgname(pkg.get_name()+'.snap')
    146133                app.add_category("Snap")
    147134                release=appstream.Release()
    148135                release.set_version(pkg.get_version())
    149136                app.add_release(release)
    150                 app.set_id("io.snapcraft.%s"%pkg.get_name()+'.snap')
     137                sw_id=False
     138                for snap_app in pkg.get_apps():
     139                        if snap_app.get_desktop_file():
     140                                app.set_id("%s"%snap_app.get_desktop_file())
     141                                sw_id=True
     142                                break
     143                if sw_id==False:
     144                        app.set_id("%s_%s.desktop"%(pkg.get_name(),pkg.get_name()))
    151145#               app.set_id(pkg.get_name()+'.snap')
    152146                app.set_id_kind=appstream.IdKind.DESKTOP
    … …  
    247241                                        self._debug("Unable to download %s"%url)
    248242                                        self._debug("Reason: %s"%e)
    249                                         target_file=''
    250243#                               os._exit(0)
    251244                return(target_file)
    … …  
    259252                pkg=None
    260253                try:
    261                         pkg=self.snap_client.list_one_sync(app_info['package'])
     254                        pkg=self.snap_client.list_one_sync(app_info['name'])
    262255                        app_info['state']='installed'
    263256                        pkgs=[pkg]
    … …  
    265258                        app_info['state']='available'
    266259                        if self.cli_mode:
    267                                 pkgs=self._search_snap(app_info['package'])
     260                                pkgs=self._search_snap(app_info['name'])
    268261                        else:
    269                                 pkgs=self._search_snap_async(app_info['package'])
     262                                pkgs=self._search_snap_async(app_info['name'])
    270263                        self._debug("Getting extended info for %s %s"%(app_info['name'],pkgs))
    271264                if type(pkgs)==type([]):

  • lliurex-store/trunk/fuentes/python3-lliurex-store.install/usr/share/lliurexstore/storeManager.py

    r7137 r7143  
    1717class StoreManager():
    1818        def __init__(self,*args,**kwargs):
     19                self.dbg=False
    1920                if 'dbg' in kwargs.keys():
    2021                        self.dbg=kwargs['dbg']
    21                 self.dbg=True
    2222                self._propagate_dbg=False
    2323                self.store=None
    24                 self.stores={}
    2524                self.related_actions={
    2625                                        'load':['load'],
    … …  
    392391        def _load_Store(self):
    393392                action='load'
    394                 #Load appstream metada first
    395                 package_type='*'
    396                 load_function=self._execute_class_method(action,package_type,launchedby=None)
    397                 self.store=load_function.execute_action(action=action,store=self.store)['data']
    398                 #Once appstream is loaded load the appstream plugins for other package types (snap, appimage...)
    399393                for package_type in self.plugins_registered[action]:
    400                         if package_type!='*':
    401                                 load_function=self._execute_class_method(action,package_type,launchedby=None)
    402                                 self.store=load_function.execute_action(action=action,store=self.store)['data']
     394                        load_function=self._execute_class_method(action,package_type,launchedby=None)
     395                        self.store=load_function.execute_action(action=action,store=self.store)['data']
    403396        #def _load_Store
    404397
    … …  
    424417        #  - Dict with the related info
    425418        ####
    426         def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True,channel=''):
     419        def _get_Extended_App_Info(self,info_applist,launchedby=None,fullsearch=True):
    427420                #Check if there's any plugin for the distinct type of packages
    428421                action='pkginfo'
    … …  
    431424                result['data']=[]
    432425                result['status']={'status':0,'msg':''}
    433                 processed=[]
    434426                for app_info in info_applist:
    435                         if channel:
    436                                 types_dict[channel]=[app_info]
     427                        package_type=self._check_package_type(app_info)
     428                        if package_type in types_dict:
     429                                types_dict[package_type].append(app_info)
    437430                        else:
    438                                 available_channels=self._check_package_type(app_info)
    439                                 for package_type in available_channels:
    440                                         if app_info['component']!='':
    441                                                 if app_info['package'] in processed:
    442                                                         continue
    443 #                                               processed.append(app_info['package'])
    444 
    445                                         if package_type in types_dict:
    446                                                 types_dict[package_type].append(app_info)
    447                                         else:
    448                                                 types_dict[package_type]=[app_info]
     431                                types_dict[package_type]=[app_info]
    449432                for package_type in types_dict:
    450433                        self._debug("Checking plugin for %s %s"%(action,package_type))
    451434                        if package_type in self.plugins_registered[action]:
    452                                 #Only seach full info if it's required
     435                                #Only search full info if it's required
    453436                                if (fullsearch==False and package_type=='deb'):
    454437                                        result['data'].extend(types_dict[package_type])
    … …  
    514497                if (launchedby=='search'):
    515498                                exact_match=False
    516                 target_channel=''
    517                 if '=' in search_item:
    518                         target_channel=search_item.split('=')[-1]
    519                         search_item=search_item.split('=')[0]
    520499                for package_type in self.plugins_registered[action]:
    521500                        search_function=self._execute_class_method(action,'*',launchedby=launchedby)
    … …  
    533512                        #2.- Get rest of metadata (slower)
    534513                        subordinate_action='pkginfo'
    535                         self._debug("Target channel: %s"%target_channel)
    536                         result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch,target_channel)
     514                        result=self._get_Extended_App_Info(result['data'],launchedby,fullsearch)
    537515                        if launchedby:
    538516                                realAction=launchedby
    … …  
    635613                #Zomandos must have the subcategory "Zomando"
    636614                self._debug("Checking package type for app "+app_info['name'])
    637                 return_msg=[]
    638                 if app_info['component']!='':
    639                         return_msg.append('deb')
    640615                if "Zomando" in app_info['categories']:
    641                         return_msg.append("zmd")
     616                        return_msg="zmd"
     617                else:
    642618                #Standalone installers must have an installerUrl field loaded from a bundle type=script description
    643                 if app_info['bundle']:
    644                         return_msg.extend(app_info['bundle'])
    645                 if app_info['installerUrl']!='':
    646                         return_msg.append("sh")
    647                 print(return_msg)
     619                        if app_info['bundle']!='':
     620                                return_msg=app_info['bundle']
     621                        elif app_info['installerUrl']!='':
     622                                return_msg="sh"
     623                        else:
     624                                return_msg="deb"
    648625                return(return_msg)
    649626        #def _check_package_type
Note: See TracChangeset for help on using the changeset viewer.