#<profile4xi profile = "31"/>
#<program4xi program = "get2sense4xi.py">
#<abstract4xi abstract = "fetches sending defined programs from scope4xi folders"/>
#<refer4xi reference = "Studio4Xi"/>
#<note4xi note = "output is automatically deleted and written again by opening to write"/>
#<state4xi status = "ACK4review; ACK4tagging; ACK4moduletesting; ACK4systemtesting; [Rel 7.21]"/>
#<use4xi usage = "
#
# 1) go to Studio4Xi in commmand mode
#     > go3studio4fb    <-- Python 3 version of Studio4Xi in Fastblack workstation (fb)
#     > go3studio4riika <-- Python 3 version of Studio4Xi in Riika
#     nb: you could use the same go2studio4xi-command in all workstations just defining root! 
#
# 2) edit version4xi.py
#     TIP 1: you can command this module to 
#            a) upgrade the input to newer HTML version
#            b) change Content Management System (CMS)-object references to HTML-type hyperlinks
#            see kb2correct and kb2replace
#     TIP 2: you typically perform steps 2) to 9) when you automatically upgrade content (TIP 1)   
#            whereas once you have done it, you normally perform
#            Step 1) get2all Step 2) edit Step 3) put2all
#
#     ===========================================================================================================                         
#     get2sense4xi.py 
#     ===========================================================================================================                          
#       'folder2view4sense':     '..//..//..//..//dragonxi//pc4xi//YoDragonXiOrg//WebSite//sense//hw//',  
#       'folder2temp4sense':     '..//..//..//..//temp//sense//',   
#
# 3) update in this module
#    a) TO-BE-CORRECTED IN INPUT 
#    b) TO-BE-REPLACED IN INPUT 
#    c) TIROOT4XI 
#    and before you run get2sense4xi, 
#    d) clear 'folder2temp4sense' folder!
#    e) make sure version4xi.py settings are ok, see above!
#
# 4) > get2sense4xi
#
# 5) view what you got (ROOT4XI defined in version4xi.py)
#      trace ROOT4XI:\STUDIO4XI\Python\3.3\txt\get2sense4xi.txt
#        note: Pipe4Xi and Queue4Xi are being activated for future use if more performance is required
#      browser HTML files in 'folder2temp4sense', example: file:///ROOT4XI:/temp/sense/en-jp-hw-xi2.html (Japan's hardware sensing) or index-hw-xi2 (Hardware Sensing)
#      check:
#      a) returns in china files *cn*.html,      for example in en-sh-cn-hw-xi2.html <td><b>&laquo;</b><a href="../en-cn-hw-xi2/" target="_blank">Gov Sensing in China</a></td>      
#      b) returns in U.S. state files *us*.html, for example in en-ca-us-hw-xi2.html <td><b>&laquo;</b><a href="../en-us-hw-xi2.html" target="_blank">U.S. Hardware Sensing</a></td>
#      c) return of other country files to main, for example in en-nl-hw-xi2.html    <td><b>&laquo;</b><a href="../../index-hw-xi2.html" target="_blank">Hardware Sensing</a></td>
#      d) index of content,                      for example index-hw-xi2.html and its date <b>&Delta;</b> 1st of June 2014 <b>&Omega;</b> 9:07 AM</h2></a>
#
#      see get2all.bat
#          copy ..\..\..\..\dragonxi\pc4xi\YoDragonXiOrg\WebSite\sense\hw\ae\en\en-ae-hw-xi2.html /y
#          .... 
#      see put2all.bat
#          copy en-ae-hw-xi2.html ..\..\..\..\dragonxi\pc4xi\YoDragonXiOrg\WebSite\sense\hw\ae\en\en-ae-hw-xi2.html /y
#          copy en-ah-cn-hw-xi2.html ..\..\..\..\dragonxi\pc4xi\YoDragonXiOrg\WebSite\sense\hw\cn\ah\en-ah-cn-hw-xi2.html /y 
#          ...
#
#      TIP 2: hyperlinks to other HTML files in this temporary folder naturally won't work!
#      TIP 3: manually edit date and time in headers, if necessary!
#
# 6) update orginal files (commanding it in 'folder2temp4sense' or using GUI!)  
#    > put2all
#      TIP 1: if you got anything, you got them all and after editing in temporary folder you can rely on put2all.bat to do its job!
#      TIP 2: start to edit from now on in the final environment after performing put2all.bat i.e. do not edit too much in temp environment!
#
# 7) browser updated files
#     TIROOT4XI test index file such as file:///ROOT4XI/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/sense/hw/index-hw-xi2.html
#       for example: file:///E:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/sense/hw/index-hw-xi2.html
#
# 8) upgrade final work directory for content, for example ROOT4XI:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\hw\xx 
#       TIP 1: delete extra such as dir.txt, HTML-files except index.html and other *.bat
#       TIP 2: copy put2all.bat and get2all.bat there
# 
# 9) edit get2all.bat in final work directory by starting to use relative paths 
#       example: ROOT4XI\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\hw\xx\get2all.bat  <-- copy ..\ae\en\en-ae-hw-xi2.html 
#                ROOT4XI\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\hw\xx\put2all.bat  <-- copy en-ae-hw-xi2.html ..\ae\en\en-ae-hw-xi2.html /y
#
# 10) run get2all.bat in final work directory 
#       TIP 1: remember that china (cn) and usa (us) have their own xx subfolder
#              which should be empty, if not then delete HTML files there
#              otherwise you risk to remember performing get operation to them!
#              note: because get2all.bat fetches both USA and China HTML file you get lot of files!
#       TIP 2: this step is optional depending on your updates i.e. you may skip this step!   
#
# 11) edit HTML files in final work directory
#       TIP 1: this step is optional depending on your updates i.e. you may skip this step!  
#       
# 12) run in final work folder >put2all
#       TIP 1: this step is optional depending on your updates i.e. you may skip this step!  
#
# 13) test final updated HTML files
#       example: file:///ROOT4XI:/DRAGONXI/PC4Xi/YoDragonXiOrg/WebSite/sense/index-sense-xi2.html
#       TIP 1: use may depict the domaind such as hardware having updated by Pi symbol!
#     
# 14) FTP-upload final HTML files
#       ROOT4XI:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\index-sense-xi2.html
#                              --> /home/icefellow/webapps/yodragonxiorg/sense
#       content such as       ROOT4XI:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\hw
#                             --> /home/icefellow/webapps/yodragonxiorg/sense/hw   
#       TIP 1: delete the whole subfolder in server first, if necessary!
#
# 15) Backup
#       TIP 1: delete the whole subfolder in backup first, if wise (in general avoid deleting while taking backups because of risks such as power failure!)
# 
# 16) Use WEB content
#       https://www.yourdragonxi.org/sense/index-sense-xi2.html --> /home/icefellow/webapps/yodragonxiorg/sense
# 
# 17) start using get2all.bat and put2all.bat in original ROOT4XI:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\xx 
#     TIROOT4XI you repeat steps 2) to 9) whenever you have major changes to many files at the same time!
#
# 18) Note: edit find2html4dragon.py and run find2html4dragon.bat to verify output
#           if any errors such as old kind of HTML tags are found, mody and rerun get2sense4xi.py, click put2all
#           and repeat process until all HTML files are OK
#           TIP 1: do NOT try to get too many lines edited automatically but instead few lines
#           TIP 2: do NOT select too many or big domains but instead one or few ! 
#"
#/>
# -------------------------------------------------------------------------------------------------

# -------------------------------------------------------------------------------------------------
# Public API
# -------------------------------------------------------------------------------------------------
#<interface4xi interface = " 
__all__ = [ 'get2sense4xi' ]
#"
#/>

# -------------------------------------------------------------------------------------------------
# Standard Imports                          
# -------------------------------------------------------------------------------------------------
#<standardize4xi standard = "
import os,sys,string
import time4xi
#"
#/>

# -------------------------------------------------------------------------------------------------
# Studio4Xi imports                               
# -------------------------------------------------------------------------------------------------
#<dragonize4xi dragonization = "
import version4xi
from version4xi import VersionKB4Xi 
from version4xi import ROOT4XI
#"
#/>
# -------------------------------------------------------------------------------------------------
# Multiprocessing4xi imports                              
# -------------------------------------------------------------------------------------------------
#<dragonize4xi dragonization = "
from actor2a4xi import Actor2a4Xi                                                                                  
from actor2b4xi import Actor2b4Xi                                                                                   
from actor2c4xi import Actor2c4Xi
from actor2d4xi import Actor2d4Xi
from actor2e4xi import Actor2e4Xi
from actor2f4xi import Actor2f4Xi
from actor2g4xi import Actor2g4Xi
from actor2h4xi import Actor2h4Xi
from actor2i4xi import Actor2i4Xi
from actor2j4xi import Actor2j4Xi
from actor2k4xi import Actor2k4Xi
from actor2l4xi import Actor2l4Xi
from actor2m4xi import Actor2m4Xi
from actor2n4xi import Actor2n4Xi
from actor2o4xi import Actor2o4Xi
from actor2p4xi import Actor2p4Xi
from actor2q4xi import Actor2q4Xi
from actor2r4xi import Actor2r4Xi
from actor2s4xi import Actor2s4Xi
from actor2t4xi import Actor2t4Xi
from actor2u4xi import Actor2u4Xi
from actor2v4xi import Actor2v4Xi
from actor2w4xi import Actor2w4Xi
from actor2x4xi import Actor2x4Xi
from actor2y4xi import Actor2y4Xi
from actor2z4xi import Actor2z4Xi
from actor2_4xi import Actor2_4Xi
from pickle4xi import pickle4xi                                                                                   
from pickle2a4xi import Pickle2a4Xi
from pickle2b4xi import Pickle2b4Xi
from pickle2c4xi import Pickle2c4Xi
from pickle2d4xi import Pickle2d4Xi
from pickle2e4xi import Pickle2e4Xi
from pickle2f4xi import Pickle2f4Xi
from pickle2g4xi import Pickle2g4Xi
from pickle2h4xi import Pickle2h4Xi
from pickle2i4xi import Pickle2i4Xi
from pickle2j4xi import Pickle2j4Xi
from pickle2k4xi import Pickle2k4Xi
from pickle2l4xi import Pickle2l4Xi
from pickle2m4xi import Pickle2m4Xi
from pickle2n4xi import Pickle2n4Xi
from pickle2o4xi import Pickle2o4Xi
from pickle2p4xi import Pickle2p4Xi
from pickle2q4xi import Pickle2q4Xi
from pickle2r4xi import Pickle2r4Xi
from pickle2s4xi import Pickle2s4Xi
from pickle2t4xi import Pickle2t4Xi
from pickle2u4xi import Pickle2u4Xi
from pickle2v4xi import Pickle2v4Xi
from pickle2w4xi import Pickle2w4Xi
from pickle2x4xi import Pickle2x4Xi
from pickle2y4xi import Pickle2y4Xi
from pickle2z4xi import Pickle2z4Xi
from pickle2_4xi import Pickle2_4Xi 
from pipe4xi import Pipe4Xi   
from print4xi import print4xi
from print4xi import Print4Xi 
from process4xi import Process4Xi
from queue4xi import Queue4Xi
from time4xi import time4xi

from xml_trace_sense4xi import xml_trace_sense4xi                                                                   
from xml_trace_reason4xi import xml_trace_reason4xi
from xml_trace_ace4xi import xml_trace_ace4xi 
#"
#/>

# -------------------------------------------------------------------------------------------------
# Multiprocessing Imports                          
# -------------------------------------------------------------------------------------------------
#<process4xi process = "
import _multiprocessing
#"
#/>


# -------------------------------------------------------------------------------------------------
# Globals                            
# -------------------------------------------------------------------------------------------------
#<globalize4xi globalization = "
global count2skipped
global count2found
global count2total
global count2upgrade

global kb2fetch                              # knowledgebase for fetching
global kb2log                                # knowledgebase for log
global kb2correct                            # knowledgebase for correcting content
global kb2replace                            # knowledgebase for replacing content

global path2temp4source  
global path2read4xi                          # path for input files
global path2temp4xi                          # path for output files
global PickleKB4Xi
global profile2fetch                         # extension for files
global t2xi 
global trace_object_count
#"
#"/>

# -------------------------------------------------------------------------------------------------
# Settings 
# -------------------------------------------------------------------------------------------------
#<set4xi setting = "
count2skipped = 0
count2found   = 0
count2total   = 0                                                                                            
count2upgrade = 0

path2read4xi  = VersionKB4Xi['folder2view4sense']          # ROOT4XI://DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//tv//
path2temp4xi  = VersionKB4Xi['folder2temp4sense']          # ROOT4XI://STUDIO4XI//Python//3.3//temp//sense//

kb2log = {}
kb2fetch = {}
                                                           # objects not to be fetched                         
kb2fetch[1] = 'index.html'                                 # special file to prohibit server folder access
kb2fetch[2] = path2read4xi + 'xx'                          # work folder 

kb2correct = {}
kb2replace = {}

# -------------------------------------------------------------------------------------------------
# TO-BE-CORRECTED IN INPUT (ADJUST, IF REQUIRED, KEEPING EXISTING PATTERNS BY ADDING NEW ONES!)
# -------------------------------------------------------------------------------------------------

# VARIABLES TO-BE-EDITED FOR SENSING 
domain2sense  = "UAS"                 # <-------------------------------------- DOMAIN SELECT!

ack2capital4all = True               # <-------------------------------------- HEADER TYPE SELECT!
if ack2capital4all is True:
    header2domain = domain2sense.upper()
    # UAS
else:    
    header2domain = domain2sense[0].upper() + domain2sense[1:]
    # Hardware, Electricity


# HTML version
kb2correct[1] = '<A NAME="'

ack2special = True                   # <-------------------------------------- SELECT CASE!
if ack2special is True:
    ack2normal = False
else:
    ack2normal  = True    

if ack2special is True:    

    pass

if ack2normal is True:
 
    # RETURN TO MAIN - VERSION ONE
    kb2correct[4] = '<td><b>&laquo;</b><a href="../../index-' + domain2sense + '-xi2/" target="_blank">' + header2domain + '</a></td>'
    #sports:         <td><b>&laquo;</b><a href="../../index-     sports         -xi2/" target="_blank">      Sports         </a></td>
    
    # RETURN TO MAIN - VERSION TWO
    kb2correct[5] = '<td><b>&laquo;</b><a href="../../index-' + domain2sense + '-xi2" target="_blank">' + header2domain.upper() + ' Sensing' + '</a></td>'
    #lex:            <td><b>&laquo;</b><a href="../../index-        lex         -xi2" target="_blank">        LEX                   Sensing     </a></td>
    
    # RETURN TO CHINA
    kb2correct[6] = '<td><b>&laquo;</b><a href="../en-cn-' + domain2sense + '-xi2/" target="_blank">' + header2domain + 'Sensing in China</a></td>'
    #uas:            <td><b>&laquo;</b><a href="../en-cn-uas                 -xi2/" target="_blank">      UAS            Sensing in China</a></td>
    
    # RETURN TO USA
    kb2correct[7] = '<td><b>&laquo;</b><a href="../index-' + domain2sense + '-xi2/" target="_blank">' + header2domain + 'Sensing</a></td>'
    #uas:            <td><b>&laquo;</b><a href="../index-       uas          -xi2/" target="_blank">      UAS            Sensing</a></td>




# -------------------------------------------------------------------------------------------------
# TO-BE-REPLACED IN INPUT 
# -------------------------------------------------------------------------------------------------
# HTML version
kb2replace[1] = '<a id="'


if ack2special is True:    

    pass 


    
if ack2normal is True:
    # RETURN TO MAIN - VERSION ONE
    kb2replace[4] = '<td><b>&laquo;</b><a href="../../index-' + domain2sense + '-xi2.html" target="_blank">' + header2domain + '</a></td>'
    #sports:         <td><b>&laquo;</b><a href="../../index-     sports         -xi2/" target="_blank">      Sports         </a></td>
    
    # RETURN TO MAIN - VERSION TWO
    kb2replace[5] = '<td><b>&laquo;</b><a href="../../index-' + domain2sense + '-xi2.html" target="_blank">' + header2domain.upper() + ' Sensing' + '</a></td>'
    #lex:           '<td><b>&laquo;</b><a href="../../index-       lex          -xi2.html" target="_blank">         LEX                  Sensing     </a></td>'
    
    # RETURN TO CHINA
    kb2replace[6] = '<td><b>&laquo;</b><a href="../en-cn-' + domain2sense + '-xi2.html" target="_blank">' + header2domain + 'Sensing in China</a></td>'
    #uas:            <td><b>&laquo;</b><a href="../en-cn-      uas           -xi2.html" target="_blank">       UAS           Sensing in China</a></td>
    
    # RETURN TO USA
    kb2replace[7] = '<td><b>&laquo;</b><a href="../index-' + domain2sense + '-xi2.html" target="_blank">' + header2domain + 'Sensing</a></td>'
    #uas:            <td><b>&laquo;</b><a href="../index-      uas           -xi2.html" target="_blank">       UAS           Sensing</a></td>

# -------------------------------------------------------------------------------------------------
# EXAMPLES OF UPGRADE SETTINGS 
# -------------------------------------------------------------------------------------------------


PickleKB4Xi = {
       'a': Pickle2a4Xi,
       'b': Pickle2b4Xi,
       'c': Pickle2c4Xi,
       'd': Pickle2d4Xi,
       'e': Pickle2e4Xi,
       'f': Pickle2f4Xi,
       'g': Pickle2g4Xi,
       'h': Pickle2h4Xi,
       'i': Pickle2i4Xi,
       'j': Pickle2j4Xi,
       'k': Pickle2k4Xi,
       'l': Pickle2l4Xi,
       'm': Pickle2m4Xi,
       'n': Pickle2n4Xi,
       'o': Pickle2o4Xi,
       'p': Pickle2p4Xi,
       'q': Pickle2q4Xi,
       'r': Pickle2r4Xi,
       's': Pickle2s4Xi,
       't': Pickle2t4Xi,
       'u': Pickle2u4Xi,
       'v': Pickle2v4Xi,
       'w': Pickle2w4Xi,
       'x': Pickle2x4Xi,
       'y': Pickle2y4Xi,
       'z': Pickle2z4Xi,
       '_': Pickle2_4Xi} 

#"
#"/>

# -------------------------------------------------------------------------------------------------
#<define4xi definition = "
profile2fetch = '.html'                      # HTML files to be fetched
                                             # Extensions: '.html'= HTML '.txt'= text '.py'=Python, '.cpp'=C++, '.hpp'=headers, '.c'=C ...

#"
#/>


# ----------------------------------------------------------------------------------------------------------
#<function4xi function = "set2trace4fecth" usage = "setting trace using definitions in pickle4xi functions !
#">                      
# ----------------------------------------------------------------------------------------------------------    
def set2trace4fecth():
    global t2xi 
    global trace_object_count
    global PickleKB4Xi

    # print("(Step 00A/33) OF SET2TRACE4FECTH - STARTING SETTING TRACE BASED ON TRACE SETTINGS IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi()) 
    # print("(Step 00B/33) OF SET2TRACE4FECTH - USING T2XI: ", t2xi)
    # <print4xi.Print4Xi object at 0x0000000003715080>    
    
    # ---------------------------------------------------------------------------------------------
    # A, B .... _ 
    # ---------------------------------------------------------------------------------------------
    keys2pickledb = sorted(PickleKB4Xi.keys())
    for key2pickledb in keys2pickledb:
        # -----------------------------------------------------------------------------------------    
        # LETTERS
        # -----------------------------------------------------------------------------------------     
        # print('=' *33)
        # print("STARTING LETTER : ", key2pickledb)
        # print('=' *33)
   
        dictionary2pickle = PickleKB4Xi[key2pickledb]        
        # print("STARTING DICTIONARY: ", dictionary2pickle)
        # print('~' *33) 
        # 
        keys2dictionary = sorted(dictionary2pickle.keys())
    
        # -----------------------------------------------------------------------------------------    
        #
        # -----------------------------------------------------------------------------------------     
        for key2dictionary in keys2dictionary:
            # -------------------------------------------------------------------------------------    
            # DICTIONARY
            # -------------------------------------------------------------------------------------     
            # print('~' *33)        
            object2pickle = key2dictionary        
            # print("STARTING OBJECT: ", object2pickle)
            # print('~' *33)         
            # pickle4xi(object2pickle)
            # print('~' *33)                  
            # print("PICKLED object: ", object2pickle)
            # PICKLED object:  _C4Xi, 
            # ---------------------------------------------------------------------------------    
            # Mark those with NACK4XI to be traced !
            # ---------------------------------------------------------------------------------     
            if dictionary2pickle[key2dictionary] == 'NACK4XI':
                set_param2xi = True     
                key_param = object2pickle     
                t2xi.set_print_permission(key_param, set_param2xi)
                # print("(Step 002A/33) OF SET2TRACE4FECTH - MARKED TO BE TRACED OBJECT: ", object2pickle)                                
                # 
            else:
                pass  
            # ---------------------------------------------------------------------------------    
            # END OF DICTIONARY
            # ---------------------------------------------------------------------------------     
        # -----------------------------------------------------------------------------------------    
        # END OF LETTERS
        # -----------------------------------------------------------------------------------------     
        # print('~' *33)        
        # print("COMPLETED  DICTIONARY: ", dictionary2pickle)
        # print('~' *33) 
    # -----------------------------------------------------------------------------------------    
    #
    # -----------------------------------------------------------------------------------------     
    # print('=' *33)
    # print("COMPLETED LETTER : ", key2pickledb)
    # print('=' *33)
    # ---------------------------------------------------------------------------------------------
    # 
    # ---------------------------------------------------------------------------------------------
    print('=' *33)
    print("(Step 0033/33) OF SET2TRACE4FECTH - COMPLETED SETTING TRACE BASED ON NACK4XI/ACK4XI SETTINGS IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi()) 
    print('=' *33)
#</function4xi> 

       
# -------------------------------------------------------------------------------------------------
#<function4xi function = "deny2trace4fetch" usage = "
#   deny trace using pickle4xi functions !
#">                      
# -------------------------------------------------------------------------------------------------    
def deny2trace4fetch():
    global t2xi 
    global trace_object_count
    global PickleKB4Xi

    print("(Step 001A/33) of DENY2TRACE4FECTH: STARTING DENYING TRACE IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi()) 
    print("(Step 001B/33) OF DENY2TRACE4FECTH - USING T2XI: ", t2xi)
    # <print4xi.Print4Xi object at 0x0000000003715080>
    
    # ---------------------------------------------------------------------------------------------
    # A, B .... _ 
    # ---------------------------------------------------------------------------------------------
    keys2pickledb = sorted(PickleKB4Xi.keys())
    for key2pickledb in keys2pickledb:
        # -----------------------------------------------------------------------------------------    
        # LETTERS
        # -----------------------------------------------------------------------------------------     
        # print("(Step 001C/33) OF DENY2TRACE4FECTH - STARTING LETTER : ", key2pickledb)
        dictionary2pickle = PickleKB4Xi[key2pickledb]        
        # print("(Step 001D/33) OF DENY2TRACE4FECTH - STARTING DICTIONARY: ", dictionary2pickle)
        keys2dictionary = sorted(dictionary2pickle.keys())
        # -----------------------------------------------------------------------------------------    
        #
        # -----------------------------------------------------------------------------------------     
        for key2dictionary in keys2dictionary:
   
            # -------------------------------------------------------------------------------------    
            # DICTIONARY
   
            object2pickle = key2dictionary        
            # print("(Step 001E/33) OF DENY2TRACE4FECTH - STARTING OBJECT: ", object2pickle)
            # pickle4xi(object2pickle)        
            # print("STEROOT4XI PICKLED object: ", object2pickle)
            # PICKLED object:  _C4Xi, 
            
            # ---------------------------------------------------------------------------------    
            # ACK4XI = tested .i.e. NOT to be traced! 
            # ---------------------------------------------------------------------------------     
            set_param2xi = 'ACK4XI'     
            key_param = object2pickle     
            t2xi.set_print_permission(key_param, set_param2xi)
            # print("(Step 001F/33) OF DENY2TRACE4FECTH - MARKED TESTED AND NOT to be traced: ", object2pickle)
            
            dictionary2pickle[key2dictionary] = 'ACK4XI' 
                    
        
            # ---------------------------------------------------------------------------------    
            # END OF DICTIONARY
            # ---------------------------------------------------------------------------------     
            # print('~' *33)              
            # print("(Step 001Z/33) OF DENY2TRACE4FECTH *** FAILED - ERROR IN PICKLING OBJECT - NOT TO BE TRACED: ", object2pickle)
            # print('~' *33) 
        # -----------------------------------------------------------------------------------------    
        # END OF LETTERS
        # -----------------------------------------------------------------------------------------     
        # print("(Step 001G/33) OF DENY2TRACE4FECTH - COMPLETED  DICTIONARY: ", dictionary2pickle)
        # 
        
    # -----------------------------------------------------------------------------------------    
    #
    # -----------------------------------------------------------------------------------------     
    # print("(Step 002F/33) OF DENY2TRACE4FECTH - COMPLETED LETTER : ", key2pickledb)
    # _, a ... z            
    print("(Step 0033/33) OF SET2TRACE4FECTH - COMPLETED DENYING TRACE IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi()) 
#</function4xi> 

# -------------------------------------------------------------------------------------------------
#<function4xi function = "tailor2trace4xi" usage = "
#   tailors trace 
#">                      
# -------------------------------------------------------------------------------------------------    
def tailor2trace4xi():
    global trace_object_count
    global PickleKB4Xi 
    global t2xi
 
    print("(Step 001A/33) OF TAILOR2TRACE4FECTH - USING T2XI: ", t2xi)
    # <print4xi.Print4Xi object at 0x0000000003715080> 
                         
    # ---------------------------------------------------------------------------------------------
    # Settings to tailor trace
    # ---------------------------------------------------------------------------------------------
    #<set4xi setting = "
    KB4Tailoring = {
         'Pipe4Xi': 'NACK4TRACE',
         'Queue4Xi': 'NACK4TRACE',         
         'Process4Xi': 'NACK4TRACE',
         'get2sense4xi': 'NACK4TRACE'
        }                             
                
    default3trace = 'NACK4TRACE' # we do NOT want trace if object is not found! 
    #"/>
    
    # ---------------------------------------------------------------------------------------------
    # PROCESS KB4Tailoring
    # ---------------------------------------------------------------------------------------------
    keys2tailor = sorted(KB4Tailoring.keys())
    for key2tailor in keys2tailor:
        # ---------------------------------------------------------------------------------    
        # NACK4XI = NOT TESTED .I.E. TO BE TRACED! 
        # ---------------------------------------------------------------------------------     
        set_param2xi = 'NACK4XI'     
        key_param = key2tailor    
        t2xi.set_print_permission(key_param, set_param2xi)
        print("(Step 002A/33) OF TAILOR_TRACE4XI - MARKED TO BE TESTED: ", key2tailor)
        # Pipe4Xi, Process4Xi, Queue4Xi, get2sense4xi

    # -----------------------------------------------------------------------------------------    
    # EOF KEYS
    # -----------------------------------------------------------------------------------------     
    print("(Step 0033/33) OF TAILOR_TRACE4XI - COMPLETED  TAILORING: ", time4xi())
    #

    
     
#</function4xi>             
    
# -------------------------------------------------------------------------------------------------
#<function4xi function = "print-trace4xi" usage = "
# print XML trace
#"> 
# -------------------------------------------------------------------------------------------------    
def print_trace4xi(t2xi):

    class2print  = "get2sense4xi"
    method2print = "get2sense4xi" 
        
    message2print = "{passed" + "; t2xi-passed-to-print-trace4xi: " + str(t2xi) + "; time: " + time4xi() + "}"
    print4xi(class2print, method2print, message2print)   
    #    

    # -------------------------------------------------------------------------------------------------
    # SENSE                        
    # -------------------------------------------------------------------------------------------------  
   
    context2sense = {
     'file_path4xi': '..//..//..//..//web//xml//sense-get2sense.xml',
     'name_space4xi': '   xmlns="https://www.yourdragonxi.org/studio4xi/owl/studio4xi.owl#"\n',
     'xml_base4xi': '   xml:base="https://www.yourdragonxi.org/web/lib/owl/studio4xi.owl">\n',
     'ontology_about4xi': '   <owl:Ontology rdf:about="Sensing of Studio4Xi">\n',
     'ontology_comment4xi': '      <rdfs:comment xml:lang="en">Classes, methods and messages with context.</rdfs:comment>\n',
     'class0_id4xi': '   <owl:Class rdf:ID="Dragon4Xi#000000">\n',
     'class0_comment4xi': '      <rdfs:comment xml:lang="en">Sensing get2sense4xi.</rdfs:comment>\n',
     'object_property_rdf4xi': '   <owl:ObjectProperty rdf:ID="sensed#000000">\n',
     'object_property_comment4xi': '       <rdfs:comment xml:lang="en">get2sense4xi sensed.</rdfs:comment>\n',
     'debug4xi': True}
      
    xml_trace_sense4xi(t2xi, context2sense)

    # -------------------------------------------------------------------------------------------------
    # REASON                         
    # -------------------------------------------------------------------------------------------------  
        
    context2reason = {
     'file_path4xi': '..//..//..//..//web//xml//reason-get2sense.xml',
     'name_space4xi': '   xmlns="https://www.yourdragonxi.org/studio4xi/owl/studio4xi.owl#"\n',
     'xml_base4xi': '   xml:base="https://www.yourdragonxi.org/web/lib/owl/studio4xi.owl">\n',
     'ontology_about4xi': '   <owl:Ontology rdf:about="Reasoning of Studio4Xi">\n',
     'ontology_comment4xi': '      <rdfs:comment xml:lang="en">Operations</rdfs:comment>\n',
     'operation_comment4xi': '      <rdfs:comment xml:lang="en">Operations for get2sense4xi.</rdfs:comment>\n',
     'class0_id4xi': '   <owl:Class rdf:ID="reasoned#000000">\n',
     'class0_comment4xi': '      <rdfs:comment xml:lang="en">Operations with context.</rdfs:comment>\n',
     'object_property_rdf4xi': '   <owl:ObjectProperty rdf:ID="reason#000000">\n',
     'object_property_comment4xi': '       <rdfs:comment xml:lang="en">reason</rdfs:comment>\n',
     'debug4xi': True}
       
    xml_trace_reason4xi(t2xi, context2reason)

    # -------------------------------------------------------------------------------------------------
    # ACE                         
    # -------------------------------------------------------------------------------------------------  
       
    context2ace = {
     'file_path4xi': '..//..//..//..//web//xml//ace-get2sense.xml',
     'name_space4xi': '   xmlns="https://www.yourdragonxi.org/studio4xi/owl/studio4xi.owl#"\n',
     'xml_base4xi': '   xml:base="https://www.yourdragonxi.org/web/lib/owl/studio4xi.owl">\n',
     'ontology_about4xi': '   <owl:Ontology rdf:about="Acing of Studio4Xi">\n',
     'ontology_comment4xi': '      <rdfs:comment xml:lang="en">Objects and values for get2sense4xi.</rdfs:comment>\n',
     'class0_id4xi': '   <owl:Class rdf:ID="ACE4Xi#0000000">\n',
     'class0_comment4xi': '      <rdfs:comment xml:lang="en">Objects and values of get2sense4xi.</rdfs:comment>\n',
     'object_property_rdf4xi': '   <owl:ObjectProperty rdf:ID="ace#0000000">\n',
     'object_property_comment4xi': '       <rdfs:comment xml:lang="en">000000</rdfs:comment>\n',
     'debug4xi': True}   
    
    xml_trace_ace4xi(t2xi, context2ace)


    # -------------------------------------------------------------------------------------------------
    # end of print_trace4xi                        
    # -------------------------------------------------------------------------------------------------  
#</function4xi>
       
# -------------------------------------------------------------------------------------------------
#<function4xi function = "get2sense4xi" usage = "
#   fetches defined files from scope4xi folders
#"> 
# -------------------------------------------------------------------------------------------------
def get2sense4xi(file2explore):
    global count2skipped
    global count2found
    global count2total
    global count2upgrade

    
    global kb2fetch                              # knowledgebase for fetching 
    global kb2log                                # knowledgebase for log
    global kb2correct                            # knowledgebase for correcting content
    global kb2replace                            # knowledgebase for replacing content
    
    global path2read4xi                          # path for input files
    global path2temp4xi                          # path for output files
    global profile2fetch                         # extension for files

    global t2xi
    global trace_object_count    
    
    class2print  = "get2sense4xi"
    method2print = "get2sense4xi" 
 
   
    message2print = "{(Step 0A/33) got" + "; file2explore-got-by-get2sense4xi: " + str(file2explore)  + "; time: " + time4xi() + "}"
    print4xi(class2print, method2print, message2print)
    # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//tv//us\en\en-us-ugs-xi2.html
    # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
               
    # ---------------------------------------------------------------------------------------------
    # SPLIT FILE NAME WITH PATH AND EXTENSION TO TWO PIECES
    # ---------------------------------------------------------------------------------------------    
    name2file=os.path.splitext(file2explore)
    
    if name2file[1] == profile2fetch:          
        # -----------------------------------------------------------------------------------------
        # (Step 1/33) OF GET2SENSE4XI - PROPER FILE TYPE
        # -----------------------------------------------------------------------------------------
        message2print = "{(Step 1A/33) analyzing" + "; file2explore-analyzing-by-get2sense4xi: " + str(file2explore) + "; time: " + time4xi() + "}"
        print4xi(class2print, method2print, message2print)      
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
        
        path2input = name2file[0] + profile2fetch 
        message2print = "{(Step 1B/33) set" + "; path2input-set-by-get2sense4xi to: " + str(path2input)  + "; time: " + time4xi() + "}"
        print4xi(class2print, method2print, message2print)          
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
        
        # -----------------------------------------------------------------------------------------
        # (Step 2/33) OF GET2SENSE4XI - CHECKING WHETHER FILE MUST BE FETCHED
        # -----------------------------------------------------------------------------------------
        message2print = "{(Step 2A/33) analyzing" + "; path2input-analyzing-by-get2sense4xi: " + str(path2input) + "; time: " + time4xi() + "}"
        print4xi(class2print, method2print, message2print) 
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html
        # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
        
        keys2fetch = kb2fetch.keys()
        ack2match = False
        for key2fecth in keys2fetch:                                                                                
            string2search = kb2fetch[key2fecth]                                                                     
            index2search=str.find(path2input,string2search)                                                         
            if index2search == -1:                                         
                ack2match = True                                                                                                
            else:
                pass
                    
        if ack2match is True:
            message2print = "{(Step 2B/33) decided" + "; file-to-read-decided-by-get2sense4xi: " + str(path2input) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)        
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
            
                        
            max2count = 33
            count2try = 0
            string2search = "/"
            
            
            # message2print = "{(Step 2C/33) initialized" + "; string2search-initialized-by-get2sense4xi to: " + str(string2search) + "; time: " + time4xi() + "}"
            # print4xi(class2print, method2print, message2print)        
            # /
            
            source2save = path2input
            while 1:
                index2search=str.find(source2save,string2search)                                                         
                if index2search == -1:                                         
                    if count2try == 0:
                        source2save = "dummy.html"
                        message2print = "{(Step 2Z1/33) hit" + "; source2save-set-by-get2sense4xi: " + str(source2save) + "; time: " + time4xi() + "}"
                        print4xi(class2print, method2print, message2print)        
                        # 
                        break                                                                                            
                    else:
                        #
                        string2search = "\\"

                                                 
                else:
                    
                    source2save = source2save[index2search+1:]        
                    # message2print = "{(Step 2E/33) set" + "; source2save-set-by-get2sense4xi to: " + str(source2save) + "; time: " + time4xi() + "}"
                    # print4xi(class2print, method2print, message2print)        
                    # /DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html ... 
                    # index-ugs-xi2.html
                    # /us\en\en-us-ugs-xi2.html ... en-us-ugs-xi2.html
                count2try = count2try + 1
                if count2try > max2count:
                    
                    # message2print = "{(Step 2Z2/33) hit" + "; count2try-hit-by-get2sense4xi: " + str(count2try) + "; time: " + time4xi() + "}"
                    # print4xi(class2print, method2print, message2print)        
                    # 34 
                    
                    message2print = "{(Step 2Z3/33) got" + "; source2save-got-by-get2sense4xi: " + str(source2save) + "; time: " + time4xi() + "}"
                    print4xi(class2print, method2print, message2print)        
                    # index-ugs-xi2.html 
                    # en-us-ugs-xi2.html

                    break
                             
                

            path2write4file = path2temp4xi + source2save 
            message2print = "{(Step 2F/33) set" + "; path2write4file-set-by-get2sense4xi to: " + str(path2write4file) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)                    
            # ROOT4XI//TempTokaTera//sense//index-ugs-xi2.html           
            # ROOT4XI//TempTokaTera//sense//en-us-ugs-xi2.html
            
            kb2log[source2save] = path2input
                        
            count2total = count2total + 1
            
            # -----------------------------------------------------------------------------------------
            # (Step 3/33) OF GET2SENSE4XI - OPEN FOR READ INPUT LINES
            # -----------------------------------------------------------------------------------------
            file2input = open(path2input,'r')
            message2print = "{(Step 3A/33) opened" + "; file2input-opened-by-get2sense4xi: " + str(file2input) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)     
            # <_io.TextIOWrapper name='ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html' mode='r' encoding='cp1252'>

            
            # -----------------------------------------------------------------------------------------
            # (Step 4/33) OF GET2SENSE4XI - OPEN OUTPUT
            # -----------------------------------------------------------------------------------------
            file2output = open(path2write4file,'w')
            message2print = "{(Step 3B/33) opened" + "; file2output-opened-by-get2sense4xi: " + str(file2output) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)              
            # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//index-ugs-xi2.html' mode='w' encoding='cp1252'>

            while 1:
                # -------------------------------------------------------------------------------------
                # (Step 5/33) OF GET2SENSE4XI - PROCESS FILE
                # -------------------------------------------------------------------------------------             
                try:
                    line2process = file2input.readline()
                except:
                    message2print = "{(Step 7Z/33) failed" + "; line2process-failed-by-get2sense4xi: " + str(line2process) + "; time: " + time4xi() + "}"
                    print4xi(class2print, method2print, message2print)  
                    #
                    line2process = '<br />' + '\n'
                      
                if not line2process:
                    # ---------------------------------------------------------------------------------
                    # (Step 30/33) OF GET2SENSE4XI - ALL LINES READ, FINISH
                    # ---------------------------------------------------------------------------------             
                    break                                               
                else:
                    # ---------------------------------------------------------------------------------
                    # (Step 7/33) OF GET2SENSE4XI - PROCESS LINE
                    # ---------------------------------------------------------------------------------
                    
                    # correct content due to for example older HTML-version, CMS-type object reference
                    keys2correct = kb2correct.keys()
                    for key2correct in sorted(keys2correct):
                        index2search=str.find(line2process,kb2correct[key2correct])                                                         
                        if index2search == -1: 
                            pass
                        else:
                            line2process = line2process.replace(kb2correct[key2correct],kb2replace[key2correct]) 
                            # message2print = "{(Step 7/33) upgraded" + "; line2process-upgraded-by-get2sense4xi: " + str(line2process) + "; time: " + time4xi() + "}"
                            # print4xi(class2print, method2print, message2print)  
                            
                       
                    # ---------------------------------------------------------------------------------
                    # (Step 29/33) OF GET2SENSE4XI - WRITE PROCESSED LINE
                    # ---------------------------------------------------------------------------------                           
                    line2write = line2process  
                    file2output.write(line2write)
        
            
            # -----------------------------------------------------------------------------------------
            # (Step 31/33) OF GET2SENSE4XI - CLOSE INPUT
            # -----------------------------------------------------------------------------------------            
            file2input.close()
            message2print = "{(Step 31A/33) closed" + "; file2input-closed-by-get2sense4xi: " + str(file2input) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)           
            # <_io.TextIOWrapper name='ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html' mode='r' encoding='cp1252'>
            
                        
            # -----------------------------------------------------------------------------------------
            # (Step 32/33) OF GET2SENSE4XI - CLOSE OUTPUT
            # -----------------------------------------------------------------------------------------            
            file2output.close()
            message2print = "{(Step 31B/33) closed" + "; file2output-closed-by-get2sense4xi: " + str(file2output) + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)
            # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//index-ugs-xi2.html' mode='w' encoding='cp1252'>
            
            
            
        else:
            message2print = "{(Step 1E/33) skipped" + "; path2input-skipped-by-get2sense4xi: " + str(path2input)  + "; time: " + time4xi() + "}"
            print4xi(class2print, method2print, message2print)                      
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index.html <-- only for server 
            
            count2skipped = count2skipped + 1
            count2total = count2total + 1

    else:
        message2print = "{(Step 1F/33) skipped" + "; name2file-skipped-by-get2sense4xi: " + str(name2file)  + "; time: " + time4xi() + "}"
        print4xi(class2print, method2print, message2print)                      
        # ('ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//dir2x', '.bat')
        
        extension2skip = name2file[1]
        message2print = "{(Step 1G/33) skipped" + "; extension-skipped-by-get2sense4xi: " + str(extension2skip[1:])  + "; time: " + time4xi() + "}"
        print4xi(class2print, method2print, message2print)         
        # 
        
        count2skipped = count2skipped + 1
        count2total = count2total + 1
                    
#</function4xi>
    

# =================================================================================================
#<class4xi class = "DirectoryWalker" base = "None" child = "None" synopsis = "a forward iterator that traverses a directory tree" usage = "
#   to review all tests"
#>
# =================================================================================================
class DirectoryWalker:

    # ---------------------------------------------------------------------------------------------
    #<methodize4xi method = "init" usage = "initializes DirectoryWalker"> 
    # ---------------------------------------------------------------------------------------------
    def __init__(self, directory):
        self.stack = [directory]
        self.files = []
        self.index = 0
        
    #</methodize4xi>
            
    # ---------------------------------------------------------------------------------------------
    #<methodize4xi method = "getitem" usage = "getting item"> 
    # ---------------------------------------------------------------------------------------------
    def __getitem__(self, index):
        while 1:
            # ------------------------------------------------------------------------------------- 
            #
            # -------------------------------------------------------------------------------------          
            try:
                # --------------------------------------------------------------------------------- 
                #
                # ---------------------------------------------------------------------------------             
                file = self.files[self.index]
                self.index = self.index + 1
            except IndexError:
                # --------------------------------------------------------------------------------- 
                # pop next directory from stack
                # ---------------------------------------------------------------------------------             
                self.directory = self.stack.pop()
                self.files = os.listdir(self.directory)
                self.index = 0
            else:
                # --------------------------------------------------------------------------------- 
                # got a filename
                # ---------------------------------------------------------------------------------             
                fullname = os.path.join(self.directory, file)
                if os.path.isdir(fullname) and not os.path.islink(fullname):
                    self.stack.append(fullname)
                return fullname
    #</methodize4xi>
#</class4xi>

     
# -------------------------------------------------------------------------------------------------
#<function4xi function = "main" usage = "
#   reviewing all tests
#">                           
# -------------------------------------------------------------------------------------------------
def main():
    global count2skipped
    global count2found
    global count2total
    global count2upgrade

    global kb2fetch                              # knowledgebase for fetching 
    global kb2log                                # knowledgebase for log
    global kb2correct                            # knowledgebase for correcting content
    global kb2replace                            # knowledgebase for replacing content    
    global kb2log
    
    global path2read4xi
    global path2temp4xi
    global profile2fetch

    global t2xi
    global trace_object_count    

       
                       
    # ------------------------------------------------------------------------------------------------- 
    # INITIALIZE
    # -------------------------------------------------------------------------------------------------        
    t2xi = Print4Xi()
    print("(Step 1A/33) OF MAIN GET2SENSE4XI - SET T2XI TO: ", t2xi)
    # <print4xi.Print4Xi object at 0x0000000003715080> 
    
     
    count2skipped = 0
    count2found = 0
    count2total  = 0   

    set2trace4fecth()                                                                                               # trace all classes and functions in the system
    deny2trace4fetch()                                                                                              # deny trace for all classes and functions in the system
    tailor2trace4xi()                                                                                               # tailor trace for this test    

    pipe2fetch = Pipe4Xi()
    queue2fetch = Queue4Xi()
    
    # --------------------------------------------------------------------------------------------- 
    # START
    # ---------------------------------------------------------------------------------------------        
    print('=' *70)
    print("(Step 2A/33) OF MAIN GET2SENSE4XI - VERSION 7.21 FOR ", path2read4xi, " WITH PROFILE: ", profile2fetch, " STARTED ", time4xi())
    # VERSION 7.21 FOR  ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//  WITH PROFILE:  .html STARTED  07:13:37 01/06/14 Pacific Standard Time
    
    path2read4xi = VersionKB4Xi['folder2view4sense']
    print ('(Step 2B/33) OF MAIN GET2SENSE4XI - PATH2READ4XI: ', path2read4xi)
    # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//
    
    print('=' *70)    
   
    pipe2fetch = Pipe4Xi()
    print("(Step 2C/33) OF MAIN GET2SENSE4XI - PIPE2FETCH ", pipe2fetch)    
    # (<pipeconnection4xi.PipeConnection4Xi object at 0x000000000373AEF0>, <pipeconnection4xi.PipeConnection4Xi object at 0x0000000003758128>)
    
    queue2fetch = Queue4Xi()
    print("(Step 2D/33) OF MAIN GET2SENSE4XI - QUEUE2FETCH ", queue2fetch)    
    # <queue4xi.Queue4Xi object at 0x0000000002F6B4A8>
    

    for file2walk in DirectoryWalker(path2read4xi):
        # ----------------------------------------------------------------------------------------- 
        #
        # -----------------------------------------------------------------------------------------     
        if os.path.isdir(file2walk):
            print ("(Step 2E/33) OF MAIN GET2SENSE4XI - DIRECTORY: " + file2walk + '\n')
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//br
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//jp
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//mil
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//org
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//se
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//uk
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us
            # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//xx
        
            
        if os.path.isfile(file2walk):
            ack2sense = True
            keys2fetch = kb2fetch.keys()
            for key2fecth in keys2fetch:                                                                                
                string2search = kb2fetch[key2fecth]
                # print ("(Step 2F/33) OF MAIN GET2SENSE4XI - STRING2SEARCH: " + string2search + '\n')
                #                                                                      
                index2search=str.find(file2walk,string2search)                                                         
                if index2search == -1:                                         
                    pass                                                                                                     
                else:
                    ack2sense = False
            
            if ack2sense is True:
                print ("(Step 2G/33) OF MAIN GET2SENSE4XI - DECIDED TO EXAMINE FILE: " + file2walk + '\n')
                # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//dir2x.bat                   <-- folder is OK, file rejected late on
                # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html          <-- folder and file are OK
                # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html    <-- OK
                
                get2sense4xi(file2walk)
            else:
                print ("(Step 2H/33) OF MAIN GET2SENSE4XI - SKIPPED FILE: " + file2walk + '\n')
                # ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index.html         <-- just for server
                # 
                             
                    
                                
    # --------------------------------------------------------------------------------------------- 
    # END
    # --------------------------------------------------------------------------------------------- 
    print('=' *75)
    print("(Step 3A/33) OF MAIN GET2SENSE4XI - VERSION 8.12 FOR ", path2read4xi, " WITH PROFILE: ", profile2fetch, " COMPLETED  ", time4xi())
            
    # -------------------------------------------------------------------------------------------
    # STATISTICS
    # ------------------------------------------------------------------------------------------- 
    print ('(Step 4A/33) OF MAIN GET2SENSE4XI - FOUND: ', count2found)
    print ('(Step 4B/33) OF MAIN GET2SENSE4XI - SKIPPED: ', count2skipped)
    print ('(Step 4C/33) OF MAIN GET2SENSE4XI - TOTAL: ', count2total)
    print ('(Step 4D/33) OF MAIN GET2SENSE4XI - COUNT2UPGRADE: ', count2upgrade)
    
    test2total = count2found + count2skipped
    if test2total == count2total:
        pass
    else:
        print ('(Step 4Z/33) OF MAIN GET2SENSE4XI *** FAILED: FOUND + SKIPPED: ', test2total, " .NE. TOTAL: ", count2total, " ***")
     
    print ('(Step 4D/33) OF MAIN GET2SENSE4XI - KB2LOG: ')       
    print('=' *75)
    keys2log = kb2log.keys()
    for key2log in sorted(keys2log):
        print(key2log, kb2log[key2log])
        # en-br-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//br\en\en-br-ugs-xi2.html
        # en-ca-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//ca\en\en-ca-ugs-xi2.html
        # en-de-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//de\en\en-de-ugs-xi2.html
        # en-fi-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//fi\en\en-fi-ugs-xi2.html
        # en-jp-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//jp\en\en-jp-ugs-xi2.html
        # en-mil-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//mil\en\en-mil-ugs-xi2.html
        # en-org-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//org\en\en-org-ugs-xi2.html
        # en-uk-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//uk\en\en-uk-ugs-xi2.html
        # en-us-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//us\en\en-us-ugs-xi2.html
        # index-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//index-ugs-xi2.html
        # sv-se-ugs-xi2.html ROOT4XI//DRAGONXI//PC4Xi//YoDragonXiOrg//WebSite//sense//ugs//se\sv\sv-se-ugs-xi2.html   
        
    print('=' *75)
    
    # -------------------------------------------------------------------------------------------
    # (Step 5/33) CREATE GET2ALL.BAT
    # -------------------------------------------------------------------------------------------             
    path2write4file = path2temp4xi + "get2all.bat"  
    print('(Step 5A/33) OF MAIN GET2SENSE4XI - PATH2WRITE4FILE: ', path2write4file)
    # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//get2all.bat' mode='w' encoding='cp1252'> 
    
    file2output = open(path2write4file,'w')
    print('(Step 5A/33) OF MAIN GET2SENSE4XI - OPENED FILE2OUTPUT: ', file2output)
    # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//get2all.bat' mode='w' encoding='cp1252'>

    kb2get = {}
    keys2log = kb2log.keys()
    for key2log in sorted(keys2log):
        kb2get[key2log] = kb2log[key2log].replace("//","\\")    
        
    keys2get = kb2get.keys()
    for key2get in sorted(keys2get):
        line2write = "copy " + kb2get[key2get] + " /y" + "\n"
        file2output.write(line2write)
    
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\br\en\en-br-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\ca\en\en-ca-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\de\en\en-de-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\fi\en\en-fi-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\jp\en\en-jp-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\mil\en\en-mil-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\org\en\en-org-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\uk\en\en-uk-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\us\en\en-us-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\index-ugs-xi2.html /y
        # copy E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\se\sv\sv-se-ugs-xi2.html /y 
               
    file2output.close()
    print('(Step 5A/33) OF MAIN GET2SENSE4XI - CLOSED FILE2OUTPUT: ', file2output)
    # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//get2all.bat' mode='w' encoding='cp1252'>
    
    # -------------------------------------------------------------------------------------------
    # (Step 6/33) CREATE PUT2ALL.BAT
    # -------------------------------------------------------------------------------------------             
    path2write4file = path2temp4xi + "put2all.bat"  
    print('(Step 6A/33) OF MAIN PUT2SENSE4XI - PATH2WRITE4FILE: ', path2write4file)
    # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//put2all.bat' mode='w' encoding='cp1252'> 
    
    file2output = open(path2write4file,'w')
    print('(Step 6A/33) OF MAIN PUT2SENSE4XI - OPENED FILE2OUTPUT: ', file2output)
    # <_io.TextIOWrapper name='ROOT4XI//TempTokaTera//sense//put2all.bat' mode='w' encoding='cp1252'>

    kb2put = {}
    keys2log = kb2log.keys()
    for key2log in sorted(keys2log):
        kb2put[key2log] = kb2log[key2log].replace("//","\\")    
        
    keys2put = kb2put.keys()
    for key2put in sorted(keys2put):
        line2write = "copy " + key2put + " " + kb2put[key2put] + " /y" + "\n"  
        file2output.write(line2write)
        # copy en-br-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\br\en\en-br-ugs-xi2.html /y
        # copy en-ca-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\ca\en\en-ca-ugs-xi2.html /y
        # copy en-de-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\de\en\en-de-ugs-xi2.html /y
        # copy en-fi-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\fi\en\en-fi-ugs-xi2.html /y
        # copy en-jp-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\jp\en\en-jp-ugs-xi2.html /y
        # copy en-mil-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\mil\en\en-mil-ugs-xi2.html /y
        # copy en-org-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\org\en\en-org-ugs-xi2.html /y
        # copy en-uk-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\uk\en\en-uk-ugs-xi2.html /y
        # copy en-us-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\us\en\en-us-ugs-xi2.html /y
        # copy index-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\index-ugs-xi2.html /y
        # copy sv-se-ugs-xi2.html E:\DRAGONXI\PC4Xi\YoDragonXiOrg\WebSite\sense\ugs\se\sv\sv-se-ugs-xi2.html /y
         
    file2output.close()
    print('(Step 6A/33) OF MAIN PUT2SENSE4XI - CLOSED FILE2OUTPUT: ', file2output)
    # 
    
    # ---------------------------------------------------------------------------------------------    
    # Print Trace
    # ---------------------------------------------------------------------------------------------     
    print ('(Step 33A/33) OF MAIN GET2SENSE4XI - PRINTING TRACE WITH T2XI', t2xi)
    # 
    
    print_trace4xi(t2xi)        
    print ('(Step 33B/33) OF MAIN GET2SENSE4XI - PRINTED TRACE WITH T2XI', t2xi)           
    
#</function4xi>
    
        
# -------------------------------------------------------------------------------------------------
if __name__ == '__main__':
    main()        
#</program4xi>


# -------------------------------------------------------------------------------------------------
# Recorded History                             
# ------------------------------------------------------------------------------------------------- 
#<record4xi record = "
# ROOT4XI\Studio4Xi\Python\3.3\txt\get2sense4xi.txt
# ROOT4XI\Studio4Xi\web\xml\ace-get2sense.xml
# ROOT4XI\Studio4Xi\web\xml\reason-get2sense.xml
# ROOT4XI\Studio4Xi\web\xml\sense-get2sense.xml
# 
#"
#>
#     
# 
# -------------------------------------------------------------------------------------------------
# Legal Notice                             
# ------------------------------------------------------------------------------------------------- 
#<protect4xi protection = "copyright"
#   owner = "Small & Smart"
#   rights = "All rights reserved"
#   state = "California"
#   country = "United States of America"
#   references = "Legal notice at www.dragonxi.com; www.yourdragonxi.com; www.yourdragonxi.org; www.dragon2xi.com/; www.dragon4xi.com/; www.dragon8xi.com/ " 
#   codes = "Codes established in California and applicable to corporations in California"
#   compliance = "The California Law"
#   court = "Supreme Court of California, 350 McAllister Street, San Francisco, CA 94102-4783"
#/>
 
#<end4xi end = "
# -------------------------------------------------------------------------------------------------
# end of get2sense4xi.py                             
# ------------------------------------------------------------------------------------------------- 
#"
#/>