add bottle dir

.theia/launch.json

@@ -0,0 +1,6 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  "version": "0.2.0",
+  "configurations": []
+}

Makefile

@@ -16,4 +16,15 @@ testEnv:
 testEnvUse:
 	python  utils/parsePortage.py use
 
+testEnvMask:
+	python  utils/parsePortage.py mask
+
+testEnvUnMask:
+	python  utils/parsePortage.py unmask
+	
+test:
+	echo 'test'
+
+
+
 

config.json

@@ -5,11 +5,11 @@
     "THEME": "default"
     },
     "Portage":{
-        "rootPth":"/etc/portage",
+        "rootPath":"/etc/portage",
         "make.conf":"/etc/portage/make.conf/custom",
         "package.use":"/etc/portage/package.use/custom",
         "package.accept_keywords":"/etc/portage/package.accept_keywords/custom",
-        "package.mask":"/etc/portage/package.mask",
+        "package.mask":"/etc/portage/package.mask/custom",
         "package.unmask":"/etc/portage/package.unmask/custom"
     
     }

core/bottle

@@ -0,0 +1 @@
+Subproject commit eb1982ea22937a042f5a6e98c5709f779a8fd66c

core/handler.py

@@ -3,16 +3,26 @@
 import json
 # from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer
 from http.server import BaseHTTPRequestHandler
+from core.bottle.bottle import  Bottle, run
+#route, post, head, request, error, run
 import logging
-import os
+import os, urllib
 from utils.utils import get_list_overlays, load_config, write_config, sort_install_pkg
 from utils.package import search
 from utils.findfsdb import on_find 
 from core.route import Router
+from core.jwt import genaratorSecretsToken
 import logging
 from io import BytesIO
 #repl = '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<!DOCTYPE repositories SYSTEM "http://www.gentoo.org/dtd/repositories.dtd">'
-
+ app =Bottle
+@app.post(/login)
+def login(user='demo', password='demo'):
+    if auth():
+        return(generatoSecretsToken())
+    else:
+        return ("403")
+@app.post('/')
 def  main():
     try:
         with open('./pkgs.json', 'tr') as fn:
@@ -23,7 +33,7 @@ def  main():
     except Exception(e):
         print(e)
         return "404"
-
+@app.post('/set_settings')
 def set_settings_app(params):
     config = load_config()
     # param = self.path.replace("/?st_app=", "") 
@@ -38,7 +48,7 @@ def set_settings_app(params):
     write_config(port, Lang)
     print(config)
     print(param)
-
+@app.post(/find/)
 def search(pkg):
     # param = self.path.replace("/find?pkg=", "")  #request['params']['name']
     Pk_list = []
@@ -62,14 +72,23 @@ def search(pkg):
     # self.r_t = str(json.dumps(search_result))
     return str(json.dumps(Search_result))
     # self.r_t = json.dumps(pkg_list)
+@app.post('/get_settings')
 def get_settings_app():
     return str(json.dumps(load_config()))
+@app.route('*',['GET']})
+def req_get():
+    return"  404"
+
+# run (host='0.0.0.0', port=8000,  keyfile='key.pem', certfile='cert.pem')
+
+
 
 class Handler(BaseHTTPRequestHandler):
+    #self.Response = ""
     def _set_response(self):
         self.send_response(200)
         self.send_header['Access-Control-Allow-Origin', '*']
-        self.send_header['Access-Control-Allow-Methods', 'GET']
+        #self.send_header['Access-Control-Allow-Methods', 'GET']
         self.send_header['Access-Control-Allow-Headers', 'X-Requested-With,content-type']
         # self.send_header['Access-Control-Allow-Credentials', true]
         self.end_headers()
@@ -91,8 +110,26 @@ class Handler(BaseHTTPRequestHandler):
         data = self.rfile.read(length)
 
     def do_POST(self):
+        """
+        if request return Token: 
+            self.r_t = main()
+            self.response()
+            
+            -> run hanlerFunc:
+        else:
+            self.send_response("403")
+            self.redorect '/auth' for self.auth 
+
+        """
+        post_data = urllib.parse.parse_qs(self.rfile.read(content_length)) # <--- Gets the data itself
+        self.r_t = route(metod='POST', url=self.path, params=post_data, handler='main')
+        self.get_data =()
+        post_data = urllib.parse.parse_qs(self.rfile.read(content_length)) # <--- Gets the data itself
+        logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n",
+                str(self.path), str(self.headers), post_data.decode('utf-8'))
         print("do_POST:\n")
         print(str(self.path), str(self.headers))
+        return(post_data)
 
     def do_HEAD(self):
         print("do_HEAD:\n")
@@ -112,25 +149,22 @@ class Handler(BaseHTTPRequestHandler):
     def do_GET(self):
         print("do_GET:\n")
         print(str(self.path), str(self.headers))
-
+        self.send_response(404)
         # print(Router.parse_url(self))
         # print("data:\t" + self.rfile.read())
         # request = Router.parse_url(self)
         #self.send_response(200)
-        self.p_list = []
-        self.r_t  = ""
+        ##self.p_list = []
+        ##self.r_t  = ""
         # length = int(self.headers['content-length'])
         # self.send_header(['Access-Control-Allow-Origin', '*'],
         # self.send_header(['Access-Control-Allow-Methods', 'GET'],
         # self.send_header(['Access-Control-Allow-Headers', 'X-Requested-With,content-type'])
         # self.send_header(['Access-Control-Allow-Credentials', true])
         # self.end_headers()
-        
         if self.path == "/":
-            # path  root -> Return all  DATA - (All Tree Portage) config.json as Json
-            # print("data:\t" + self.get_data())
-            self.r_t = main()
-            self.response()
+            self.send_response(403)
+        
 
         elif self.path == '/ovelays':
             #  Return List repositories
@@ -190,11 +224,10 @@ class Handler(BaseHTTPRequestHandler):
 
             #self.r_t = str(sort_inatll_pkg())
             self.r_t = str(json.dumps(scan_config_portage()))
-
+        
         else:
             #Return Error 404
-            self.send_response(404)
-            
+            self.send_response(404)       
             self.end_headers()
             print(str(self.client_address[0]) +"\t" + str(404))
 

core/route.py

@@ -24,7 +24,8 @@ class Router():
                 return handler()
         else:
             return 1
-
+    def setRoutes(self):
+        pass
 class RouterOld(BaseHTTPRequestHandler):
     # def __init__(self):
     #     self.P_list = []
@@ -47,20 +48,6 @@ class RouterOld(BaseHTTPRequestHandler):
         #self.send_header['Access-Control-Allow-Credentials', true]
         self.end_headers()
 
-    def do_GET(self):
-        # logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
-        # print(str(self.path), str(self.headers))
-        self.r_t = str(self.path), str(self.headers)
-        return self.response()
-
-    def do_POST(self):
-        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
-        self._set_response()
-        print(str(self.path), str(self.headers))
-
-    def do_HEAD(self):
-        pass
-
     def do_REQUEST(self):
         print("do_REQUEST:\n")
         print(str(self.path), str(self.headers))
@@ -77,7 +64,7 @@ class RouterOld(BaseHTTPRequestHandler):
             #print("TypeError")
             return self.wfile.write(bytes(self.r_t, 'UTF-8'))
 
-    def route(self, metod, url, handler):
+    def route(self, metod, url, params,  handler):
         print(url)
         metod = metod.lower()
         if self.path in self.Routes.url:

server.py

@@ -1,17 +1,160 @@
-#!/usr/bin/env pyton3
+"""#!/usr/bin/env pyton3
 # -*- coding: UTF-8 -*-
 '__autor__' =='serkus'
-from http.server import HTTPServer, SimpleHTTPRequestHandler, BaseHTTPRequestHandler
+"""
+#from http.server import HTTPServer, SimpleHTTPRequestHandler, BaseHTTPRequestHandler
 import logging
-from core.handler import Handler as Handler
+#from core.handler import Handler as Handler
 import os, sys, json, ssl
-from core.route import Router
 #PORT_NUMBER = 8000
 from utils.findfsdb import create_db
 from utils.utils import load_config
+import json
+# from BaseHTTPServer import BaseHTTPRequestHandler,HTTPServer
+#from http.server import BaseHTTPRequestHandler
+from core.bottle.bottle import Bottle, run
+#route, post, head, request, error, run
+from utils.utils import get_list_overlays, load_config, write_config, sort_install_pkg
+from utils.package import search
+from utils.findfsdb import on_find 
+from core.route import Router
+from core.jwt import genaratorSecretsToken
+import logging
+from io import BytesIO
+#repl = '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n<!DOCTYPE repositories SYSTEM "http://www.gentoo.org/dtd/repositories.dtd">'
+
+app = Bottle()
+@app.post('/login')
+def login(user='demo', password='demo'):
+    if auth():
+        return(generatoSecretsToken())
+    else:
+        return ("403")
+@app.post('/')
+def  main():
+    try:
+        with open('./pkgs.json', 'tr') as fn:
+            data = fn.read()
+            pkg_list = json.loads(data)
+            #print(pkg_list)
+        return json.dumps(pkg_list)    
+    except Exception(e):
+        print(e)
+        return "404"
+
+@app.post('/set/settings')
+def set_settings_app(params):
+    config = load_config()
+    # param = self.path.replace("/?st_app=", "") 
+    list_param = param.split(',')
+    print(list_param)
+    for i in list_param:
+        if i.startswith('port'):
+            port = int(i.split('=')[1])    
+        elif i.startswith('Lang'):
+            Lang = i.split('=')[1]
+                
+    write_config(port, Lang)
+    print(config)
+    print(param)
+
+@app.post('/find')
+def search(pkg):
+    # param = self.path.replace("/find?pkg=", "")  #request['params']['name']
+    Pk_list = []
+    Search_result = {}
+    if len(param.split('/')) == 2:
+        param = param.split('/')[1]
+        P_list = on_find(param)
+        print(p_list)
+    if len(P_list) == 0:
+        print("Never Found")
+        self.r_t = str(json.dumps({"Package_result": p_list}))
+    else:
+        for p in p_list:
+            print(p)
+    if len(param.split("/")) == 2:
+        Pk_list.append(search(param.split("/")[1]))
+    else:
+        Pk_list.append(search(param))
+        # print(pk)
+    Search_result = {"Package_result": Pk_list}
+    # self.r_t = str(json.dumps(search_result))
+    return str(json.dumps(Search_result))
+    # self.r_t = json.dumps(pkg_list)
+
+@app.post('/get/settings')
+def get_settings_app():
+    return str(json.dumps(load_config()))
+
+@app.post('/install')
+def install():
+    # os.sys(emerge <pkgName>)
+    pass
+
+@app.post('/delete')
+def delete():
+    #os.sys('emerge  -C <pkgName>')
+    pass
 
+@app.post('/get/set_world')
+def get_setWorld():
+    """with open('/var/lib/portage/set_world') as fSet:
+        setList  = fSet.read().split('\n')
+    return json.dumps('set_world':setList})
+
+    """
+@app.post('/set/set_world')
+def set_setWorld():
+    pass
+
+@app.post('/docs')
+def docs():
+    pass 
+
+@app.route('/',['GET'])
+def req_get():
+    try:
+        with open('./pkgs.json', 'tr') as fn:
+            data = fn.read()
+            pkg_list = json.loads(data)
+            #print(pkg_list)
+        return json.dumps(pkg_list)    
+    except Exception(e):
+        print(e)
+        return "404"
+    
+    
+    #return"  403"
+
+
+
+def runServer():
+    create_db()
+    config = load_config()
+    if len(config) == 0:
+        print("Файл конфигурации пустой.")
+        return 1
+    try:
+        print(config['PORT'])
+    except KeyError:
+        print("KeyError")
+    except KeyboardInterrupt:
+        pass
+    #[3] keyfile='key.pem',
+    run(host='0.0.0.0', port= config['Server']['PORT'], certfile='localhost.pem')
+
+
+
+
+
+
+
+
+
+"""
 def https_server():
-    https_server_address  = ('', 4443)
+    https_server_address = ('', 4443)
     httpd = HTTPServer(https_server_address, SimpleHTTPRequestHandler)
     httpd.socket = ssl.wrap_socket(httpd.socket,
                                     server_side = True,
@@ -33,14 +176,14 @@ def run():
         pass
     
     # server = HTTPServer(('', config['PORT']), Router)
-    server = HTTPServer(('', config['PORT']), Handler)
+    server = HTTPServer(('', config['Server']['PORT']), Handler)
     # print('Started HTTP Server on port', config['PORT'])
     
     server.socket = ssl.wrap_socket(server.socket,
                                     server_side = True,
                                     certfile = 'localhost.pem',
                                     ssl_version = ssl.PROTOCOL_TLS)
-    print('Started HTTP Server on port', config['PORT'])
+    print('Started HTTP Server on port', config['Server']['PORT'])
     print("https://localhost:8000")
     
     try:
@@ -48,9 +191,10 @@ def run():
     except KeyboardInterrupt:
         logging.info('Stopping httpd...\n')
     server.server_close()
-   
+"""   
 if __name__ == '__main__':
     #https_server()
-    run()
-    https_server()
+    #run()
+    #https_server()
+    runServer()
 

utils/findfsdb.py

@@ -3,13 +3,105 @@
 import os, sys
 import json
 from io import StringIO  
-from utils.utils import get_list_overlays, sort_install_pkg
+from utils.utils import get_list_overlays, sort_install_pkg, load_config
 from utils.GenRecovers import ScanRecoverFile
 from utils.getUses import get_global_USE, get_local_USE
 from utils.package import search
+from utils.parsePortage import PortageConfig
 # создаём раcширенную базу пакетов с приблизительной структурой
 # pkg_list ={"category": [{name: name_pkg, versions:[list_version]}]}
 # и кладём это всё в json
+
+
+class PortageConfig():
+    def __init__(self):
+        self.Config = load_config()
+        self.TargetParse =['USE', 'USE_EXPAN', 'VIDEO_CARDS', 'ACCEPT_CHOSTS', 'ACCEPT_LICENSE','CCACHE_DIR', 'CCACHE_SIZE',
+                    'EMERGE_DEFAULT_OPTS', 'CFLAGS', 'CXXFLAGS', 'MAKEOPTS']
+        self.MakeConfig={}
+        self.EnvPortaga ={}
+        #super().__init__(self.run())
+
+    def getLines(self, filename):
+        if os.path.exists(filename):
+            with open (filename, 'r') as f:
+                lines = f.read().split("\n")
+        else:
+            print("path is not Found")
+        return lines
+
+    def parseMakeConf(self):
+        StateBox = 'Null'
+        Lines = self.getLines(self.Config['Portage']['make.conf'])
+
+        for line in Lines:
+            if not line.startswith('#') and len(line.split("="))>1:
+                line.replace('"', "")
+                if StateBox == 'Null' and not line.endswith('"'):
+                    StateBox = line.split('=')[0]
+                    self.MakeConfig[StateBox] =[] 
+                                    
+                    self.MakeConfig[StateBox] = line.split('=')[1].split(" ")
+                    for i in  line.split('=')[1].split(" "):
+                        self.MakeConfig[split('=')[0]].append(i)
+                elif StateBox !='Null' and not line.endswith('"'):
+                    StateBox = line.split('=')[1]
+                    for i in  line.split('=')[1].split(" "):
+                        self.MakeConfig[line.split('=')[0]].append(i)
+                elif StateBox == 'Null' and line.endswith('"'):
+                    #line.replace('"', "")
+                    self.MakeConfig[line.split('=')[0]] = line.split('="')[1].split(" ")
+        self.EnvPortaga['make.conf'] = self.MakeConfig        
+        print(self.MakeConfig)
+    
+    def templParse(self, parm, res=False):
+        self.MakeConfig[parm] =[]
+        Lines = self.getLines(self.Config['Portage'][parm])
+        for i in Lines:
+            if not i.startswith('#'):
+                self.MakeConfig[parm].append(dict(Name=i.split(" ")[0], Uses=i.split(" ")[1:]))
+            
+        if res:
+            print(self.MakeConfig[parm])
+            return self.MakeConfig[parm]
+            
+        self.EnvPortaga[pam] = self.MakeConfig[parm]
+
+    def parsePackageUse(self):
+      self.templParse('package.use')
+
+    def parsePackageMasks(self):
+        sel.templParse('package.mask')
+
+    def parsePakageUnmask(self):
+        self.templParse("package.unmask")
+
+    def parsePackageKeywords(self):
+        self.templParse('package.accept_keywords')
+
+    def run(self):
+       self.parseMakeConf()
+       self.templParse('package.use', res=True)
+       self.templParse('package.mask', res=True)
+       self.templParse('package.unmask', res=True)
+       self.templParse('package.accept_keywords', res=True)
+       return self.EnvPortaga
+
+
+if __name__ ==  '__main__':
+    Test = PortageConfig()
+    if sys.argv[1] == "envMake":   
+        Test.parseMakeConf()
+    elif sys.argv[1] == "use":
+        Test.templParse('package.use', res=True)
+    elif sys.argv[1] == "mask":
+        Test.templParse('package.mask', res=True)
+    elif sys.argv[1] == "unmask":
+        Test.templParse('package.unmask', res=True)
+    else:
+        pass
+
+
 #
 
 AliaseCategory ={
@@ -57,12 +149,13 @@ AliaseCategory ={
 				 }
 
 def create_db():
-	overlays = get_list_overlays()
-	recovers = ScanRecoverFile()
+	#overlays = get_list_overlays()
+	#recovers = ScanRecoverFile()
 	pkg_list = {}
 	listUses = dict(LocalUSE = get_local_USE(), GlobalUSE = get_global_USE()) #[0] LocalUSE = get_local_USE(),
-	InstallPkgs = sort_install_pkg()
-	portage_list = {}
+	#InstallPkgs = sort_install_pkg()
+	#portage_list = {}
+	#PortEnv = PortageConfig().run()
 	port_dir = ["/var/db/repos", "/usr/portage"]
 	if not os.path.exists('./pkgs.json'):
 		print("Create ramdb")
@@ -107,9 +200,9 @@ def create_db():
 									pkg_list[d.split("/")[-2]].append(d.split('/')[-1])
 									#print([d.split('/')[-1]])
 			#"all_pkgs": all_pkgs, [0]
+			InstallPkgs = sort_install_pkg(all_pkgs)
             
-			fn.write(json.dumps({ "all_pkgs": all_pkgs, "Catalog": pkg_list,"overlays": overlays,  "aliases": AliaseCategory, "recovers": recovers, "usesDecription":listUses, "InstallPkgs":InstallPkgs }))
-			#json.length "InstallPkgs":InstallPkgs
+			fn.write(json.dumps({ "all_pkgs": all_pkgs, "Catalog": pkg_list, "overlays": get_list_overlays(),  "aliases": AliaseCategory, "recovers": ScanRecoverFile(), "usesDecription":listUses, "InstallPkgs":sort_install_pkg(), 'EnvPortage': PortageConfig().run()}))
 		print(len(pkg_list))
 	"""
 	with open('./portage.json', 'w') as p:

utils/package.py

@@ -3,6 +3,7 @@
 import json
 import portage
 portage.root
+from utils.parsePortage import PortageConfig
 portge = portage.db[portage.root]["porttree"].dbapi
 #from utils.utils import sort_install_pkg
 #ПЛАН:
@@ -19,6 +20,7 @@ def search(r_p):
     Description = ""
     Home_page = ""
     repository = ""
+    #PortEnv = PortageConfig.run()
     try:
         parametrs = ["HOMEPAGE", "IUSE","DESCRIPTION", "repository", "LICENSE"]
         #print(r_p)
@@ -58,12 +60,12 @@ def search(r_p):
         else:
             Name = "Package is not Found" 
 
-        #print(Category + "\n" + Name + "\n" + version +"\n" + USE + "\n" + Description + "\n" + Home_page  +"\n") 
-        #p_list = str(Category + "\n" + Name + "\n" + version +"\n" + USE + "\n" + Description + "\n" + Home_page  +"\n")
+        print(Category + "\n" + Name + "\n" + version +"\n" + USE + "\n" + Description + "\n" + Home_page  +"\n") 
+        p_list = str(Category + "\n" + Name + "\n" + version +"\n" + USE + "\n" + Description + "\n" + Home_page  +"\n")
     except Exception as e:
         print(str(e))
         p_list = " ERROR IN Package "
         
-    pkg = {"Category": Category, "Name": Name, "version": version.split("    "), "USE": USE.split(" "), "Description": Description, "Home_page": Home_page, 'repo': str(repository) }
+    pkg = {"Category": Category, "Name": Name, "version": version.split("    "), "USE": USE.split(" "), "Description": Description, "Home_page": Home_page, 'repo': str(repository)}
     print(pkg)
     return pkg

utils/parsePortage.py

@@ -1,13 +1,20 @@
 #-*- codding:UTF-8 -*-
-#!/usr/bin/env python
 import os, sys, json
-from utils import load_config
+try:
+    from utils.utils import load_config
+except Exception as  e:
+    print(e)
+
 class PortageConfig():
     def __init__(self):
         self.Config = load_config()
         self.TargetParse =['USE', 'USE_EXPAN', 'VIDEO_CARDS', 'ACCEPT_CHOSTS', 'ACCEPT_LICENSE','CCACHE_DIR', 'CCACHE_SIZE',
                     'EMERGE_DEFAULT_OPTS', 'CFLAGS', 'CXXFLAGS', 'MAKEOPTS']
+        
         self.MakeConfig={}
+        self.EnvPortaga ={}
+        super().__init__(self.run())
+
     def getLines(self, filename):
         if os.path.exists(filename):
             with open (filename, 'r') as f:
@@ -37,29 +44,50 @@ class PortageConfig():
                 elif StateBox == 'Null' and line.endswith('"'):
                     #line.replace('"', "")
                     self.MakeConfig[line.split('=')[0]] = line.split('="')[1].split(" ")
-                    
+        self.EnvPortaga['make.conf'] = self.MakeConfig       
         print(self.MakeConfig)
+    
+    def templParse(self, parm, res=False):
+        self.MakeConfig[parm] =[]
+        Lines = self.getLines(self.Config['Portage'][parm])
+        for i in Lines:
+            self.MakeConfig[parm].append(dict(Name=i.split(" ")[0], Uses=i.split(" ")[1:]))
+        
+        if res:
+            print(self.MakeConfig[parm])
+            return self.MakeConfig[parm]
+        
+        self.EnvPortaga[pam] = self.MakeConfig[parm]
 
     def parsePackageUse(self):
-        self.MakeConfig['package.use'] =[]
-        Lines = self.getLines(self.Config['Portage']['package.use'])
-        for i in Lines:
-            self.MakeConfig['package.use'].append(dict(Name=i.split(" ")[0], Uses=i.split(" ")[1:]))
+      self.templParse('package.use')
 
     def parsePackageMasks(self):
-        Lines = self.getLines(self.Config['Portage']['package.mask'])
+        sel.templParse('package.mask')
 
     def parsePakageUnmask(self):
-        Lines = self.getLines(self.Config['Portage']["package.unmask"])
+        self.templParse("package.unmask")
 
     def parsePackageKeywords(self):
-        Lines = self.getLines(self.Config['Portage']['package.accept_keywords'])
+        self.templParse('package.accept_keywords')
+
+    def run(self):
+       self.parseMakeConf()
+       self.templParse('package.use', res=True)
+       self.templParse('package.mask', res=True)
+       self.templParse('package.unmask', res=True)
+       self.templParse('package.accept_keywords', res=True)
+
 
 if __name__ ==  '__main__':
     Test = PortageConfig()
     if sys.argv[1] == "envMake":   
         Test.parseMakeConf()
     elif sys.argv[1] == "use":
-        Test.parsePackageUse()
+        Test.templParse('package.use', res=True)
+    elif sys.argv[1] == "mask":
+        Test.templParse('package.mask', res=True)
+    elif sys.argv[1] == "unmask":
+        Test.templParse('package.unmask', res=True)
     else:
-        Test.parseMakeConf()
+        pass

utils/utils.py

@@ -3,7 +3,7 @@
 '__autor__' == 'serkus'
 import os, sys, json
 from urllib import request
-from package import search
+from utils.package import search
 # import xml
 import xml.etree.ElementTree as ET
 
@@ -143,11 +143,11 @@ def load_config():
 
 # SORT IN  INTALL PAKAGES
 # ''
-def sort_install_pkg():
+def sort_install_pkg(Tree):
     #pkg =scan_config_portage()
     INSTALL = {}
     pkg_name =""
-    TrePortage = ScanTreePortage()
+    ##TrePortage = ScanTreePortage()
     path = '/var/db/pkg/'
     for d, dirs, files in os.walk(path):
         for f in files:
@@ -168,20 +168,39 @@ def sort_install_pkg():
                     INSTALL[d.replace(path,"").split('/')[0]].append(dict(name = pkg_name[:-1], ver = f.replace(pkg_name, "")))           
             else:
                 INSTALL[d.replace(path,"").split('/')[0]].append(dict(name = pkg_name[:-1],ver = f.replace(pkg_name, "")))
-                if d.replace(path, "").split('/')[0] not in INSTALL:
-                    INSTALL[d.replace(path, "").split('/')[0]] = []
-                    INSTALL[d.replace(path, "").split('/')[0]].append(f.replace(".ebuild", "") )
-                    INSTALL[d.replace(path,"").split('/')[0]].append(f.replace(".ebuild", "")) #dict(name = pkg_name[:-1],ver = f.replace(pkg_name, "")
+                #if d.replace(path, "").split('/')[0] not in INSTALL:
+                INSTALL[d.replace(path, "").split('/')[0]] = []
+                INSTALL[d.replace(path, "").split('/')[0]].append(f.replace(".ebuild", "") )
+                INSTALL[d.replace(path,"").split('/')[0]].append(f.replace(".ebuild", "")) #dict(name = pkg_name[:-1],ver = f.replace(pkg_name, "")
                 
 
     #print(str(len(INSTALL)))
     #return json.dumps({'install_pkgs':INSTALL})
     return  INSTALL
-def ScanTreePortage():
-    DirsRoot = ["/var/db/repos", "/usr/portage"]
-   #d, ListTree, f for in os.walk('/usr/portage') and d, ListTree, f for in os.walk("/var/db/repos")
-    #return ListTree
 
+def ScanTreePortage():
+    DirsRoot = [ "/var/db/repos", "/usr/portage"]
+    ListTree = []
+    for p in DirsRoot:
+        for d, dirs, files in os.walk(p):
+            for f in files:
+                if f.endswith('.ebuild'):
+                    #print(d +"/" + f)
+                    pkg_name = ""
+                    try:
+                        #ver = int(f.replace('.ebuild', '').split('-')[-1][0])
+                        for pn in f.replace('.ebuild', '').split('-')[:-1]:
+                            pkg_name = pkg_name + pn + "-"
+                    except TypeError:
+                        for pn in f.replace('.ebuild', '').split('-')[:-2]:
+                            pkg_name = pkg_name + pn + "-"
+                    except Exception as e:
+                        print(e)
+                        #str(d.split("/")[-2] +"/" + d.split("/")[-1])
+                        ListTree.append(pkg_name)
+    #d, ListTree, f for in os.walk('/usr/portage') and d, ListTree, f for in os.walk("/var/db/repos")
+    return ListTree
+"""
 def scan_config_portage():
     Dirs_root = ["/var/db/repos", "/usr/portage"]
     Config = {}
@@ -201,3 +220,4 @@ def scan_config_portage():
     #config = {'portage': pf}
     #print("config:\t" + str(config))
     return Config
+"""