app.py

import streamlit as st
import pathlib
from PIL import Image
import google.generativeai as genai

import os  
import google.generativeai as genai  

# 🔑 Configura a chave da API diretamente do ambiente  
API_KEY = os.getenv("HUGGINGFACE_API_KEY", "chave_padrão_aqui")  

genai.configure(api_key=API_KEY)


# ⚙️ Configuração de geração
configuracao_geracao = {
    "temperature": 1,
    "top_p": 0.95,
    "top_k": 64,
    "max_output_tokens": 8192,
    "response_mime_type": "text/plain",
}

# 🛡️ Configurações de segurança
configuracoes_seguranca = [
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
]

# 🧠 Nome do modelo
NOME_MODELO = "gemini-1.5-flash-latest"

# 🖌️ Seleção do framework (por exemplo, Tailwind, Bootstrap, etc.)
framework = "Regular CSS use flex grid etc"  # Mude para "Bootstrap" ou qualquer outro framework conforme necessário

# 🔨 Cria o modelo
modelo = genai.GenerativeModel(
    model_name=NOME_MODELO,
    safety_settings=configuracoes_seguranca,
    generation_config=configuracao_geracao,
)

# 💬 Inicia uma sessão de chat
sessao_chat = modelo.start_chat(history=[])

# ✉️ Função para enviar uma mensagem para o modelo
def enviar_mensagem_para_modelo(mensagem, caminho_imagem):
    entrada_imagem = {
        'mime_type': 'image/jpeg',
        'data': pathlib.Path(caminho_imagem).read_bytes()
    }
    resposta = sessao_chat.send_message([mensagem, entrada_imagem])
    return resposta.text

# 🚀 Aplicativo Streamlit
def principal():
    st.title("DockerGen 1.5 Pro: Gerador Avançado de YAML para Docker Compose 🐳⚙️ | Transforme Diagramas em Configurações Docker")
    st.subheader('Empowered by [Elias Andrade] - [GitHub](https://github.com/chaos4455/) | [LinkedIn](https://www.linkedin.com/in/itilmgf/) ⚡🔥')

    arquivo_carregado = st.file_uploader("Escolha uma imagem...", type=["jpg", "jpeg", "png"])
    detalhes_descricao = st.text_area("Detalhes e descrição", "Forneça mais detalhes sobre o diagrama e o que deve ser criado.")

    # 🗹 Opções de configuração
    st.markdown("### ⚙️ Opções de Configuração Docker Compose")
    
    # 🚀 Configurações Gerais
    replicabilidade = st.checkbox("Replicabilidade ♻️")
    escalabilidade = st.checkbox("Escalabilidade 📈")
    redundancia = st.checkbox("Redundância 🔄")
    persistencia_dados = st.checkbox("Persistência de Dados 💾")
    nivel_seguranca = st.selectbox("Nível de Segurança 🔒", ["Baixo", "Médio", "Alto"])
    tipo_aplicacao = st.selectbox("Tipo de Aplicação 🛠️", ["Web", "Banco de Dados", "Cache", "Mensageria", "Outro"])
    
    if tipo_aplicacao == "Outro":
        especificar_tipo_aplicacao = st.text_input("Especifique o Tipo de Aplicação")
    else:
        especificar_tipo_aplicacao = ""

    pre_instalar_pacotes = st.checkbox("Pré-instalar Pacotes 📦")
    if pre_instalar_pacotes:
        pacotes = st.text_area("Liste os Pacotes a Serem Instalados (separados por vírgulas)")
    else:
        pacotes = ""

    # 🐳 Configurações do Docker Compose
    st.markdown("### Docker Compose")

    build_imagem = st.checkbox("Gerar Dockerfile para Buildar Imagem 🛠️")
    replicas = st.number_input("Número de Réplicas", min_value=1, max_value=50, value=1, step=1)
    volumes = st.text_area("Volumes (separados por vírgulas)", "volume1:/path1,volume2:/path2")
    redes = st.text_area("Redes (separados por vírgulas)", "rede1,rede2")
    portas = st.text_area("Portas (separados por vírgulas)", "8080:80,443:443")
    variaveis_ambiente = st.text_area("Variáveis de Ambiente (separados por vírgulas)", "VAR1=value1,VAR2=value2")
    dependencias_servicos = st.text_area("Dependências de Serviços (separados por vírgulas)", "servico1,servico2")
    comandos = st.text_area("Comandos para Execução", "npm start,python app.py")
    restart_policy = st.selectbox("Política de Reinício", ["no", "always", "unless-stopped", "on-failure"])

    # 🐋 Configurações do Docker Swarm
    st.markdown("### Docker Swarm")
    
    usar_swarm = st.checkbox("Usar Docker Swarm 🌐")
    if usar_swarm:
        modo_swarm = st.selectbox("Modo de Serviço", ["replicated", "global"])
        update_config = st.text_area("Configuração de Atualização", "parallelism: 2, delay: 10s, failure_action: rollback")
        rollback_config = st.text_area("Configuração de Rollback", "parallelism: 1, delay: 5s")
        placement_constraints = st.text_area("Restrições de Colocação", "node.role == manager, node.labels.env == production")

    # 🚀 Recursos Adicionais
    st.markdown("### Recursos Adicionais")

    cpu_limit = st.text_input("Limite de CPU", "0.5")
    memory_limit = st.text_input("Limite de Memória", "512M")
    cpu_reservation = st.text_input("Reserva de CPU", "0.1")
    memory_reservation = st.text_input("Reserva de Memória", "128M")

    if arquivo_carregado is not None:
        try:
            # 🖼️ Carrega e exibe a imagem
            imagem = Image.open(arquivo_carregado)
            st.image(imagem, caption='Imagem Carregada.', use_column_width=True)

            # 🌈 Converte a imagem para o modo RGB se tiver um canal alfa
            if imagem.mode == 'RGBA':
                imagem = imagem.convert('RGB')

            # 💾 Salva a imagem carregada temporariamente
            caminho_imagem_temporaria = pathlib.Path("temp_image.jpg")
            imagem.save(caminho_imagem_temporaria, format="JPEG")

            # 🔄 Gera a descrição da infraestrutura
            if st.button("Gerar Docker Compose YAML"):
                st.write("🧑‍💻 Analisando seu diagrama de infraestrutura...")

                # Prompt para a IA
                prompt = f"""
                Descreva a infraestrutura representada neste diagrama em detalhes. Inclua os serviços, redes e volumes. 
                Gera uma configuração Docker Compose YAML completa e detalhada baseada nesta infraestrutura. 
                Certifique-se de:
                1. Criar redes com nomes únicos.
                2. Atribuir nomes de grupo e nomes únicos para todos os objetos.
                3. Declarar portas exportas, utilizando números aleatórios para evitar conflitos.
                4. Definir IPs para os objetos, utilizando faixas de IP em 192.168.x.x ou 10.10.x.x.
                5. Adicionar comentários explicativos em cada seção e configuração.
                6. Definir CPU, memória e recursos de rede para cada serviço.
                7. Incluir todas as configurações e subconfigurações possíveis para cada objeto.
                8. Configurar imagens Docker e volumes persistentemente.
                {detalhes_descricao}

                Configurações adicionais:
                - Replicabilidade: {replicabilidade}
                - Escalabilidade: {escalabilidade}
                - Redundância: {redundancia}
                - Persistência de Dados: {persistencia_dados}
                - Nível de Segurança: {nivel_seguranca}
                - Tipo de Aplicação: {tipo_aplicacao} {especificar_tipo_aplicacao}
                - Pré-instalar Pacotes: {pre_instalar_pacotes}
                - Pacotes: {pacotes}
                - Gerar Dockerfile: {build_imagem}
                - Número de Réplicas: {replicas}
                - Volumes: {volumes}
                - Redes: {redes}
                - Portas: {portas}
                - Variáveis de Ambiente: {variaveis_ambiente}
                - Dependências de Serviços: {dependencias_servicos}
                - Comandos: {comandos}
                - Política de Reinício: {restart_policy}
                - Usar Docker Swarm: {usar_swarm}
                """

                if usar_swarm:
                    prompt += f"""
                    Configurações do Swarm:
                    - Modo de Serviço: {modo_swarm}
                    - Configuração de Atualização: {update_config}
                    - Configuração de Rollback: {rollback_config}
                    - Restrições de Colocação: {placement_constraints}
                    """

                prompt += f"""
                Recursos:
                - Limite de CPU: {cpu_limit}
                - Limite de Memória: {memory_limit}
                - Reserva de CPU: {cpu_reservation}
                - Reserva de Memória: {memory_reservation}
                """

                descricao = enviar_mensagem_para_modelo(prompt, caminho_imagem_temporaria)
                st.write(descricao)

                # 🔍 Refina a descrição
                st.write("🔍 Refinando descrição com comparação visual...")
                prompt_refinado = f"""
                Compare os elementos de infraestrutura descritos com a imagem fornecida e identifique quaisquer elementos ausentes ou imprecisões. 
                Forneça uma descrição refinada e precisa dos elementos de infraestrutura com base nesta comparação. 
                Aqui está a descrição inicial: {descricao}
                """
                descricao_refinada = enviar_mensagem_para_modelo(prompt_refinado, caminho_imagem_temporaria)
                st.write(descricao_refinada)

                # 🛠️ Gera o YAML
                st.write("🛠️ Gerando Docker Compose YAML...")
                prompt_yaml = f"""
                Crie um arquivo Docker Compose YAML baseado na seguinte descrição de infraestrutura. 
                Certifique-se de incluir todas as configurações detalhadas, como redes, volumes, serviços com suas respectivas imagens, 
                portas exportas (utilizando números aleatórios para evitar conflitos), IPs definidos nas faixas 192.168.x.x ou 10.10.x.x, 
                recursos de CPU e memória, e comentários explicativos. Aqui está a descrição refinada: {descricao_refinada}
                """
                yaml_inicial = enviar_mensagem_para_modelo(prompt_yaml, caminho_imagem_temporaria)
                st.code(yaml_inicial, language='yaml')

                # 🔧 Refina o YAML
                st.write("🔧 Refinando Docker Compose YAML...")
                prompt_yaml_refinado = f"""
                Valide o seguinte código Docker Compose YAML com base na descrição de infraestrutura e imagem e forneça uma versão refinada do código YAML que melhore a precisão e aderência ao design original. 
                Certifique-se de incluir todas as configurações detalhadas e comentários explicativos. 
                Aqui está o YAML inicial: {yaml_inicial}
                """
                yaml_refinado = enviar_mensagem_para_modelo(prompt_yaml_refinado, caminho_imagem_temporaria)
                st.code(yaml_refinado, language='yaml')

                # 💾 Salva o YAML refinado em um arquivo
                with open("docker-compose.yaml", "w") as arquivo:
                    arquivo.write(yaml_refinado)
                st.success("O arquivo YAML 'docker-compose.yaml' foi criado.")

                # 📥 Fornece o botão de download para o YAML
                st.download_button(label="Baixar YAML", data=yaml_refinado, file_name="docker-compose.yml", mime="text/yaml")
        except Exception as e:
            st.error(f"Ocorreu um erro: {e}")

if __name__ == "__main__":
    principal()