dbpoint 0.1.1__py3-none-any.whl

dbpoint/datadriver.py

@@ -0,0 +1,328 @@
+'''
+
+Ühendus läbi confi (dict), kus võimalikud võtmed järgmistes gruppides:
+a) väljast juhitavad, mida ei tasuks näppida: driver (miks siia jõuti), class (siinne instants ise pärast)
+b) ühenduseteks üldiselt vajaminevad: host, port, engine (ASA jaoks), database, dsn (ODBC DNS), username, password
+c) ühenduse ajal muud kasutatavad: appname (PG jaoks)
+d) metainfos ja muudes üldistustes erisuste juhtimiseks (sh ODBC korral): dialect (ODBC korral nt mysql, ASA korral nt asa5, asa7)
+ - võib olla tähenduses metainfo jaoks oluline versioon (ASA tüüpprobleem) kui ka 
+ - teistele tarbijatele dünaamilsite SQL.ide loomiseks vajalik ver (nt vanemates puudub mingi omadus)  
+
+SQL käskude jooksutamine (run) koos võimalusega andmete tagastamiseks (do_return), commitiga järel (do_commit_after) ja meta küsimsiega (mõte alles)
+- käskuke jooksutamisel tekkivad vead mäpitakse tootja moduli exceptionitest meie ühtlustatud exceptioniteks (kasutades alamklassis täidetud mäpperit)
+
+'''
+from datetime import datetime
+from dbpoint.perks import get_custom_logger, mem_free_now
+from collections import namedtuple
+# two attempts for getting annotations to work (first failed, second is semantically wrong (MySQL Cursor is not Postgre Cursor)):
+#from _typeshed.dbapi import DBAPIConnection, DBAPICursor # too fresh too raw yet (eg. Protocol don't mention rollback())
+#from psycopg2.extensions import connection, cursor
+# third attempt:
+from collections.abc import Sequence, Mapping
+from typing import Any, Protocol
+
+logging = get_custom_logger('driver')
+
+# next classes (Cursor and Connection) are only for type Annotations for IDEs
+class Cursor(Protocol):
+    description: Sequence[Any] | None
+    rowcount: int
+    arraysize: int
+
+    def close(self) -> None:
+        ...
+
+    def execute(self, operation: Any, *args, **kwargs) -> None:
+        ...
+
+    def executemany(
+            self,
+            operation: Any,
+            seq_of_parameters: Sequence[Any] | Mapping[Any, Any],
+            *args,
+            **kwargs
+        ) -> None:
+        ...
+
+class Connection(Protocol):
+    def close(self) -> None:
+        ...
+
+    def commit(self) -> None:
+        ...
+
+    def rollback(self) -> None:
+        ...
+
+    def cursor(self, *args, **kwargs) -> Cursor:
+        ...
+
+
+class DataDriverGeneric(object):
+    
+    map_of_exceptions = {} # alluv importigu sql_driver_errors ja lihtnime järgi (tootja-draiveri exc klassi viimane osis) vastavus (vt pg teostust)
+    conn: Connection = None # klassi instantsil on üks ühendus
+    created = None
+    last_run = None
+    closed_ts = None
+    run_count = 0 # tegelikult õnnestunud käskude arv
+    run_count_after_last_disconnect = 0
+    # escape võidakse ära muuta kui on juba olemas konkreetne draiver ja vb ka lausa konkreetne versioon
+    # nt ASA on vana kaldkriips, MySQL on kuni ver 5 (incl) kaldkriips, aga uuemad juba starndadi järgi ülakoma
+    apostrophe_escape = r"''" 
+    # mõelda, kas on vaja
+    #error = None ¤ või Exception  # ja konkreetne draiver paneb connect sees siia enda oma (endanimi.Error) ja run eristab seda muudest py üldisematest
+    #
+    type_mapper = {} 
+    columns_definition: list[dict] = []
+
+    class_mapper = {
+        'CHAR' : 'VARCHAR'
+        , 'NCHAR' : 'VARCHAR'
+        , 'NVARCHAR' : 'TEXT'
+        , 'VARCHAR' : 'TEXT'
+        , 'DATETIME' : 'TIMESTAMP'
+        , 'TINYINT': 'SMALLINT'
+        , 'BLOB' : 'BYTEA'
+        , 'LONG VARCHAR' : 'TEXT'
+        , 'LONG BINARY' : 'BYTEA'
+    }
+    
+    def __init__(self):
+        self.created = datetime.now()
+        
+    
+    def me(self):
+        return '' # üldine on nimetu, alluvad suurtähelised (läbivalt suur- või läbivalt väiketähelised) lühendid? PG, MYSQL, MSSQL, ORA, ASA, IQ, ASE, ODBC  
+    
+
+    def connect(self, profile: dict) -> int: # usutavasti on alluvatel nati erinevad nõksud/detailid
+        ...
+    
+    
+    def stream(self, sql: str):
+        cur: Cursor = self.conn.cursor()
+        cur.execute(sql)
+        if not self.analyze_column_meta(cur.description):
+            return
+        #self.last_apos, self.last_structure = self.make_for_create(cur.description)
+        #self.last_columns = self.make_for_columns(cur.description)
+        while True:
+            try:
+                row = cur.fetchone()
+            except Exception as e1:
+                logging.error(e1)
+                break
+            
+            if row is None:
+                break
+            else:
+                yield row
+        cur.close()
+
+    
+    def get_columns_definition(self) -> list[dict]:
+        return self.columns_definition
+    
+    
+    
+    def get_mapper(self):
+        def the_mapper(dataclass: str) -> str:
+            dataclass2 = self.class_mapper.get(dataclass.upper(), dataclass.upper())
+            #print(f"{dataclass} -> {dataclass2}")
+            return dataclass2
+        return the_mapper
+    
+    
+    def analyze_column_meta(self, cursor_description: tuple | None) -> bool:
+        
+        self.columns_definition.clear()
+        if cursor_description is None:
+            return False
+        
+        for desc in cursor_description: # https://peps.python.org/pep-0249/#description
+            dataclass = self.type_mapper.get(desc[1], 'TEXT')
+            
+            if dataclass in ('BIGINT', 'INT', 'NUMERIC', 'BOOLEAN'):
+                needs_escape = False
+            else:
+                needs_escape = True
+            
+            if dataclass not in ('TEXT') and desc[3] > 1 and desc[4] is not None: # and desc[4] != 65535:
+                details = []
+                details.append(f"{desc[4]}")
+                if desc[5] is not None and desc[5] != 65535:
+                    details.append(f"{desc[5]}")
+                datatype_details = ",".join(details)
+                datatype_details = f"({datatype_details})" # sulud ümber
+            else:
+                datatype_details = ''
+            datatype = dataclass + datatype_details
+            temp_name = desc[0] # vaja oleks korduvust ja nime olemasolu kontrollida (aga need võivad ka failida ja las arendaja teeb korda)
+            col_def = {'name' : temp_name, 'name_original' : desc[0], "class" : dataclass, "type" : datatype, "needs_escape" : needs_escape}
+            self.columns_definition.append(col_def)
+        return True
+
+    def extract_name_string(self, separator: str=', ') -> str:
+        if not self.columns_definition:
+            return ''
+        return separator.join([col['name'] for col in self.columns_definition])
+    
+    def run(self, sql: str, do_return: bool = True, **kwargs):
+        # , do_commit_after: bool = True, on_error_rollback = True, do_grab_meta = False
+        
+        if sql is None or len(sql.strip()) < 1:
+            raise Exception("Empty command")
+            #raise unified.DataDriverEmptyCommand('Empty command') # kas tühi SQL on fataalne või edasi mindav, otsustagu väljakutsuja
+        
+        # olulised muutuvad argumendid ja nende vaikeväärtused
+        defaults = { 
+            'on_success_commit' : True
+            , 'new_transaction': False
+            , 'on_error_rollback' : True
+            , 'on_error_disconnect' : False
+            , 'verbose' : False
+            , 'style' : 'number' # both on liiga ohtlik, kuna meil metasüsteem ja mitmes kohas on iteratsioon üle veergude
+            }
+        control = {**defaults, **kwargs}
+        
+        # alternatiiv:
+        kwargs.setdefault('verbose', False)
+        
+        # 
+        extra_on_success_commit = control['on_success_commit']
+        extra_on_error_rollback = control['on_error_rollback']
+        extra_on_error_disconnect = control['on_error_disconnect']
+        extra_new_transaction = control['new_transaction']
+
+        #' extra_verbose = control['verbose']
+        # ja selle alternatiiv:
+        extra_verbose = kwargs.get('verbose', False)
+        extra_return_style = control['style'] # text, number, both
+        if extra_return_style == 'text':
+            extra_return_style = 'name'
+        if extra_return_style not in ('name', 'number', 'both'):
+            extra_return_style = 'number'
+        
+        if extra_new_transaction:
+            self.conn.commit()
+        
+        result_set = []
+        try:
+            #with self.conn.cursor() as cur: // see tuli ära jätta, sest asa cursori __enter__ evib mingit viga (AttributeError)
+            cur: Cursor = self.conn.cursor()
+            cur.execute(sql)
+            #logging.debug("execution instructed")
+
+            if do_return:
+                # cur.description: tuple[str, DBAPITypeCode, int | None, int | None, int | None, int | None, bool | None]
+                if not self.analyze_column_meta(cur.description):
+                    logging.debug("during analyze emptyness happenes")
+                    return []
+                
+                if extra_return_style == 'number':
+                    #logging.debug("numbered columns instructed")
+                    result_set = cur.fetchall()
+
+                if extra_return_style == 'name':
+                    #logging.debug("named columns instructed")
+                    columns_named_spaced = self.extract_name_string(' ')
+                    if columns_named_spaced is None:
+                        raise Exception('no metadata grabbed')
+                    record_type = namedtuple('NamedTupleRecord', columns_named_spaced, rename=True)
+                    result_set = list(map(record_type._make, cur.fetchall()))
+
+                if extra_return_style == 'both':
+                    #logging.debug("dualistic columns instructed")
+                    columns_named_spaced = self.extract_name_string(' ')
+                    record_type = namedtuple('DictRecord', columns_named_spaced, rename=True)
+                    result_set = []
+                    row: tuple
+                    for row in cur.fetchall():
+                        # row on numbrilise indeksiga (list): row[0], row[1] jne
+                        new_row : dict = {}
+                        for pos, cell in enumerate(row): # kordame datat
+                            new_row[record_type._fields[pos]] = cell # str key
+                            new_row[pos] = cell # int key
+                        result_set.append(new_row) # list[dict[int|str, any]]
+
+        except Exception as ex:
+            #print('hakkame töötlema ja peitma ja muud tegema, mis pole päris hea vea lokaliseerimiseks, aga hea lõpptarbijale')
+            if extra_on_error_rollback:
+                self.conn.rollback()
+                logging.debug("rollback happenes")
+            if extra_on_error_disconnect:
+                self.disconnect()
+                logging.debug("disconnect happenes")
+            raise ex
+        finally:      
+            cur.close() # see juhtub isegi raise ex korral except osas
+        
+        self.last_run = datetime.now()
+        self.run_count = self.run_count + 1 # õnnestunud käsk suurendab käskude arvu
+        self.run_count_after_last_disconnect = self.run_count_after_last_disconnect + 1
+        
+        #logging.debug(f"commands executed is now {self.run_count} (and {self.run_count_after_last_disconnect} after last connect)")
+
+        if extra_on_success_commit:
+            #logging.debug("commit happenes")
+            self.conn.commit()
+        
+        if do_return:
+            #logging.debug("return data happenes")
+            return result_set
+        else:
+            #logging.debug("just return happenes")
+            return []
+    
+    def escape(self, cell_value, data_class, needs_escape):
+        ''' 
+        Postgre jaoks kirjutame üle niikuinii, sest saame kasutada märkhaaval asendamise asemel nn 3nda märgiga ümbritsemist (mis aitab säilitada json ja xml sisusid, peamiselt json)
+        Teistel ei tarvitse olla boolean tüüpi, aga sellest ei lähe midagi siin katki. 
+        Pigem läheb katki, kui on boolean ja see antakse stringina teisiti (ega tõlgita py bool-iks) -- sii ssee fn üle kirjutada 
+        ''' 
+        if cell_value is None:
+            return 'NULL'
+        if data_class == 'BOOLEAN' or isinstance(cell_value, bool):
+            return 'TRUE' if cell_value == 't' else 'FALSE' 
+        if needs_escape:
+            # vs liht-asendamise meetod
+            return (str(cell_value)).replace("'", self.apostrophe_escape)
+        else:
+            return f"{cell_value}"   
+        
+    
+    def disconnect(self):
+        try:
+            self.conn.close()
+        except:
+            ...
+        finally:
+            self.conn = None
+            self.closed_ts = datetime.now()
+            self.run_count_after_last_disconnect = 0
+
+    def commit(self):
+        self.conn.commit()
+
+    def rollback(self):
+        self.conn.rollback()
+    
+    def __repr__(self) -> str:
+        # profiiliga seotud metainfo
+        info = []
+        info.append(self.me())
+        info.append(f"inited at {self.created:%F %T.%f}") # ISO formatted date, Time, fractions (6 kohta)
+        if(self.conn is not None):
+            info.append('connected,')
+            if self.last_run is None:
+                info.append("no runs")
+            else:
+                info.append(f"last run at {self.last_run:%F %T.%f}")
+        else:
+            if(self.closed_ts is not None): # kui pole ühendust veel olnud, siis pole ka sulgemise aega
+                info.append(f"disconnected at {self.closed_ts:%F %T.%f}")
+        info.append(f"run count is {self.run_count} ({self.run_count_after_last_disconnect})")
+        return " ".join(info)
+

dbpoint/dbpoint.py

@@ -0,0 +1,289 @@
+#import datacontroller.datacontroller_exceptions as unified
+from typing import Iterable, Callable
+from dbpoint.perks import get_custom_logger, mem_free_now
+
+logging = get_custom_logger('dbpoint')
+
+class Hub(object):
+    
+    profiles = {}
+    known_drivers = {}
+    # implemented saab known-iks, kui a) teda esimest korda soovitakse ja b) siinses kaustas on sellenimeline .py fail  
+    implemented_drivers = {'pg' : ['pg'], 'oracle' : ['oracle']
+                           , 'asa' : ['asa'], 'maria' : ['maria']
+                           , 'mssql' : ['mssql'], 'odbc' : ['odbc']}
+    
+    
+    def __init__(self, list_of_profiles: list[dict]):
+        #print(f"Init of {self.__class__.__name__}") # kuna metaclass on Singleton, siis juhtub see ühe korra ainult
+        # siin võib ka kulutada aega ja uurida välja, kas kõvakettal on midagi, mis kvalifitseeruks draiveriks -> implemented_drivers
+        # aga midagi ei tohi importida, initsialiseerida, ühendada (sest kõiki kindlasti vaja ei lähe)
+        
+        self.last_sql = ''
+        self.last_sql_with_error = ''
+        
+        for one_profile in list_of_profiles or []:
+            if isinstance(one_profile, dict): 
+                self.add_profile(one_profile.get('name', ''), one_profile.copy())
+        
+        
+    def get_last_error_command(self):
+        return self.last_sql_with_error
+
+    
+    def get_last_command(self):
+        return self.last_sql
+        
+
+    def run(self, profile_name: str, sql: str, do_return: bool = True, **kwargs):
+        # param "sql" on üldjuhul SQL-KÄSK
+        # aga see võib olla ka midagi muud, kui driaver pole SQL-draiver (X-tee jm hierahr json/xml, excel/csv)
+        # see võib olla path/url    
+        self.last_sql = sql
+        driver = self.get_driver(profile_name)
+    
+        rs = None
+        try:
+            #logging.debug(f"Command for profile '{profile_name}'")
+            rs = driver.run(sql, do_return, **kwargs)
+        # vigu tasub püüda, kui otsustame mingeid olukordi üldtasemel ise ära töödelda
+        except Exception as e3:
+            self.last_sql_with_error = sql
+            raise e3
+        #self.last_sql_with_error = "" (jätame viimase vea puutumata, isegi kui on väga vana)
+        return rs # mis võib olla ka tühi list (kui ei soovitud datat)
+    
+    
+    def fn_stream(self, profile_name: str):
+        def streamer(sql):
+            driver = self.get_driver(profile_name)
+            return driver.stream(sql)
+        return streamer
+
+
+    def copy_to(self, sql : str, profile_name : str, first_row_grab : Callable, side_effects : Callable | None, prepare_row_command : Callable, save_command : Callable, info_step: int = 1000):
+        permanent_info = {}
+        pos = 0
+        logging.debug(f"copy_to.. {profile_name}")
+        flow = self.fn_stream(profile_name)
+        for pos, row in enumerate(flow(sql), 1):
+            if pos == 1:
+                permanent_info : dict = first_row_grab()
+                if permanent_info is None:
+                    logging.error("Problem with GRAB")
+                    return -1
+                #logging.debug(f"pos=1 start side effect")
+                side_quest = side_effects() if side_effects is not None else True
+                #logging.debug(f"pos=1 end side effect")
+            command = prepare_row_command(row, permanent_info)
+            if not save_command(command, pos):
+                logging.error(f"Problem with SAVE, made {pos}")
+                return -pos # if 1st row failes, return -1, if second returns -2
+            if pos % info_step == 0:
+                mem_free = mem_free_now()
+                logging.info(f"Pulled up to here {pos} rows, free memory {mem_free:.2f}")
+                if mem_free < 1:
+                    logging.error(f"Out of memory very soon, so lets quit as we can it do now")
+                    return -pos
+            
+        logging.info(f"copy_to END {pos} rows")
+        return pos
+
+
+    def generate_command_for_create_table(self, target_table: str, create_as_temp: False, cols_def = None, map_columns: dict = None) -> str:
+        as_temp = ' TEMP' if create_as_temp else ''
+        if map_columns is None:
+            create_columns = ', '.join([col_def['name'] + ' ' + col_def['type'] for col_def in cols_def])
+        else:
+            create_columns = ', '.join([map_columns[col_def['name']] + ' ' + col_def['type'] for col_def in cols_def if col_def['name'] in map_columns and map_columns[col_def['name']] != ''])
+        
+        create_table = f"CREATE{as_temp} TABLE {target_table} ({create_columns})"
+        print(f"{create_table=}")
+        return create_table
+        
+    
+    def to_file(self, profile_name: str, query: str, file_path) -> int:
+        
+        driver = self.get_driver(profile_name)
+        
+        try:
+            number_of_rows = driver.to_file(query, file_path)
+        except: # FIXME unified.DataControllerException as e0:
+            print('vigusk juhtus: ' + str(e0))
+            return -1
+        return number_of_rows
+
+    
+    def get_driver(self, profile_name: str | None): # -> (Cursor, None)
+        """
+        Returns object capable to make actions and thus having database connection (makes on if no)
+        """
+        if profile_name is None:
+            logging.error("Missing profile name for driver")
+            return None
+        
+        profile_data = self.get_profile(profile_name)
+        if profile_data is None:
+            return None
+        # lugeda profiilist välja, kes tagab teostuse
+        driver_name = profile_data['driver']
+        if profile_data['class'] is None: 
+            driver_class = self.known_drivers[driver_name].DataDriver()
+            self.set_profile_class(profile_name, driver_class)
+        else:
+            driver_class = profile_data['class']
+        
+        if driver_class.connect(profile_data) == 1: # 0 => was already connected
+            logging.debug(f"Profile {profile_name} connected")
+        
+        return driver_class
+        
+        
+    def get_profile(self, profile_name: str | None) -> dict | None:
+        if profile_name is None:
+            msg = f"Profile name (connection alias) is missing"
+            logging.error(msg)
+            return None
+            #raise Exception(msg)
+        if self.is_profile_exists(profile_name):
+            return self.profiles[profile_name] # see on py suva, kas see on viide sama obj sisse või uus -- seega alati muuta selfi!
+        else:
+            msg = f"{profile_name} does not exists"
+            logging.error(msg)
+            return None
+            #raise unified.DataControllerProfileExistenceException(f"Profile '{profile_name}' not existing")
+            #raise Exception(msg)
+    
+    
+    def find_driver(self, named_driver):
+        '''
+        Find driver by name, and import module containing it
+        '''
+        import importlib
+        import os.path
+        logging.debug(f"finding driver for '{named_driver}'")
+        # turvameede -- mapper
+        if named_driver not in self.implemented_drivers:
+            msg = f"Driver {named_driver} is not implemented"
+            raise Exception(msg)
+            #raise unified.DataControllerProfileUnknowDriverException(f"Driver {named_driver} is not implemented")
+        #module_to_import = self.implemented_drivers[named_driver][0] # vana
+        
+        module_name = self.implemented_drivers[named_driver][0]
+        logging.debug(f"Module name for {named_driver} is {module_name}")
+        long_module_name = '.'.join(['dbpoint', 'drivers', module_name]) # need on built-in moodulid! aga custom?
+        logging.debug(f"Long module name is {long_module_name}")
+        try: # lets try to import module, starting from root package and long_module_name
+            named_driver_module = importlib.import_module(long_module_name, 'dbpoint') # package = self.current_file_dir_name)
+            self.known_drivers[named_driver] = named_driver_module
+        except Exception as e1:
+            print(e1)
+            msg = f"Cannot import module {long_module_name} from package dbpoint"
+            logging.error(msg)
+            return None
+        
+    
+    def is_profile_exists(self, profile_name: str) -> bool:
+        return profile_name in self.profiles 
+    
+    
+    def is_driver_known(self, driver_name: str, try_to_find: bool = True) -> bool:
+        if driver_name in self.known_drivers:
+            return True
+        if not try_to_find:
+            return False
+        self.find_driver(driver_name)
+        return self.is_driver_known(driver_name, False) # kutsume välja iseenda, aga ei luba tsüklisse minna
+        
+    
+    def add_profile(self, profile_name, profile_data) -> None:
+        
+        if 'driver' not in profile_data:
+            msg = f"{profile_name} do not have driver"
+            logging.error(msg)
+            #raise unified.DataControllerProfileValidationException(f"Profile '{profile_name}' don't specify driver")
+            raise Exception(msg)
+        driver_name = profile_data['driver']
+        if self.is_driver_known(driver_name):
+            profile_data['class'] = None
+            self.profiles[profile_name] = profile_data
+            return
+        logging.error(f"{profile_name} uses unknown driver {driver_name}")
+        msg = f"Profile '{profile_name}' uses unknown driver '{driver_name}'"
+        raise Exception(msg)
+        #raise unified.DataControllerProfileUnknowDriverException()
+    
+    
+    def is_profile_connected(self, profile_name) -> bool: # kas kasutame nime? või sisu dicti?
+        return self.profiles[profile_name]['connected']
+    
+    
+    def set_profile_class(self, profile_name: str, profile_class):
+        self.profiles[profile_name]['class'] = profile_class
+    
+    
+    def do_real_connection_check(self, profile_name):
+        '''
+        see võiks veenduda, kas ühendus on jätkuvalt olemas ja kui pole, siis markeerida kadunuks 
+        '''
+        ...
+
+    def commit(self, profile_name):
+        driver = self.get_driver(profile_name)
+        if driver is None:
+            error.log("Cannot commit, because of missing profile name")
+            return None
+        return driver.commit() # == None anyway
+
+    def rollback(self, profile_name):
+        driver = self.get_driver(profile_name)
+        if driver is None:
+            error.log("Cannot rollback, because of missing profile name")
+            return None
+        return driver.rollback()
+
+    def disconnect(self, profile_name):
+        if not self.is_profile_exists(profile_name):
+            print(f"Profiili nimega '{profile_name}' pole olemas")
+            return
+        driver_class = self.profiles[profile_name]['class']
+        if driver_class is None: # olukord, kus pole veel ühendust vajatudki, st pole loodud
+            return 
+        driver_class.disconnect() # siia ümber pole try vaja, sest driver peaklass juba tegeleb
+        self.profiles[profile_name]['connected'] = False
+
+
+    def disconnect_all(self):
+        for profile_name in self.profiles:
+            self.disconnect(profile_name)
+            logging.debug(f"{profile_name} disconnected")
+
+    def escape(self, profile_name, cell_value, data_class, needs_escape):
+        driver = self.get_driver(profile_name)
+        if driver is None:
+            error.log("Cannot make escape expression, because of missing profile name")
+            return None
+        return driver.escape(cell_value, data_class, needs_escape)
+    
+    def get_columns_definition(self, profile_name):
+        driver = self.get_driver(profile_name)
+        if driver is None:
+            error.log("Cannot get columns list, because of missing profile name")
+            return None
+        return driver.get_columns_definition()
+
+    def __repr__(self):
+        # kõik profiilid ühendusinfoga (parool on varjestatud) ja profiilide metainfoga (millal, palju)
+        str_lines = []
+        for jrk, (name, profile) in enumerate(self.profiles.items(), 1):
+            str_lines.append(f"{jrk}) {name}")
+            for key, value in profile.items():
+                if key in ['password']:
+                    out_value = "'" + value[0:1] + '*****' + "'"
+                else:
+                    out_value = repr(value) # nt class
+                str_lines.append(f"  {key} = {out_value}")
+            str_lines.append("")
+        str_lines.append("")
+        return "\n".join(str_lines)
+