space copied from https://huggingface.co/spaces/jorge-henao/ask2democracycol

README.md

@@ -1,12 +1,12 @@
 ---
-title: Ask2democracy
-emoji: 📈
-colorFrom: blue
-colorTo: pink
+title: Ask2democracy - IA para las discusiones democráticas
+emoji:  🧐 📄 🇨🇴
+colorFrom: yellow
+colorTo: blue
 sdk: streamlit
-sdk_version: 1.17.0
+sdk_version: 1.10.0
 app_file: app.py
-pinned: false
+pinned: True
 license: apache-2.0
 ---
 

about.py

@@ -0,0 +1,53 @@
+from pinecone_quieries import PineconeProposalQueries
+import streamlit as st
+
+def show_about_ask2democracy():
+    description = """
+    <h2>Sobre esta iniciativa</h2>
+    <p>El debate ciudadano generalmente está sustentado en documentos que salvo pocas excepciones, casi nadie lee.
+    En este demo se han indexado algunos textos relevantes para la discución pública que suelen estar dispersos y poco accesibles. Además, se apoya en el estado del arte de la inteligencia artificial (abajo más detalles) , permitiendo explorar los documentos haciéndoles preguntas en español.
+    <p>
+    También se busca contribuir a la inteligencia artificial abierta y en español, mediante la construcción de un dataset y el entrenamiento de un modelo de lenguaje adaptado para las discusiones ciudadanas. Algo que puede ayudar a elevar la calidad del debate en todos los países de habla hispana.
+    <p>
+    Textos indexados: Propuesta reforma pensional de Marzo 22 de 2023, Propuesta reforma de la salud del 13 febrero 2023 , Capítulo de hallazgos y recomendaciones de la comisión de la verdad (trabajo en progreso, si quieres apoyar escríbeme)
+    <div align="right">
+    Creado por Jorge Henao 🇨🇴 <a href="https://twitter.com/jhenaotw" target='_blank'>Twitter</a> <a href="https://www.linkedin.com/in/henaojorge" target='_blank'>LinkedIn</a> <a href="https://linktr.ee/jorgehenao" target='_blank'>Linktree</a>
+    </div>
+    <p>
+    <h2>¿Cómo utilizar este espacio?</h2>
+    Selecciona el de documento que quieres explorar en el panel de la izquierda, escribe preguntas en la caja de texto y presiona el botón.     
+    No se trata de un sistema de búsquedas basado en palabras clave, por el contrario, puedes redactar preguntas más extensas y elaboradas. Cuanto más contexto le des a la pregunta mejores resultados obtienes.        
+    <h2>Integración opcional con OpenAI</h2>
+    Este demo usa recursos de computo limitados sin costo para la gente (si quieres ayudar a que sea más rápido ecríbeme). 
+    De manera opcional, si tienes una cuenta en OpenAI también puedes activar la integración copiando tu API key en el panel de la izquierda.
+    Una vez ingreses el api key, cada vez que hagas una pregunta el sistema la usará para elaborar una respuesta breve a partir de los resultados de búsqueda obtenidos, basándose siempre en las fuentes oficiales.
+    También puedes configurar que tan larga quieres que sea la respuesta (max tokens), y que tan creativas (temperatura).
+    <p><p><b>Nota:El sistema no guarda tu API key, sólo la utiliza para aumentar tus consultas mientras lo uses.</b>
+    <h2>Inteligencia artificial y democracia</h2>
+    Pretende ayudar a construir democracia participativa apaloncándose en el estado del arte de la inteligencia artificial. 
+    Al ser un demo accesible en web, puede ayudarle a un ciudadano del común a tener una opinión más informada, ayudándole a ser partícipe del debate público haciendo preguntas directamente a las fuentes en su propio lenguaje y llegando a sus propias conclusiones. 
+    <p><p>
+    Respecto a la inteligencia artificial hay algunas hipótesis que se quieren probar:
+    <ul>
+    <li> ¿Que tan efectivo puede ser un sistema de búsquedas con modelos de inteligencia artificial abiertos, para ayudar a la gente a entender discuciones ciudadanas relevantes en español? </li>
+    <li> ¿Que tan creativa puede ser la ingeligencia artificial en esa materia?</li>
+    <li> ¿Puede la inteligencia artificial abierta, ayudarle a la gente a entender documentos legislativos: propuestas de reforma, planes de gobierno, y en general documentos de discución pública?</li>
+    <li> ¿Puede la inteligencia artificial abierta igualar o mejorar sistemas como ChatGPT/GPT-4 de OpenAI para el entendimiento de discusiones ciudadanas en español?</li>
+    </ul>
+    Por lo anterior se prentende la construcción de un dataset. Dataset usado para entrenar(fine-tunning) uno o más modelos(Bert/GPT-2/Alpaca...) adapatado a discuciones ciudadanas en español.
+    Algo que puede ayudar a elevar el nivel del debate público en paises de habla hispana.    
+    <h2>Ask2Democracy v0.3</h2>
+    Esta version usa sentence transformers (Cosine similarity), una base de dactos vectorial Pinecone para almacenar los embeddings, Haystack framework y la integración con OpenAI.
+    Los modelos de lenguaje transformers utilizados son:
+    <code>
+sentence-transformers/multi-qa-MiniLM-L6-cos-v1
+deepset/xlm-roberta-base-squad2-distilled
+</code>
+<a href= "https://github.com/jorge-henao/ask_to_democracy"> repo en github con FastAPI</a>    
+    <h2>Beta disclaimer</h2>
+    Las respuestas que arroja el sistema no han sido pregrabadas ni basadas en opiniones. Todas son respuestas extraídas de fuentes oficiales.
+    Este demo usa modelos de lenguaje para entender el lenguaje español, sin embargo, necesita de un mayor entrenamiento por lo que, en ocasiones, puede ser confuso y no tan preciso. 
+    Si quieres apoyar escríbeme a <a href="mailto:jorge.henao@diezonce.co">jorge.henao@diezonce.co</a>
+    </p>      
+    """
+    st.markdown(description, unsafe_allow_html=True)

app.py

@@ -0,0 +1,158 @@
+import time
+from about import show_about_ask2democracy
+import streamlit as st
+from pinecone_quieries import PineconeProposalQueries
+from config import Config
+from samples import *
+
+queries = PineconeProposalQueries (index_name= Config.index_name,
+                                        api_key = Config.es_password,
+                                        environment = Config.pinecone_environment,
+                                        embedding_dim = Config.embedding_dim,
+                                        reader_name_or_path = Config.reader_model_name_or_path,
+                                        use_gpu = Config.use_gpu,
+                                        OPENAI_key= None)
+
+def search(question, retriever_top_k, reader_top_k, selected_index=None):
+    filters = {"source_title": selected_index}
+    query_result = queries.search_by_query(query = question, 
+                                                    retriever_top_k = retriever_top_k, 
+                                                    reader_top_k = reader_top_k,
+                                                    filters = filters)
+    result = []
+    for i in range(0, len(query_result)):
+        item = query_result[i]
+        result.append([[i+1], item.answer.replace("\n",""), item.context[:250], 
+                    item.meta['title'], item.meta['source_title'], 
+                    int(item.meta['page']), item.meta['source_url']])
+    return result
+    
+def search_and_show_results(query:str, retriever_top_k = 5, reader_top_k =3, selected_index=None):
+    stt = time.time()
+    results = search(query, retriever_top_k=retriever_top_k, 
+                     reader_top_k=reader_top_k, selected_index=selected_index)
+    ent = time.time()
+    elapsed_time = round(ent - stt, 2)
+
+    st.write(f"**Resultados encontrados para la pregunta** \"{query}\" ({elapsed_time} sec.):")
+    for i, answer in enumerate(results):
+        st.subheader(f"{answer[1]}")
+        doc = answer[2][:250] + "..."
+        st.markdown(f"{doc}[Lee más aquí]({answer[6]})", unsafe_allow_html=True)
+        st.caption(f"Fuente: {answer[4]} - Artículo: {answer[3]} - Página: {answer[5]}")
+                
+def search_and_generate_answer(question, retriever_top_k, generator_top_k, 
+                               openai_api_key, openai_model_name= "text-davinci-003", 
+                               temperature = .5, max_tokens = 30,  selected_index = None):
+    filters = {"source_title": selected_index}
+    
+    query_result = queries.genenerate_answer_OpenAI(query = question, 
+                                                    retriever_top_k = retriever_top_k, 
+                                                    generator_top_k = generator_top_k,
+                                                    filters = filters, OPENAI_key = openai_api_key,
+                                                    openai_model_name= openai_model_name,temperature = temperature, max_tokens = max_tokens)
+    result = []
+    for i in range(0, len(query_result)):
+        item = query_result[i]
+        source_title = item.meta['doc_metas'][0]['source_title']
+        source_url = item.meta['doc_metas'][0]['source_url']
+        chapter_titles = [source['title'] for source in item.meta['doc_metas']]
+        result.append([[i+1], item.answer.replace("\n",""), 
+                    source_title, source_url, str(chapter_titles)])
+    return result
+
+def search_and_show_generative_results(query:str, retriever_top_k = 5, generator_top_k =1 , openai_api_key = None, openai_model_name = "text-davinci-003", temperature = .5, max_tokens = 30, selected_index = None):
+    # set start time
+    stt = time.time()
+    results = search_and_generate_answer(query, retriever_top_k = retriever_top_k, 
+                                         generator_top_k= generator_top_k, 
+                                         openai_api_key = openai_api_key,
+                                         openai_model_name= openai_model_name, 
+                                         temperature = temperature, max_tokens = max_tokens, 
+                                         selected_index = selected_index)
+    ent = time.time()
+    elapsed_time = round(ent - stt, 2)
+    st.write(f"**Respuesta generada para la pregunta**  \"{query}\" ({elapsed_time} sec.):")
+    if results != None:
+        for i, answer in enumerate(results):
+            # answer starts with header
+            st.subheader(f"{answer[1]}")
+            st.caption(f"Fuentes: {answer[2]} - {answer[4]}")
+            st.markdown(f"[Lee más aquí]({answer[3]})")
+        
+
+indexes =  [{"title": "Propuesta reforma a la salud 13 de febrero de 2023", "name": "Reforma de la salud 13 Febrero 2023", "samples": samples_reforma_salud}, 
+            {"title": "Propuesta reforma pensional marzo 22 de 2023", "name": "Reforma pensional Marzo 2023", "samples": samples_reforma_pensional},
+            {"title": "Hallazgos de la comisión de la verdad", "name": "Hallazgos y recomendaciones - 28 de Junio 2022", "samples": samples_hallazgos_paz}
+            ]  
+
+
+
+index_titles = [item["title"] for item in indexes] 
+
+def get_selected_index_by_title(title):
+    for item in indexes:
+        if item["title"] == title:
+            return item["name"]
+    return None
+
+def get_samples_for_index(title):
+    for item in indexes:
+        if item["title"] == title:
+            return item["samples"]
+    return None
+
+def main():
+    st.title("Ask2Democracy 🇨🇴")
+    st.markdown("""
+    <div align="right">
+    Creado por Jorge Henao 🇨🇴 <a href="https://twitter.com/jhenaotw" target='_blank'>Twitter</a> <a href="https://www.linkedin.com/in/henaojorge" target='_blank'>LinkedIn</a> <a href="https://linktr.ee/jorgehenao" target='_blank'>Linktree</a>
+    </div>""", unsafe_allow_html=True)    
+    
+    # session_state = st.session_state
+    # if "api_key" not in session_state:
+    #     session_state.api_key = ""
+    
+    with st.form("my_form"):
+        st.sidebar.title("Configuración de búsqueda")
+        with st.sidebar.expander("Parámetros de recuperación", expanded= True):        
+            index = st.selectbox("Selecciona el documento que deseas explorar", index_titles)
+            top_k_retriever = st.slider("Retriever Top K", 1, 10, 5)
+            top_k_reader = st.slider("Reader Top K", 1, 10, 3)
+            
+        with st.sidebar.expander("Configuración OpenAI"):        
+            openai_api_key = st.text_input("API Key", type="password", placeholder="Copia aquí tu OpenAI API key (no será guardada)",
+                            help="puedes obtener tu api key de OpenAI en https://platform.openai.com/account/api-keys.")
+            openai_api_model = st.text_input("Modelo", value= "text-davinci-003")
+            openai_api_temp = st.slider("Temperatura", 0.1, 1.0, 0.5, step=0.1)
+            openai_api_max_tokens = st.slider("Max tokens", 10, 100, 60, step=10)
+        
+        # if openai_api_key:
+        #     session_state.password = openai_api_key
+            
+        sample_questions = get_samples_for_index(index).splitlines()
+        query = st.text_area("",placeholder="Escribe aquí tu pregunta, cuanto más contexto le des, mejor serán las respuestas")
+        with st.expander("Algunas preguntas de ejemplo", expanded= False):
+            for sample in sample_questions:
+                st.markdown(f"- {sample}")
+
+        submited = st.form_submit_button("Buscar") 
+    if submited:
+        selected_index = get_selected_index_by_title(index)
+        if openai_api_key:
+            with st.expander("", expanded= True):    
+                search_and_show_generative_results(query = query,retriever_top_k= top_k_retriever,
+                                                    generator_top_k= 1, openai_api_key = openai_api_key,
+                                                    openai_model_name = openai_api_model, 
+                                                    temperature= openai_api_temp, 
+                                                    max_tokens= openai_api_max_tokens,
+                                                    selected_index = selected_index)
+        with st.expander("", expanded= True):    
+            search_and_show_results(query, retriever_top_k=top_k_retriever, 
+                                    reader_top_k=top_k_reader, 
+                                    selected_index=selected_index)
+    else:
+        show_about_ask2democracy()
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,12 @@
+class Config():
+    es_host = "saimon-askwdemocracy.es.us-central1.gcp.cloud.es.io"
+    es_user = "elastic"
+    #es_password = "53f2a7a9-ea9d-4fd2-a8bc-f471b67f0262"
+    es_password = "1f45bf76-b600-42b3-b2cc-ab6062693eb7"
+    index_name = "docsreloaded"
+    reader_model_name_or_path = "deepset/xlm-roberta-base-squad2-distilled"
+    pinecone_environment="us-east-1-aws"
+    embedding_dim = 384
+    similarity="cosine"
+    #reader_model_name_or_path = "deepset/xlm-roberta-base-squad2"
+    use_gpu = True

pinecone_quieries.py

@@ -0,0 +1,170 @@
+
+from abc import ABC, abstractmethod
+from haystack.nodes import BM25Retriever, FARMReader
+from haystack.document_stores import ElasticsearchDocumentStore
+from haystack.pipelines import ExtractiveQAPipeline, DocumentSearchPipeline
+from haystack.document_stores import PineconeDocumentStore
+from haystack.nodes import EmbeddingRetriever, OpenAIAnswerGenerator
+from json import JSONDecodeError
+from pathlib import Path
+from typing import List, Optional
+
+import pandas as pd
+
+from haystack import BaseComponent, Document
+from haystack.document_stores import PineconeDocumentStore
+from haystack.nodes import (
+    EmbeddingRetriever,
+    FARMReader
+)
+from haystack.pipelines import ExtractiveQAPipeline, Pipeline, GenerativeQAPipeline
+from haystack.pipelines import BaseStandardPipeline
+from haystack.nodes.reader import BaseReader
+from haystack.nodes.retriever import BaseRetriever
+from sentence_transformers import SentenceTransformer
+
+import certifi
+import datetime
+import requests
+from base64 import b64encode
+
+ca_certs = certifi.where() 
+class QAPipeline(BaseStandardPipeline):
+    """
+    Pipeline for Extractive Question Answering.
+    """
+
+    def __init__(self, reader: BaseReader, retriever: BaseRetriever):
+        """
+        :param reader: Reader instance
+        :param retriever: Retriever instance
+        """
+        self.pipeline = Pipeline()
+        self.pipeline.add_node(component=retriever, name="Retriever", inputs=["Query"])
+        self.pipeline.add_node(component=reader, name="Reader", inputs=["Retriever"])
+        self.metrics_filter = {"Retriever": ["recall_single_hit"]}
+
+    def run(self, query: str, params: Optional[dict] = None, debug: Optional[bool] = None):
+        """
+        :param query: The search query string.
+        :param params: Params for the `retriever` and `reader`. For instance,
+                       params={"Retriever": {"top_k": 10}, "Reader": {"top_k": 5}}
+        :param debug: Whether the pipeline should instruct nodes to collect debug information
+                      about their execution. By default these include the input parameters
+                      they received and the output they generated.
+                      All debug information can then be found in the dict returned
+                      by this method under the key "_debug"
+        """
+                
+        output = self.pipeline.run(query=query, params=params, debug=debug)
+        return output
+
+
+class DocumentQueries(ABC):
+    
+    @abstractmethod
+    def search_by_query(self, query : str, retriever_top_k: int, reader_top_k: int, index_name: str = None, filters = None):
+        pass
+
+class PineconeProposalQueries(DocumentQueries):
+    
+    def __init__(self, index_name: str, api_key, reader_name_or_path: str, use_gpu = True,
+                 embedding_dim = 384, environment = "us-east1-gcp", OPENAI_key = None) -> None:
+        
+        reader = FARMReader(model_name_or_path = reader_name_or_path, 
+                            use_gpu = use_gpu, num_processes = 1, 
+                            context_window_size = 200)
+        
+        self._initialize_pipeline(index_name, api_key, reader = reader, embedding_dim= 
+                                  embedding_dim, environment = environment, OPENAI_key= OPENAI_key)
+        #self.log = Log(es_host= es_host, es_index="log", es_user = es_user, es_password= es_password)
+        self.OpenAI_api_key = None
+        
+    def _initialize_pipeline(self, index_name, api_key, similarity = "cosine",
+                             embedding_dim = 384, reader = None,
+                             environment = "us-east1-gcp",
+                             metadata_config = {"indexed": ["title", "source_title"]},
+                             OPENAI_key = None):
+        if reader is not None:
+            self.reader = reader
+                
+        #pinecone.init(api_key=es_password, environment="us-east1-gcp")
+        
+        self.document_store = PineconeDocumentStore(
+            api_key = api_key,
+            environment = environment,
+            index = index_name,
+            similarity = similarity,
+            embedding_dim = embedding_dim,
+            metadata_config = {"indexed": ["title","source_title"]}
+        )
+                
+        self.retriever = EmbeddingRetriever(
+            document_store= self.document_store,
+            embedding_model = "sentence-transformers/multi-qa-MiniLM-L6-cos-v1",
+            model_format="sentence_transformers"
+        )
+                     
+        self.extractive_pipe = ExtractiveQAPipeline (reader = self.reader, 
+                                          retriever = self.retriever)
+        
+        self.generative_OPENAI_pipe = None
+        if (OPENAI_key != None and OPENAI_key != ""):
+            OPENAI_generator = OpenAIAnswerGenerator(api_key = OPENAI_key, 
+                                                      model="text-davinci-003", temperature=.5, max_tokens=60)
+            self.generative_OPENAI_pipe = GenerativeQAPipeline(generator = OPENAI_generator, 
+                                                           retriever = self.retriever)
+            
+    def search_by_query(self, query : str, retriever_top_k: int, reader_top_k: int, index_name: str = None, filters = None):
+        #self.document_store.update_embeddings(self.retriever, update_existing_embeddings=False)        
+        params = {"Retriever": {"top_k": retriever_top_k, 
+                                "filters": filters}, 
+                  "Reader": {"top_k": reader_top_k}}
+        prediction = self.extractive_pipe.run( query = query, params = params, debug = True)      
+        return prediction["answers"]
+
+    def __initialize_openAIGEnerator(self, OPENAI_key, openai_model_name= "text-davinci-003", temperature = .5, max_tokens = 30):
+        if OPENAI_key != self.OpenAI_api_key:
+            OPENAI_generator = OpenAIAnswerGenerator(api_key=OPENAI_key, 
+                                                      model=openai_model_name, temperature= temperature, max_tokens=max_tokens)
+            self.generative_OPENAI_pipe = GenerativeQAPipeline(generator = OPENAI_generator, 
+                                                           retriever = self.retriever)
+            self.OpenAI_api_key = OPENAI_key
+ 
+    def genenerate_answer_OpenAI(self, query : str, retriever_top_k: int, generator_top_k: int,  filters = None, 
+                                 OPENAI_key = None, openai_model_name= "text-davinci-003",temperature = .5, max_tokens = 30):
+        if OPENAI_key != self.OpenAI_api_key:
+            self.__initialize_openAIGEnerator(OPENAI_key, openai_model_name, temperature, max_tokens)
+            params = {"Retriever": {"top_k": retriever_top_k, 
+                                    "filters": filters}, 
+                    "Generator": {"top_k": generator_top_k}} 
+            prediction = self.generative_OPENAI_pipe.run( query = query, params = params)      
+            return prediction["answers"]
+        else:
+            return None
+
+    def genenerate_answer_HF(self, query : str, retriever_top_k: int, reader_top_k: int, es_index: str = None, filters = None) :
+        params = {"Retriever": {"top_k": retriever_top_k, 
+                                "filters": filters}, 
+                  "Generator": {"top_k": reader_top_k}} 
+        prediction = self.generative_HF_pipe.run( query = query, params = params)      
+        return prediction["answers"]
+
+class Log():
+    
+    def __init__(self, es_host: str, es_index: str, es_user, es_password) -> None:
+        self.elastic_endpoint = f"https://{es_host}:443/{es_index}/_doc"
+        self.credentials = b64encode(b"3pvrzh9tl:4yl4vk9ijr").decode("ascii")
+        self.auth_header = { 'Authorization' : 'Basic %s' %  self.credentials }
+                      
+    def write_log(self, message: str, source: str) -> None:
+        created_date = datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ')
+        post_data  = {
+            "message" : message,
+            "createdDate": {
+                "date" : created_date
+            },
+            "source": source
+        }
+        r = requests.post(self.elastic_endpoint, json = post_data, headers = self.auth_header)
+        print(r.text) 

requirements.txt

@@ -0,0 +1,4 @@
+sentence-transformers
+farm-haystack[pinecone]
+pinecone-client
+streamlit==1.15.0

samples.py

@@ -0,0 +1,37 @@
+
+samples_reforma_salud = """¿Que es el ADRES?
+¿Cuándo se implementará el Sistema de Salud?
+¿Cómo se implementará el Sistema de Salud?
+¿Qué es principio de interpretación y fundamento de la transición en relación al Sistema de Salud?
+¿Qué se garantiza la atención en todo momento con el nuevo Sistema de Salud?
+¿Qué son los Centros de Atención Primaria Integrales y Resolutivos en Salud - CAPIRS?
+¿Qué se garantiza durante el periodo de transición del nuevo Sistema de Salud?
+¿Puede haber personas sin protección de su salud durante el periodo de transición?
+¿Cuál es el derecho fundamental que se garantiza en todo momento durante la transición del nuevo Sistema de Salud?
+¿Qué se debe realizar para garantizar la gestión de los recursos en el nivel nacional y desconcentrado?
+¿Cómo se regirá el régimen de contratación de los contratos mencionados en el texto?
+¿Qué son las cláusulas exorbitantes previstas en el estatuto General de Contratación de la administración pública?
+¿Qué principios deben atender los contratos mencionados en el texto?
+¿Cuál es el ámbito de aplicación de los contratos mencionados en el texto?
+¿Quién tiene la responsabilidad de realizar la auditoría de las cuentas en relación a estos contratos?
+¿Cuáles son las características que deben cumplir los contratos mencionados en el texto?
+¿Qué se entiende por "coordinación" en el contexto de los contratos mencionados en el texto?
+¿Qué objetivo se busca con los contratos mencionados en el texto?
+¿Quién será el encargado de contratar los servicios de salud y otros requerimientos para el cumplimiento de su labor en el nivel regional?
+¿Qué tipo de instituciones hospitalarias y ambulatorias se integran a la red de servicios del territorio?
+¿Qué tarifas deben seguir las instituciones hospitalarias y ambulatorias para la prestación de servicios de salud?
+¿Qué busca modular el régimen de tarifas y formas de pago para la prestación de servicios de salud?
+¿Qué tipo de registro llevará el Fondo Regional de Salud?
+¿Cuáles son algunas de las variables que se incluirán en el registro de cada servicio prestado y pagado?"""
+
+samples_hallazgos_paz =  """¿cantidad de víctimas en la masacre de bojayá?
+¿periodo con más detenciones arbitrarias registradas?
+¿cantidad de víctimas en la masacre de bojayá?
+¿cuantas víctimas de desplazamiento en antioquia?"""
+
+
+samples_reforma_pensional="""¿cuales son los pilares que se proponen?
+¿cuanto será la cotización al pilar contributivo?
+¿quienes serán los beneficiarios del pilar contributivo?
+¿cual es el beneficio para las mujeres con hijos?
+"""