**Contexto:**  
O objetivo é ter acesso a diferentes perspectivas sobre um tema de interesse para analisar em profundidade, contando com pontos de vista potencialmente conflitantes. Para isso, o ChatGPT deve utilizar toda a informação disponível para emular de maneira precisa e efetiva cada personalidade, reproduzindo o posicionamento, vícios de escrita e maneirismos.

---

**Intenção:**  
O objetivo é estabelecer um debate com diversas personalidades sobre um tema específico, respeitando o seguinte método:

1. O ChatGPT deve iniciar a interação solicitando o tema e as personalidades desejadas.  
2. O usuário responde.  
3. O ChatGPT faz uma breve introdução atualizada do tema e apresenta a opinião de cada personalidade em sentenças diretas.  
4. O ChatGPT apresenta uma lista com os principais conflitos entre as opiniões.  
5. O ChatGPT apresenta uma lista de provocações, onde cada personalidade pode fazer uma pergunta direta a outra sobre um conflito identificado.  
6. O ChatGPT solicita a mediação do usuário.  

**7. Possíveis desvios:**  
- Se o usuário solicitar a opinião de uma nova personalidade, o ChatGPT deve apresentar a opinião dessa personalidade, os conflitos com as demais e uma provocação direta da nova personalidade para outra, voltando ao passo 5.  
- Se o usuário selecionar uma provocação, o ChatGPT deve fazer uma atualização criteriosa do tema considerando a provocação, apresentar a réplica da personalidade provocada e a tréplica da personalidade provocadora, e então apresentar uma nova lista de provocações, voltando ao passo 5.  
- Se o usuário fizer outra solicitação, o ChatGPT deve atendê-la da melhor forma possível e retornar ao passo 3.

---

**Condição para informação insuficiente:**  
Caso o ChatGPT não tenha informações suficientes sobre uma das personalidades sugeridas, deve indicar isso claramente e não incluir essa personalidade na discussão.

---

**Formato:**  
- As opiniões devem ser apresentadas em uma lista numerada, escritas como se fossem pelas próprias personalidades, no formato `"Nome da personalidade: Opinião"`, com o nome entre colchetes.  
- Os conflitos devem ser apresentados em uma lista numerada.  
- As provocações devem estar no formato `"[Provocador] para [Provocado]: Provocação"`, sendo a provocação uma questão relacionada a uma discordância anterior.  
- O nome do ChatGPT a partir daquele momento seria **"Mastermind GPT"**, devendo ser sucinto e não fazer advertências ou explicações contextuais sobre seu funcionamento.  
- Ao entender o prompt, o ChatGPT deve se apresentar como **"Mastermind GPT"** e executar imediatamente o passo 1 do método.

**Contexto:**  
O objetivo é ter acesso a diferentes perspectivas sobre um tema de interesse para analisar em profundidade, contando com pontos de vista potencialmente conflitantes. Para isso, o ChatGPT deve utilizar toda a informação disponível para emular de maneira precisa e efetiva cada personalidade, reproduzindo o posicionamento, vícios de escrita e maneirismos.

**Intenção:**  
O objetivo é estabelecer um debate com diversas personalidades sobre um tema específico, respeitando o seguinte método:

1. O ChatGPT deve iniciar a interação solicitando o tema e as personalidades desejadas.  
2. O usuário responde.  
3. O ChatGPT faz uma breve introdução atualizada do tema e apresenta a opinião de cada personalidade em sentenças diretas.  
4. O ChatGPT apresenta uma lista com os principais conflitos entre as opiniões.  
5. O ChatGPT apresenta uma lista de provocações, onde cada personalidade pode fazer uma pergunta direta a outra sobre um conflito identificado.  
6. O ChatGPT solicita a mediação do usuário.  

**7. Possíveis desvios:**  
- Se o usuário solicitar a opinião de uma nova personalidade, o ChatGPT deve apresentar a opinião dessa personalidade, os conflitos com as demais e uma provocação direta da nova personalidade para outra, voltando ao passo 5.  
- Se o usuário selecionar uma provocação, o ChatGPT deve fazer uma atualização criteriosa do tema considerando a provocação, apresentar a réplica da personalidade provocada e a tréplica da personalidade provocadora, e então apresentar uma nova lista de provocações, voltando ao passo 5.  
- Se o usuário fizer outra solicitação, o ChatGPT deve atendê-la da melhor forma possível e retornar ao passo 3.

**Condição para informação insuficiente:**  
Caso o ChatGPT não tenha informações suficientes sobre uma das personalidades sugeridas, deve indicar isso claramente e não incluir essa personalidade na discussão.

**Formato:**  
- As opiniões devem ser apresentadas em uma lista numerada, escritas como se fossem pelas próprias personalidades, no formato `"Nome da personalidade: Opinião"`, com o nome entre colchetes.  
- Os conflitos devem ser apresentados em uma lista numerada.  
- As provocações devem estar no formato `"[Provocador] para [Provocado]: Provocação"`, sendo a provocação uma questão relacionada a uma discordância anterior.  
- O nome do ChatGPT a partir daquele momento seria **"Mastermind GPT"**, devendo ser sucinto e não fazer advertências ou explicações contextuais sobre seu funcionamento.  
- Ao entender o prompt, o ChatGPT deve se apresentar como **"Mastermind GPT"** e executar imediatamente o passo 1 do método.

conda create -n transcricao_env python=3.10
conda activate transcricao_env

!pip install git+https://github.com/openai/whisper.git
!pip install ffmpeg-python

import whisper
import ffmpeg
import os

model = whisper.load_model("base")

video_path = r"/Users/elemarjr/Downloads/mentoria_arquitetura_1.mp4"
audio_path = r"/Users/elemarjr/Downloads/mentoria_arquitetura_1.m4a"
ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True)

# Obter a transcrição
output_path = r"/Users/elemarjr/Downloads/mentoria_arquitetura_1.txt"
result = model.transcribe(audio_path, language='pt')

# Salvar a transcrição em um arquivo de texto
with open(output_path, "w", encoding='utf-8') as f:
    f.write(result['text'])

import whisper
import ffmpeg
import os
import sys

def transcribe_video(video_path):
    # Define o caminho do arquivo de áudio e da transcrição
    audio_path = os.path.splitext(video_path)[0] + '.m4a'
    output_path = os.path.splitext(video_path)[0] + '.txt'

    # Extrai o áudio do vídeo
    ffmpeg.input(video_path).output(audio_path).run(overwrite_output=True)

    # Carrega o modelo Whisper
    model = whisper.load_model("base")

    # Gera a transcrição
    result = model.transcribe(audio_path, language='pt')

    # Salva a transcrição em um arquivo de texto
    with open(output_path, "w", encoding='utf-8') as f:
        f.write(result['text'])

    print(f"Transcrição salva em {output_path}")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Uso: python transcribe.py <caminho_para_o_video>")
        sys.exit(1)

    video_path = sys.argv[1]
    transcribe_video(video_path)

import pandas as pd
import requests
from cachetools import cached, TTLCache
from datetime import datetime


class WordPress:
    def __init__(self, url):
        self.url = url

    @cached(cache=TTLCache(maxsize=100, ttl=300))
    def get_post_types(self):
        endpoint = '/wp-json/wp/v2/types'
        api_url = f'{self.url}{endpoint}'

        response = requests.get(api_url)
        post_types = response.json()

        if response.status_code == 200:
            data = [{'key': key, 'name': value['name']} for key, value in post_types.items()]
            return pd.DataFrame(data)
        else:
            return pd.DataFrame()

    @cached(cache=TTLCache(maxsize=100, ttl=300))
    def get_users(self):
        api_url = f'{self.url}/wp-json/wp/v2/users'

        response = requests.get(api_url)

        if response.status_code == 200:
            users_data = response.json()
            df = pd.DataFrame(users_data)
            return df
        else:
            return pd.DataFrame()

    @cached(cache=TTLCache(maxsize=100, ttl=300))
    def get_posts(self, post_type_slug, start_date, end_date):

        start_iso = (datetime.strptime(start_date, '%Y-%m-%d')
                     .replace(hour=0, minute=0, second=0)
                     .strftime('%Y-%m-%dT%H:%M:%S'))
        end_iso = (datetime.strptime(end_date, '%Y-%m-%d')
                   .replace(hour=23, minute=59, second=59)
                   .strftime('%Y-%m-%dT%H:%M:%S'))

        endpoint = f'/wp-json/wp/v2/{post_type_slug}'
        api_url = f'{self.url}{endpoint}'

        params = {
            'after': start_iso,
            'before': end_iso,
            'date_gmt': ''
        }

        response = requests.get(api_url, params=params)
        posts = response.json()

        if response.status_code == 200 and isinstance(posts, list):
            data = [
                {'ID': post['id'],
                 'Title': post['title']['rendered'],
                 'Modified': post['modified'],
                 'Created': post['date_gmt'],
                 'AuthorId': post.get('author', 1)
                 } for post in posts]
            df = pd.DataFrame(data)
            return df
        else:
            return pd.DataFrame()

from datetime import timedelta, datetime


class Weeks:
    @staticmethod
    def get_week_dates(reference_date):
        start_of_week = reference_date - timedelta(days=reference_date.weekday() + 1)
        end_of_week = start_of_week + timedelta(days=6)
        return start_of_week.strftime('%Y-%m-%d'), end_of_week.strftime('%Y-%m-%d')

    @staticmethod
    def get_current():
        today = datetime.now()
        return Weeks.get_week_dates(today)

    @staticmethod
    def get_previous(n = 1):
        today = datetime.now()
        last_week_date = today - timedelta(days=7 * n)
        return Weeks.get_week_dates(last_week_date)

    @staticmethod
    def get_week_string_from_date(reference_date):
        start, end = Weeks.get_week_dates(reference_date)
        return Weeks.get_week_string_from_interval(start, end)

    @staticmethod
    def get_week_string_from_interval(start, end):
        star_f = datetime.fromisoformat(start).strftime('%d/%m')
        end_f = datetime.fromisoformat(end).strftime('%d/%m')
        return f'{star_f} - {end_f}'

import pandas as pd
from datetime import datetime

from src.wordpress import WordPress
from src.weeks import Weeks

class Ontologia:
    def __init__(self):
        self.wp = WordPress('https://ontologia.eximia.co')

    def get_classes(self):
        df = self.wp.get_post_types()
        classes = df[
            ~(df['key'].str.startswith('wp_') |
              df['key'].str.startswith('nav_') |
              df['key'].str.contains('jet-engine') |
              df['key'].str.contains('assets') |
              df['key'].str.contains('classes') |
              df['key'].str.contains('page') |
              df['key'].str.contains('post') |
              df['key'].str.contains('links') |
              df['key'].str.contains('media') |
              df['key'].str.contains('attachment') |
              df['key'].str.contains('visibility_preset') |
              df['key'].str.endswith('_links') |
              df['key'].str.endswith('-links')
              )
        ]
        return classes

    def get_authors(self):
        df = self.wp.get_users()
        return df[~(df['name'].str.contains('admin'))]

    def get_entries(self, start_date, end_date):
        classes_df = self.get_classes()
        entries_list = []

        for index, row in classes_df.iterrows():
            post_type_slug = row['key']
            posts_df = self.wp.get_posts(post_type_slug, start_date, end_date)

            posts_df['ClassKey'] = row['key']
            posts_df['ClassName'] = row['name']

            entries_list.append(posts_df)

        final_df = pd.concat(entries_list, ignore_index=True)
        final_df = final_df[~(final_df['AuthorId'] == 1)]

        user_name_map = self.get_authors().set_index('id')['name'].to_dict()
        final_df['AuthorName'] = final_df['AuthorId'].map(user_name_map)
        return final_df

    def get_summary_by_author(self, start_date, end_date):
        entries_df = self.get_entries(start_date, end_date)
        summary_df = entries_df.groupby('AuthorName').size().reset_index(name='Count')

        start_date_formatted = pd.to_datetime(start_date).strftime('%d/%m')
        end_date_formatted = pd.to_datetime(end_date).strftime('%d/%m')
        date_column_title = f"{start_date_formatted} - {end_date_formatted}"

        summary_df.columns = ['Author', date_column_title]

        return summary_df

    def get_summary_by_class(self, start_date, end_date):
        entries_df = self.get_entries(start_date, end_date)
        summary_df = entries_df.groupby('ClassName').size().reset_index(name='Count')

        start_date_formatted = pd.to_datetime(start_date).strftime('%d/%m')
        end_date_formatted = pd.to_datetime(end_date).strftime('%d/%m')
        date_column_title = f"{start_date_formatted} - {end_date_formatted}"

        summary_df.columns = ['Class', date_column_title]

        return summary_df

    def get_weekly_summary_by(self, by, alias, number_of_weeks):
        start, _ = Weeks.get_previous(number_of_weeks)
        _, end = Weeks.get_current()

        entries = self.get_entries(start, end)

        def week(row):
            ref = datetime.fromisoformat(row["Created"])
            return Weeks.get_week_string_from_date(ref)

        entries["Week"] = entries.apply(week, axis=1)

        result = pd.DataFrame(columns=[alias])

        for i in range(number_of_weeks):
            start, end = Weeks.get_previous(i)
            week = Weeks.get_week_string_from_interval(start, end)
            df = entries[entries['Week'] == week]

            summary_df = df.groupby(by).size().reset_index(name='Count')
            summary_df.columns = [alias, week]
            result = pd.merge(summary_df, result, on=alias, how='outer')

        result.fillna(0, inplace=True)

        return result