easy-utils-dev 2.131__py3-none-any.whl → 2.133__py3-none-any.whl

easy_utils_dev/ept.py

@@ -1,12 +1,13 @@
 import xml.etree.ElementTree as ET
 from bs4 import BeautifulSoup    
 from easy_utils_dev.simple_sqlite import initDB
-from easy_utils_dev.utils import getRandomKey , getTimestamp , lget , mkdirs
+from easy_utils_dev.utils import getRandomKey , getTimestamp , lget , mkdirs , start_thread
 import json , os , glob
 from easy_utils_dev.FastQueue import FastQueue
 from easy_utils_dev.debugger import DEBUGGER 
 import zipfile
 import tempfile
+from collections import defaultdict
 
 
 __LIBPATH__ = os.path.dirname(os.path.abspath(__file__))
@@ -65,6 +66,13 @@ class EPTManager :
         db = initDB()
         db.config_database_path(self.ept_db_path)
         return db
+    
+    def create_ept_tables_from_sql(self) :
+        self.logger.info("Creating EPT Database Tables from SQL ...")
+        db = self.Database()
+        db.execute_script( f"{os.path.join(__LIBPATH__ , 'ept_sql' , 'create_ept_tables.sql')}")
+        self.logger.info("Creating EPT Database Tables from SQL completed")
+
 
     def create_ept_columns(self , drop_cols=[]) :
         self.logger.info("Creating EPT Database Tables ...")
@@ -119,41 +127,54 @@ class EPTManager :
 
     def create_ept_rows(self) :
         self.logger.info("Creating EPT Rows ...")
-        tags = [str(tag.name) for tag in self.root.find_all() ]
-        tags = list(set(tags))
+        all_tags = list(self.root.find_all())
+        unique_table_names = list({str(tag.name) for tag in all_tags})
+        grouped_by_table = defaultdict(list)
+        for t in all_tags:
+            grouped_by_table[str(t.name)].append(t)
         db = initDB()
         db.config_database_path(self.ept_db_path)
-        for tableName in tags :
-            tags = self.root.find_all(tableName)
+        table_columns_map = {}
+        for table_name in unique_table_names:
+            query = f"PRAGMA table_info({table_name})"
+            cols = db.execute_dict(query)
+            table_columns_map[table_name] = [c['name'] for c in cols]
+        for table_name in unique_table_names:
+            elements = grouped_by_table.get(table_name)
+            if not elements:
+                continue
+            column_names = table_columns_map[table_name]
             rows = []
-            query = f"PRAGMA table_info({tableName})"
-            columns = db.execute_dict(query)
-            for tag in tags :
-                template = {}
-                for column in columns :
-                    template[column['name']] = None
+            rows_append = rows.append
+            for tag in elements:
+                template = dict.fromkeys(column_names, None)
                 attrs = tag.attrs
-                if len(list(attrs.keys())) > 0 :
-                    for key , _ in template.items() :
-                        template[key] = attrs.get(key , None)
-                    template['parentId'] = tag.parent.attrs.get('id')
-                    template['parentTag'] = tag.parent.name
-                    template['grandparentId'] = tag.parent.parent.attrs.get('id')
-                    template['grandparentTag'] = tag.parent.parent.name
-                    if self.include_parent_attrs :
-                        template['parentAttrs'] = json.dumps(tag.parent.attrs)
-                    if self.include_grantparent_attrs :
-                        template['grandparentAttrs'] = json.dumps(tag.parent.parent.attrs)
-                    rows.append(template)
-                    # print(f"[{tableName}] : Adding Row ")
-            if len(rows) > 0 :
-                db.insert_to_table_bulk(tableName=tableName , values=rows)
+                if attrs:
+                    for key in column_names:
+                        if key in attrs:
+                            template[key] = attrs[key]
+                parent = tag.parent
+                if parent is not None:
+                    template['parentId'] = parent.attrs.get('id')
+                    template['parentTag'] = parent.name
+                    if self.include_parent_attrs:
+                        template['parentAttrs'] = json.dumps(parent.attrs)
+                    grandparent = getattr(parent, 'parent', None)
+                    if grandparent is not None:
+                        template['grandparentId'] = grandparent.attrs.get('id')
+                        template['grandparentTag'] = grandparent.name
+                        if self.include_grantparent_attrs:
+                            template['grandparentAttrs'] = json.dumps(grandparent.attrs)
+                rows_append(template)
+            if rows:
+                db.insert_to_table_bulk(tableName=table_name , values=rows)
+        self.logger.info("Creating EPT Rows completed")
                 
     def parse(self) :
         if self.design_path.endswith('.ept') :
             self.extract_ept(self.design_path)
 
-        with open(self.design_path , 'r') as file :
+        with open(self.design_path , 'r' , encoding='utf-8') as file :
             xml_content = file.read()
         xml_content  = self.fix_xml_file(xml_content)
         self.root = BeautifulSoup( xml_content, 'xml')
@@ -174,7 +195,6 @@ class EPTManager :
     def _create_v_dirs(self) :
         db = self.Database()
         dirs = self.get_all_dirs()
-
         db.createTable(
             'c_dirs' ,
             data=[
@@ -256,7 +276,7 @@ class EPTManager :
 
     def _create_crossconnections_table(self) : 
         query = f"""
-        CREATE TABLE c_crossconnections AS
+        CREATE VIEW c_crossconnections AS
         SELECT DISTINCT 
             p.owner as wdmdemand, 
             sh.number || '-' || sm.physicalslot || '-L' || p.portnumber as physicalslot ,
@@ -283,9 +303,96 @@ class EPTManager :
         db = self.Database()
         db.execute_dict(query)
 
+    def _create_ports_inventory(self) : 
+        query = f"""
+        CREATE VIEW c_port_inventory AS
+        select 
+            p.pluggable as moduletype, 
+            p.pluggableapn as partnumber,
+            p.portnumber,
+            p.connectortype,
+            cp.slotid,
+            cp.id as eptpackid , 
+            p.id as eptpid , 
+            sh.id as eptshid , 
+            s.id as eptsid , 
+            sh.number as shelfid,
+            sm.physicalslot,
+            s.name as sitename,
+            CASE 
+                WHEN p.connectortype LIKE 'Line%' 
+                    THEN sh.number || '-' || sm.physicalslot || '-L' || p.portnumber
+                WHEN p.connectortype LIKE 'Client%' 
+                    THEN sh.number || '-' || sm.physicalslot || '-C' || p.portnumber
+                WHEN p.connectortype LIKE '%VOA%' 
+                    THEN sh.number || '-' || sm.physicalslot || '-VA' || p.portnumber
+                ELSE NULL
+            END as custom_portname ,
+            CASE 
+                WHEN p.pluggable IS NULL AND physicalslot IS NOT NULL  AND p.pluggableapn is NULL
+                    THEN 'free'
+                ELSE 'busy'
+            END as portstatus
+        from port p
+        JOIN circuitpack cp ON p.parentId = cp.id 
+        JOIN shelf sh ON cp.parentId = sh.id
+        JOIN site s ON sh.grandparentId = s.id
+        JOIN slot_mapping sm ON sh.type = sm.shelfType AND cp.slotid = sm.logicalSlot
+        JOIN OTtype ot ON ot.OTtype = cp.type 
+        WHERE ( p.connectortype IS NOT NULL ) ;
+        """
+        db = self.Database()
+        db.execute_dict(query)
+
+    def _create_enhanced_dirs(self) : 
+        query = f"""
+        CREATE VIEW c_enhanced_dirs AS
+        select DISTINCT
+        line.id as eptlineid , 
+        line.span as spanid , 
+        site.id as eptsitenameid ,
+        spn.name as eptsegementname , 
+        line.wdmlink as wdmlinkid ,
+        cp.type as boardtype ,
+        sh.type as shelftype,
+        sp.physicalslot as slot ,
+        sh.number as shelfid ,
+        site.name as sitename ,
+        segt.id as segementid , 
+
+        CASE
+            WHEN segt2.asite = site.id THEN site_b.name
+            WHEN segt2.bsite = site.id THEN site_a.name
+        END AS farsitename,
+
+        CASE 
+            WHEN segtinfo.orient = 'AB' AND segt2.asite = site.id THEN segtinfo.dist
+            WHEN segtinfo.orient = 'AB' AND segt2.bsite = site.id THEN segtinfo.dist
+            WHEN segtinfo.orient = 'BA' AND segt2.asite = site.id THEN segtinfo.dist
+            WHEN segtinfo.orient = 'BA' AND segt2.bsite = site.id THEN segtinfo.dist
+        END AS distance ,
+        sh.number || "-" || sp.physicalSlot as fullslot 
+        from line 
+        JOIN circuitpack cp ON cp.wdmline = line.id AND ( cp.packIDRef IS NOT NULL OR cp.type = oa.OAtype )
+        JOIN site on site.id = sh.grandparentId
+        JOIN OAtype as oa
+        JOIN shelf sh ON sh.id = cp.parentId
+        JOIN slot_mapping sp on sp.logicalSlot = cp.slotid  AND sh.type = sp.shelftype
+        JOIN span spn ON spn.id = line.span AND spn.ashelfset IS NOT NULL
+        JOIN segt ON segt.grandparentId = spn.id 
+        JOIN segt segt2 ON segt.id = segt2.id AND segt2.asite IS NOT NULL
+        JOIN segtinfo ON segtinfo.parentId = segt.id 
+        JOIN site AS site_a ON site_a.id = segt2.asite
+        JOIN site AS site_b ON site_b.id = segt2.bsite
+        GROUP BY line.id ;
+
+        """
+        db = self.Database()
+        db.execute_dict(query)
+
     def _create_card_inventory(self) : 
         query = f"""
-        CREATE TABLE c_card_inventory AS
+        CREATE VIEW c_card_inventory AS
         SELECT DISTINCT 
             sh.number || '-' || pack.physicalslot AS slot,
             sh.number AS shelfid, 
@@ -331,16 +438,55 @@ class EPTManager :
         db = self.Database()
         db.execute_dict(query)
 
+    def _create_shelf_inventory(self) : 
+        query = f"""
+        CREATE VIEW c_shelf_info AS
+        SELECT 
+            sh.type AS  shelftype ,
+            sh.number AS shelfnumber,
+            sh.apn AS partnumber ,
+            st.name AS sitename
+        FROM shelf sh
+        JOIN site st ON st.id = sh.grandparentId
+        WHERE sh.number != 0
+        UNION ALL
+        SELECT 
+            cp.type AS  shelftype ,
+            cp.dcmpseudoshelf AS shelfnumber,
+            cp.apn AS partnumber ,
+            st.name as sitename 
+        FROM circuitpack cp
+        JOIN shelf sh ON sh.id = cp.parentId
+        JOIN site st ON sh.grandparentId = st.id 
+        WHERE cp.dcmpseudoshelf IS NOT NUll ;
+        """
+        db = self.Database()
+        db.execute_dict(query)
+
+    def _create_site_tmp_table(self) : 
+        query = f"""
+        CREATE TABLE c_tmp_site_view AS
+        SELECT * FROM site;
+        """
+        db = self.Database()
+        db.execute_dict(query)
+
     def convert_design(self , drop_cols=[] ) :
         start = getTimestamp()
         db = self.Database()
         self.parse()
-        self.create_ept_columns(drop_cols=drop_cols)
+        self.create_ept_tables_from_sql()
         self.create_ept_rows()
-        db.execute_script(f"{os.path.join(__LIBPATH__ , 'ept_sql' , 'create_dirs.sql')}")
-        self._create_v_dirs()
-        self._create_crossconnections_table()
-        self._create_card_inventory()
+        # db.execute_script(f"{os.path.join(__LIBPATH__ , 'ept_sql' , 'create_dirs.sql')}")
+        a = start_thread(self._create_v_dirs , daemon=True)
+        b = start_thread(self._create_crossconnections_table , daemon=True)
+        c = start_thread(self._create_card_inventory , daemon=True)
+        d = start_thread(self._create_shelf_inventory , daemon=True)
+        s = start_thread(self._create_site_tmp_table , daemon=True)
+        s = start_thread(self._create_ports_inventory , daemon=True)
+        s = start_thread(self._create_enhanced_dirs , daemon=True)
+        a.join() ; b.join() ; c.join() ; d.join() ; s.join()
+        
         end = getTimestamp()
         if os.path.exists(self.tmp_design_path) :
             os.remove(self.tmp_design_path)