Lanzamiento de Word Extraction Tool v0.42: Corrección de errores

KSM dice:

# -*- coding: utf-8 -*-
importar sistema operativo
importar win32com.client
importar pandas como pd
from pandas import DataFrame
de kiwipiepy importar Kiwi
# de konlpy.tag import Komoran # Para prueba(2021-02-21)
# de fecha y hora importar fecha y hora
importar fecha y hora
importar re
importar argparse
hora de importación
importar multiprocesamiento

_versión_ = '0.41'‘

Historial de versiones de #
# v0.42(2023-02-24): Parche para el error "La(s) columna(s) ['DBSchema'] no existen" al extraer palabras solo de archivos en in_path y no de tablas de base de datos o archivos de comentarios de columnas.
# v0.41(2023-02-19): Se agregó el elemento Frecuencia de ocurrencia del esquema de la base de datos (DBSchema_Freq) a la hoja "Frecuencia de palabras" después de extraer las palabras de los archivos de comentarios de la tabla y la columna de la base de datos.
# v0.40(2021-08-29): Se agregó un elemento de origen a la hoja "Frecuencia de palabras" después de extraer palabras de archivos de MS Word, PowerPoint y texto.
# v0.30(2021-04-26): Se agregó el elemento Fuente a la hoja "Frecuencia de palabras" después de extraer las palabras de la tabla de la base de datos, archivo de comentarios de columna.
# v0.20(2021-02-21): Versión con procesamiento multiproceso habilitado
# v0.10(2021-01-10): Versión inicial

def get_word_list(df_text) -> DataFrame:
“””
Extrae los sustantivos del DataFrame resultante de la extracción de texto y devuelve el resultado final como un DataFrame.
:param df_text: texto extraído del archivo (tipo DataFrame)
:return: Resultado de la extracción de sustantivos, palabras compuestas (1 o más sustantivos, prefijo+sustantivo+sufijo) (tipo Dataframe)
“””
hora_inicio = hora.hora()
lista_de_datos_de_palabras = []

kiwi = Kiwi()
Etiquetador # = Komoran()
row_idx = 0
para cada índice y fila en df_text.iterrows():
row_idx += 1
Si row_idx % 100 == 0: # Imprimir el estado de progreso actual cada 100 registros
print('[pid:%d] actual: %d, total: %d, progreso: %3.2f%%' %
(os.getpid(), row_idx, df_text.shape[0], round(row_idx / df_text.shape[0] * 100, 2)))
nombre_archivo = fila['NombreArchivo']
tipo_archivo = fila['Tipo_Archivo']
página = fila['Página']
texto = str(row['Texto'])
fuente = (fila['Fuente'])
is_db = Verdadero si row['FileType'] está en ('tabla', 'columna') de lo contrario Falso
is_db_table = True if row['FileType'] == 'table' else False
is_db_column = True if row['FileType'] == 'column' else False
si es_db:
db = fila['DB']
esquema = fila['Esquema']
tabla = fila['Tabla']
db_schema = fila['DBSchema']
si es_columna_db:
columna = fila['Columna']

Si el texto es None o text.strip() == ”:
continuar
intentar:
# sustantivos = mecab.sustantivos(texto)
# [O]ToDo: Extractos que incluyen prefijos nominales consecutivos (XPN) y sufijos derivados de sustantivos (XSN).
# [O]ToDo: Cuando los sustantivos (NNG, NNP) aparecen consecutivamente, extraiga el sustantivo compuesto conectado a cada sustantivo.
text_pos = [(token.form, token.tag) para token en kiwi.tokenize(text)]
palabras = [pos para pos, etiqueta en text_pos si etiqueta en ['NNG', 'NNP', 'SL']] # NNG: sustantivo común, NNP: sustantivo propio
pos_list = [x para (x, y) en text_pos]
lista_de_etiquetas = [y para (x, y) en posición_de_texto]
pos_str = ‘/’.join(pos_list) + ‘/’
tag_str = ‘/’.join(tag_list) + ‘/’
iterador = re.finditer('(NNP/|NNG/)+(XSN/)*|(XPN/)+(NNP/|NNG/)+(XSN/)*|(SL/)+', tag_str)
para mo en iterador:
x, y = mo.span()
si x == 0:
start_idx = 0
demás:
start_idx = tag_str[:x].count('/')
end_idx = tag_str[:y].count('/')
sub_pos = ”
# si end_idx – start_idx > 1 y no (start_idx == 0 y end_idx == len(tag_list)):
Si end_idx – start_idx > 1:
para i en rango(start_idx, end_idx):
sub_pos += pos_list[i]
# print('%s[sub_pos]' % sub_pos)
palabras.append('%s[Palabra compuesta]' % sub_pos) # Registrar morfema adicional

Si len(words) >= 1:
# imprimir(sustantivos, texto)
para palabra en palabras:
# imprimir(sustantivo, '\t', texto)
data_row = {'FileName': file_name, 'FileType': file_type, 'Page': page, 'Text': text,
‘'Palabra': palabra, 'Fuente': fuente}
si es_db:
data_row['DB'] = db
data_row['Esquema'] = esquema
data_row['Tabla'] = tabla
data_row['DBSchema'] = db_schema
si es_columna_db:
data_row['Column'] = columna
lista_de_datos_palabra.append(fila_de_datos)
excepto Excepción como ex:
print(f'[pid:{os.getpid()}] Se ha producido una excepción para el texto: {text}')
imprimir(ej)

df_result = pd.DataFrame(word_data_list)
imprimir(
f'[pid:{os.getpid()}] recuento de texto de entrada:{df_text.shape[0]}, recuento de palabras extraídas: {df_result.shape[0]}')
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('[pid:%d] get_word_list finalizado. total: %d, tiempo transcurrido: %s' %
(os.getpid(), df_text.shape[0], tiempo_transcurrido))
devolver df_resultado

def get_current_datetime() -> str:
return datetime.datetime.now().strftime(“%Y-%m-%d %H:%M:%S.%f”)

def get_ppt_text(file_name) -> DataFrame:
“””
Extrae texto de un archivo PPT y devuélvelo como un tipo DataFrame.
:param file_name: nombre de archivo de entrada (tipo str)
:return: texto extraído del archivo de entrada
“””
# :return: DataFrame con sustantivos extraídos del texto del archivo de entrada mediante un analizador morfológico
hora_inicio = hora.hora()
print('\r\nget_ppt_text: %s' % file_name)
ppt_app = win32com.client.Dispatch('PowerPoint.Application')
ppt_file = ppt_app.Presentations.Open(file_name, True)
Resultado # = []
df_data = []
page_count = 0
para diapositiva en ppt_file.Slides:
número_de_diapositiva = diapositiva.NúmeroDeDiapositiva
page_count += 1
para forma en diapositiva.Formas:
forma_texto = []
texto = ”
Si shape.HasTable:
col_cnt = shape.Table.Columns.Count
recuento_fila = forma.Tabla.Filas.Contador
para row_idx en range(1, row_cnt + 1):
para col_idx en range(1, col_cnt + 1):
texto = forma.Tabla.Celda(fila_idx, columna_idx).Forma.MarcoDeTexto.RangoDeTexto.Texto
si texto != ”:
text = text.replace(‘\r’, ‘ ‘)
forma_texto.append(texto)
elif shape.HasTextFrame:
para párrafo en shape.TextFrame.TextRange.Paragraphs():
texto = párrafo.Texto
si texto != ”:
forma_texto.append(texto)
para texto en shape_text:
si texto.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'ppt', 'Page': slide_number, 'Text': text, 'Source': f'{file_name}:{slide_number}:{text}'})
df_texto = pd.DataFrame(df_datos)
# imprimir(resultado)
ppt_file.Close()
# print(df_result)
imprimir ('recuento de texto: %s' % str (df_text. forma [0]))
print('Número de páginas: %d' % número_de_páginas)
# print(df_text.head(10))
# print(df_result.Paragraph)
# devuelve df_result
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('[pid:%d] get_ppt_text tiempo transcurrido: %s' % (os.getpid(), tiempo_transcurrido))
# devuelve get_word_list(df_text)
devolver df_text

def get_doc_text(file_name) -> DataFrame:
“””
Extrae texto de un archivo .doc y lo devuelve como un tipo DataFrame.
:param file_name: nombre de archivo de entrada (tipo str)
:return: texto extraído del archivo de entrada
“””
# :return: DataFrame con sustantivos extraídos del texto del archivo de entrada mediante un analizador morfológico
hora_inicio = hora.hora()
print('\r\nget_doc_text: %s' % file_name)
word_app = win32com.client.Dispatch(“Word.Application”)
word_file = word_app.Documents.Open(file_name, True)
Resultado # = []
df_data = []
página = 0
para cada párrafo en word_file.Paragraphs:
texto = párrafo.Rango.Texto
página = párrafo.Rango.Información(3) # 3: wdActiveEndPageNumber(Verificar el número de página del texto)
si texto.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'doc', 'Page': page, 'Text': text, 'Source': f'{file_name}:{page}:{text}'})

df_texto = pd.DataFrame(df_datos)

Archivo_de_palabras.Cerrar()
imprimir ('recuento de texto: %s' % str (df_text. forma [0]))
imprimir ('recuento de páginas: %d' % página)
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('[pid:%d] get_doc_text tiempo transcurrido: %s' % (os.getpid(), tiempo_transcurrido))
# devuelve get_word_list(df_text)
devolver df_text

def get_txt_text(file_name) -> DataFrame:
“””
Extrae texto de un archivo txt y lo devuelve como un tipo DataFrame.
:param file_name: nombre de archivo de entrada (tipo str)
:return: texto extraído del archivo de entrada
“””
# :return: DataFrame con sustantivos extraídos del texto del archivo de entrada mediante un analizador morfológico
hora_inicio = hora.hora()
imprimir('\r\nget_txt_text: ' + nombre_archivo)
df_data = []
número_de_línea = 0
con open(file_name, 'rt', encoding='UTF8') como archivo:
para el texto en el archivo:
número_de_línea += 1
si texto.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'txt', 'Page': line_number, 'Text': text, 'Source': f'{file_name}:{line_number}:{text}'})
df_texto = pd.DataFrame(df_datos)
print('Recuento de texto: %d' % df_text.shape[0])
print('número de líneas: %d' % número_de_línea)
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('[pid:%d] get_txt_text tiempo transcurrido: %s' % (os.getpid(), tiempo_transcurrido))
# devuelve get_word_list(df_text)
devolver df_text

def crear_nube_de_palabras(df_group, now_dt, out_path):
“””
Dibujar una nube de palabras con un DataFrame que contiene frecuencias de sustantivos.
:param df_group: DataFrame de frecuencia de sustantivos
:param now_dt: Fecha y hora actuales
:param out_path: ruta_de_salida
:retorno: Ninguno
“””
hora_inicio = hora.hora()
print('\r\niniciar make_word_cloud…')
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import koreanize_matplotlib
# malgun.ttf # NanumSquare.ttf # NanumSquareR.ttf NanumMyeongjo.ttf # NanumBarunpenR.ttf # NanumBarunGothic.ttf
wc = WordCloud(font_path='.\\font\\NanumBarunGothic.ttf',
color_de_fondo='blanco',
max_words=500,
ancho=1800,
altura=1000
)

# print(df_group.head(10))
palabras = df_group.to_dict()['Freq']
# imprimir(palabras)
# palabras = df_group.T.to_dict('list')
wc.generate_from_frequencies(words)
wc.to_file('%s\\wordcloud_%s.png' % (out_path, now_dt))
# plt.axis('off')
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('make_word_cloud tiempo transcurrido: %s' % tiempo transcurrido)
# plt.imshow(wc)
# plt.show()

# Todo: Extraer texto del archivo Araea Hangul (hwp)
def get_hwp_text(file_name) -> DataFrame:
aprobar

# Tareas pendientes: Extraer texto del archivo PDF
def get_pdf_text(nombre_de_archivo) -> Marco de datos:
aprobar

# [O]Tarea: Extraer texto de la tabla, comentario de la columna
def get_db_comment_text(file_name) -> DataFrame:
“””
Extrae el texto del archivo db_comment y lo devuelve como un tipo DataFrame.
:param file_name: nombre de archivo de entrada (tipo str)
:return: texto extraído del archivo de entrada
“””
# :return: DataFrame con sustantivos extraídos del texto del archivo de entrada mediante un analizador morfológico
hora_inicio = hora.hora()
print('\r\nget_db_comment_text: %s' % file_name)
ruta_completa_nombre_archivo = os.path.abspath(nombre_archivo)

Comentario de la tabla de la región #
df_table_raw = pd.read_excel(full_path_file_name, sheet_name=0, engine='openpyxl')
df_table = df_table_raw.iloc[:, :4].copy()
df_table.columns = ['DB', 'Esquema', 'Tabla', 'Texto']
df_table['FileName'] = nombre_de_archivo_ruta_completa
df_table['FileType'] = 'table'‘
df_table['Página'] = 0
df_table = df_table[df_table.Text.notnull()] # Eliminar filas sin valor de texto
df_table['Source'] = df_table['DB'].astype(str) + '.' + df_table['Schema'].astype(str) + '.' + df_table['Table'].astype(str) \
+ '(' + df_table['Text'].astype(str) + ')'‘
Región final #

Comentario de la columna de la región #
df_column_raw = pd.read_excel(full_path_file_name, sheet_name=1, engine='openpyxl')
df_column = df_column_raw.iloc[:, :5].copy()
df_column.columns = ['DB', 'Esquema', 'Tabla', 'Columna', 'Texto']
df_column['FileName'] = nombre_de_archivo_de_ruta_completa
df_column['FileType'] = 'column'‘
df_column['Página'] = 0
df_column = df_column[df_column.Text.notnull()] # Eliminar filas sin valor de texto
df_column['Source'] = df_column['DB'].astype(str) + '.' + df_column['Schema'].astype(str) + '.' + df_column['Table'].astype(str) \
+ '.' + df_column['Column'].astype(str) + '(' + df_column['Text'].astype(str) + ')'‘
Región final #
df_text = pd.concat([df_column, df_table], ignore_index=True)
df_text['DBSchema'] = df_text['DB'] + '.' + df_text['Schema'] # Valor de DB.Schema generado (2023-02-19)
# imprimir(df_texto)
hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
print('[pid:%d] get_db_comment_text tiempo transcurrido: %s' % (os.getpid(), tiempo_transcurrido))
imprimir ('recuento de texto: %s' % str (df_text. forma [0]))
# devuelve get_word_list(df_text)
devolver df_text

def get_file_text(file_name) -> DataFrame:
“””
Una función para extraer texto de archivos de MS Word, PowerPoint, Texto y Comentarios de base de datos (Excel).
:param file_name: nombre_archivo
:return: texto extraído de un archivo (tipo DataFrame)
“””
df_text = DataFrame()
Si file_name.endswith(('.doc', '.docx')):
df_text = get_doc_text(file_name)
elif file_name.endswith(('.ppt', '.pptx')):
df_text = get_ppt_text(file_name)
elif file_name.endswith('.txt'):
df_text = get_txt_text(nombre_archivo)
elif file_name.endswith(('.xls', '.xlsx', '.xlsb')):
df_text = get_db_comment_text(nombre_archivo)
devolver df_text

# Tareas pendientes: Procesamiento en paralelo (procesamiento separado de db_comment_file e in_path, procesamiento dividido si db_comment_file es grande)
def main():
“””
Extrae el texto de los archivos ubicados en las subcarpetas de la ruta especificada, extrae los sustantivos de cada texto y guárdalos como un archivo de Excel.
:retorno: Ninguno
“””

Configuración de análisis y uso de argumentos de la región # ————————————————————-
# parser = argparse.ArgumentParser(usage='prueba de uso', description='prueba de descripción')
usage_description = r”””— Descripción —
* Se requiere db_comment_file o in_path.

Ejemplo de ejecución
1. Extraer texto y palabras del archivo: Especificar la ruta de entrada y la ruta de salida.
python word_extractor.py –multi_process_count 4 –in_path .\\test_files –out_path .\out

2. Extraer texto y palabras de los comentarios de la base de datos: Especifique db_comment_file y out_path.
python word_extractor.py –db_comment_file “tabla,columna comments.xlsx” –out_path .\out

3. Extraer texto y palabras del archivo, comentario de la base de datos: Especifique db_comment_file, in_path, out_path.
python word_extractor.py –db_comment_file “tabla,columna comments.xlsx” –in_path .\\test_files –out_path .\out

* Formato de archivo de comentarios de columnas y tablas de base de datos
– Primera hoja (Comentario de la tabla): Nombre de la base de datos, Nombre del esquema, Nombre de la tabla, Comentario de la tabla
– Segunda hoja (Columna de comentarios): DBName, SchemaName, Tablename, ColumnName, ColumnComment”””

# Tareas pendientes: Agregar opción: Si se deben extraer palabras compuestas, si se deben extraer caracteres en inglés, si se deben excluir caracteres en inglés de 1 dígito, …
analizador = argparse.ArgumentParser(descripción=descripción_de_uso, clase_formateador=argparse.RawTextHelpFormatter)
Agregar argumento de nombre #
parser.add_argument('–multi_process_count', required=False, type=int,
help='Número de procesos múltiples que se ejecutarán simultáneamente para la extracción de texto y la extracción de palabras (si no se especifica, se establecerá en el recuento de CPU (lógico))')
parser.add_argument('–db_comment_file', required=False,
help='Nombre del archivo de información de comentarios de la tabla de la base de datos (por ejemplo, comment.xlsx)')
parser.add_argument('–in_path', required=False, help=r'Ruta del archivo de entrada (ppt, doc, txt) (p. ej., .\in)')
parser.add_argument('–out_path', required=True, help=r'Ruta del archivo de salida (xlsx, png) (p. ej., .\out)')

args = parser.parse_args()

si args.multi_process_count:
multi_process_count = int(args.multi_process_count)
demás:
multi_process_count = multiprocessing.cpu_count()

archivo_comentario_db = args.archivo_comentario_db
Si db_comment_file no es None y no os.path.isfile(db_comment_file):
print('db_comment_file no encontrado: %s' % db_comment_file)
salir(-1)

in_path = args.in_path
ruta_salida = args.ruta_salida
imprimir('--------------------')
print('Extractor de palabras v%s inicio — %s' % (_version_, get_current_datetime()))
print('##### argumentos #####')
print('multi_process_count: %d' % multi_process_count)
print('db_comment_file: %s' % db_comment_file)
print('in_path: %s' % in_path)
print('out_path: %s' % out_path)
imprimir('--------------------')
# endregion Argumentos Análisis y configuración de uso ————————————————————-

hora_inicio = hora.hora()

df_text = DataFrame() Texto leído del archivo #
df_result = DataFrame() Palabra extraída de # df_text
lista_archivos = []
Si in_path no es None y in_path.strip() != ”:
print('[%s] Iniciar obtención de lista de archivos…' % get_current_datetime())
in_abspath = os.path.abspath(in_path) # os.path.abspath('.') + '\\test_files'‘
tipos_de_archivo = ('.ppt', '.pptx', '.doc', '.docx', '.txt')
para raíz, directorio, archivos en os.walk(in_abspath):
para cada archivo en archivos ordenados:
Archivos # a excluir
Si el archivo comienza con '~':
continuar
Archivos # para incluir
Si file.endswith(file_types):
lista_archivos.append(raíz + '\\' + archivo)

print('[%s] Finalizada la obtención de la lista de archivos.' % get_current_datetime())
print('— Lista de archivos —')
print(‘\n’.join(file_list))

Si db_comment_file no es None:
lista_archivo.append(archivo_comentario_db)

print('[%s] Iniciar obtención de texto del archivo…' % get_current_datetime())
con multiprocessing.Pool(processes=multi_process_count) como pool:
mp_text_result = pool.map(get_file_text, file_list)
df_text = pd.concat (mp_text_result, ignore_index = Verdadero)
print('[%s] Finalizado Obtener texto del archivo.' % get_current_datetime())
Extracción de texto completada hasta #. La extracción de palabras comienza a continuación.

# ———- Ejecución paralela ———-
print('[%s] Iniciar obtención de texto de archivo…' % get_current_datetime())
importar matemáticas
chunk_size = math.ceil(len(df_text) / multi_process_count) if multi_process_count > 0 else 1
Si chunk_size == 0:
df_text_split = [df_text]
demás:
df_text_split = [df_text[i:i + chunk_size] para i en range(0, len(df_text), chunk_size)]
# mp_result = []
con multiprocessing.Pool(processes=multi_process_count) como pool:
mp_result = pool.map(get_word_list, df_text_split)

df_result = pd.concat(mp_result, ignore_index=True)
# si 'DB' no está en df_result.columns:
# df_result['DB'] = ‘
# df_result['Esquema'] = ‘
# df_result['Table'] = ‘
# df_result['Column'] = ‘
# df_result['DBSchema'] = ‘

print('[%s] Finalizado Obtener Palabra del Archivo Texto.' % get_current_datetime())
# ——————————

print('[%s] Iniciar obtención de frecuencia de palabras…' % get_current_datetime())
Si 'DB' está en df_result.columns:
df_group = df_result.groupby('Word').agg({
‘'Palabra': 'contar',
‘Source’: lambda x: ‘\n’.join(list(x)[:10]),
‘'DBSchema': 'nunique'’
}).cambiarnombre(columnas={
‘'Palabra': 'Frecuencia',
‘'Fuente': 'Fuente',
‘'DBSchema': 'DBSchema_Freq'’
})
demás:
df_result['DB'] = ‘
df_result['Esquema'] = ‘
df_result['Table'] = ‘
df_result['Column'] = ‘
df_result['DBSchema'] = ‘

df_group = df_result.groupby('Word').agg({
‘'Palabra': 'contar',
‘Source’: lambda x: ‘\n’.join(list(x)[:10])
}).cambiarnombre(columnas={
‘'Palabra': 'Frecuencia',
‘'Fuente': 'Fuente'’
})
df_group = df_group.sort_values(by='Freq', ascending=False)
print('[%s] Finalizado Obtener frecuencia de palabras.' % get_current_datetime())
# df_group['Len'] = df_group['Word'].str.len()
# df_group[‘Len’] = df_group[‘Word’].apply(lambda x: len(x))
print('[%s] Iniciar creación de nube de palabras…' % get_current_datetime())
ahora_dt = datetime.datetime.now().strftime(“%Y%m%d%H%M%S”)
crear_nube_de_palabras(df_group, now_dt, out_path)
print('[%s] Finalizado Crear nube de palabras.' % get_current_datetime())

print('[%s] Iniciar Guardar el resultado de la extracción en un archivo de Excel…' % get_current_datetime())
df_result.index += 1
estilo_de_excel = {
‘'font-size': '10pt'’
}
df_result = df_result.style.set_properties(**excel_style)
df_group = df_group.style.set_properties(**excel_style)
out_file_name = '%s\\extract_result_%s.xlsx' % (out_path, now_dt) # 'out\\extract_result_%s.xlsx' % now_dt

print('Comenzando a escribir el archivo de Excel…')
con pd.ExcelWriter(path=out_file_name, engine='xlsxwriter') como escritor:
df_result.to_excel(writer,
encabezado=Verdadero,
sheet_name='Resultado de la extracción de palabras',
índice=Verdadero,
index_label='No',
freeze_paneles=(1, 0),
columnas=['Palabra', 'NombreArchivo', 'TipoArchivo', 'Página', 'Texto', 'DB', 'Esquema', 'Tabla', 'Columna'])
df_group.to_excel(writer,
encabezado=Verdadero,
nombre_hoja='Frecuencia de palabras',
índice=Verdadero,
index_label='Palabra',
freeze_paneles=(1, 0))
cuaderno de trabajo = escritor.libro
hoja de trabajo = escritor.hojas['frecuencia de palabras']
formato_de_ajustar = libro_de_trabajo.agregar_formato({'text_wrap': True})
worksheet.set_column(“C:C”, None, wrap_format)

# print('Finalizado el archivo de Excel')
print('[%s] Finalizado. Guardar el resultado de la extracción en un archivo de Excel…' % get_current_datetime())

hora_fin = hora.hora()
# tiempo_transcurrido = tiempo_final – tiempo_inicio
tiempo_transcurrido = str(datetime.timedelta(segundos=end_time – start_time))
imprimir('--------------------')
print('[%s] Finalizado.' % get_current_datetime())
print('tiempo total transcurrido: %s' % tiempo_transcurrido)
imprimir('--------------------')

Si __name__ == '__main__':
principal()
# print_usage()
# get_db_comment_text('tabla,columna comentarios.xlsx')