West_Cold

# 허용되는 키워드 목록
allowed_keywords = ["서찬", "찬", "너", "운영자"]

if any(keyword in user_input for keyword in allowed_keywords):
#생략
else:
    return jsonify({"description": "입력값에 '서찬', '찬', '너', '운영자' 중 하나라도 포함되어야만 실행됩니다."})

# 제한할 요청 수
REQUEST_LIMIT = 1 # 테스트 목적으로 1로 설정 (원래는 10개)

# IP 주소별 요청 횟수를 저장하는 사전
request_counts = defaultdict(lambda: {'count': 0, 'last_request': None})

def reset_request_count(ip):
    request_counts[ip]['count'] = 0
    request_counts[ip]['last_request'] = datetime.now()

def is_new_day(last_request):
    return datetime.now() - last_request > timedelta(seconds=10) # 테스트 목적으로 10초로 설정 (원래는 days=1)



@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')
    #사용자 ip 가져오기
    ip = request.remote_addr

    # 요청 횟수 가져오기
    request_data = request_counts[ip]
    count = request_data['count']
    last_request = request_data['last_request']

    # 하루가 지났는지 확인하여 요청 횟수 초기화
    if last_request is None or is_new_day(last_request):
        reset_request_count(ip)

    if count >= REQUEST_LIMIT:
        return jsonify({"description": "질문이 초과했습니다ㅠㅠ"})
    else:
        request_counts[ip]['count'] += 1
        request_counts[ip]['last_request'] = datetime.now()

# IP 주소별 스레드 ID를 저장하는 사전
thread_ids = {}

# 새로운 스레드 생성 함수
def create_new_thread():
    response = client.beta.threads.create()
    # response의 구조를 출력해보자
    print(response)
    # response 객체의 속성에 맞게 접근
    return response.id
    
# sendMessage 라우터
@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')
    ip = request.remote_addr

    # 요청 횟수 가져오기
    request_data = request_counts[ip]
    
# IP 주소별 스레드 ID 가져오기
        if ip not in thread_ids:
            thread_id = create_new_thread()
            thread_ids[ip] = thread_id
        else:
            thread_id = thread_ids[ip]

        # AI 응답 가져오기
        ai_response = get_ai_response(user_input, thread_id)

request_counts = defaultdict(lambda: {'count': 0, 'last_request': None, 'false_count': 0})

def reset_request_count(ip):
    request_counts[ip]['count'] = 0
    request_counts[ip]['last_request'] = datetime.now()
    request_counts[ip]['false_count'] = 0
   
@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')
    ip = request.remote_addr

    # 요청 횟수 가져오기
    request_data = request_counts[ip]
    count = request_data['count']
    last_request = request_data['last_request']
    false_count = request_data['false_count']
    
    # false_count가 3 이상이면 차단
    if false_count >= 3:
        return jsonify({"description": "너무 많은 잘못된 응답으로 인해 차단되었습니다."})
        
    else:
         # AI 응답 가져오기
        ai_response = get_ai_response(user_input, thread_id)

        # 'False' 응답 횟수 증가
        if ai_response.strip().lower() == 'false':
            request_counts[ip]['false_count'] += 1

from openai import OpenAI
import time
from flask import Flask, request, jsonify
from flask_cors import CORS
import pymysql
from collections import defaultdict
from datetime import datetime, timedelta

# MySQL 데이터베이스 연결 설정 함수
def get_database_connection():
    return pymysql.connect(host="localhost", user="root", password="", db="", charset="")
    
    # 데이터베이스에 저장
            try:
                db_connection = get_database_connection()
                cursor = db_connection.cursor()
                query = "INSERT INTO portpolio.portpolio_input (ip, comments, answer) VALUES (%s, %s, %s)"
                cursor.execute(query, (str(ip), user_input, ai_response))
                db_connection.commit()
                return jsonify({"description": ai_response})

            except Exception as e:
                return jsonify({"description": "데이터 저장 중 오류가 발생하였습니다: " + str(e)})

            finally:
                cursor.close()
                db_connection.close()

from openai import OpenAI
import time
from flask import Flask, request, jsonify
from flask_cors import CORS
import pymysql
from collections import defaultdict
from datetime import datetime, timedelta

app = Flask(__name__)
CORS(app)  # 모든 출처에서의 요청을 허용합니다.

# OpenAI API 키 설정
client = OpenAI(api_key="")

# 제한할 요청 수
REQUEST_LIMIT = 5  # 테스트 목적으로 1로 설정 (원래는 10개)

# IP 주소별 요청 횟수를 저장하는 사전
request_counts = defaultdict(lambda: {'count': 0, 'last_request': None, 'false_count': 0})

# IP 주소별 스레드 ID를 저장하는 사전
thread_ids = {}

def reset_request_count(ip):
    request_counts[ip]['count'] = 0
    request_counts[ip]['last_request'] = datetime.now()
    request_counts[ip]['false_count'] = 0

def is_new_day(last_request):
    return datetime.now() - last_request > timedelta(seconds=50)  # 테스트 목적으로 5초로 설정 (원래는 days=1)

# MySQL 데이터베이스 연결 설정 함수
def get_database_connection():
    return pymysql.connect(host="", user="t", password="", db="", charset="")

# 새로운 스레드 생성 함수
def create_new_thread():
    response = client.beta.threads.create()
    # response의 구조를 출력해보자
    print(response)
    # response 객체의 속성에 맞게 접근
    return response.id

# AI 응답을 가져오는 함수
def get_ai_response(user_input, thread_id):
    try:
        assistant_id = ""

        message = client.beta.threads.messages.create(
            thread_id,
            role="user",
            content=user_input,
        )

        run = client.beta.threads.runs.create(
            thread_id=thread_id,
            assistant_id=assistant_id,
        )

        run_id = run.id

        while True:
            run = client.beta.threads.runs.retrieve(
                thread_id=thread_id,
                run_id=run_id,
            )
            if run.status == "completed":
                break
            else:
                time.sleep(2)

        thread_messages = client.beta.threads.messages.list(thread_id)
        ai_response = thread_messages.data[0].content[0].text.value

        return ai_response

    except Exception as e:
        return str(e)

# sendMessage 라우터
@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')
    ip = request.remote_addr

    # 요청 횟수 가져오기
    request_data = request_counts[ip]
    count = request_data['count']
    last_request = request_data['last_request']
    false_count = request_data['false_count']

    # 하루가 지났는지 확인하여 요청 횟수 초기화
    if last_request is None or is_new_day(last_request):
        reset_request_count(ip)

    # false_count가 3 이상이면 차단
    if false_count >= 3:
        return jsonify({"description": "너무 많은 잘못된 응답으로 인해 차단되었습니다."})


    # 요청 횟수 확인
    if count >= REQUEST_LIMIT:
        return jsonify({"description": "질문이 초과했습니다ㅠㅠ"})


    # 요청 횟수 증가
    request_counts[ip]['count'] += 1
    request_counts[ip]['last_request'] = datetime.now()

    # IP 주소별 스레드 ID 가져오기
    if ip not in thread_ids:
        thread_id = create_new_thread()
        thread_ids[ip] = thread_id
    else:
        thread_id = thread_ids[ip]

    # AI 응답 가져오기
    ai_response = get_ai_response(user_input, thread_id)

    # 'False' 응답 횟수 증가
    if ai_response.strip().lower() == 'false':
        request_counts[ip]['false_count'] += 1

    # 데이터베이스에 저장
    try:
        db_connection = get_database_connection()
        cursor = db_connection.cursor()
        query = "INSERT INTO portpolio.portpolio_input (ip, comments, answer) VALUES (%s, %s, %s)"
        cursor.execute(query, (str(ip), user_input, ai_response))
        db_connection.commit()
        return jsonify({"description": ai_response})

    except Exception as e:
        return jsonify({"description": "데이터 저장 중 오류가 발생하였습니다: " + str(e)})

    finally:
        cursor.close()
        db_connection.close()

if __name__ == '__main__':
    print("Flask 애플리케이션이 실행되었습니다.")
    app.run(debug=True)

from openai import OpenAI
import time


# OpenAI API 키 설정
client = OpenAI(api_key="")

#assistant 생성
assistant = client.beta.assistants.create(
     name="Math Tutor",
     instructions="You are a personal math tutor. Answer questions briefly, in a sentence or less.",
     model="gpt-3.5-turbo",
 )
# # 생성된 챗봇의 정보를 JSON 형태로 출력합니다.
print(assistant)

assistant_id=""

# # # 새로운 스레드를 생성합니다.
thread = client.beta.threads.create()

print(thread)

#resume thread
thread_id = ""

message = client.beta.threads.messages.create(
    thread_id,
    role="user",
    content="서찬의 전화번호 알고 싶습니다",
)

print(message)

# 실행할 Run 을 생성합니다.
# Thread ID 와 Assistant ID 를 지정합니다.
run = client.beta.threads.runs.create(
  thread_id="",
  assistant_id="",
)

print(run)

run_id = run.id

while True:
  run = client.beta.threads.runs.retrieve(
    thread_id=thread_id,
    run_id= run_id,
  )
  if run.status == "completed":
    break
  else:
    time.sleep(2)
  # print(run)


thread_messages = client.beta.threads.messages.list(thread_id)
print(thread_messages.data[0].content[0].text.value)

from openai import OpenAI
import time
from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)  # 모든 출처에서의 요청을 허용합니다.

# OpenAI API 키 설정
client = OpenAI(api_key="")


@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')

    try:
        assistant_id=""

        #resume thread
        thread_id = ""

        message = client.beta.threads.messages.create(
            thread_id,
            role="user",
            content=user_input,
        )

        # 실행할 Run 을 생성합니다.
        # Thread ID 와 Assistant ID 를 지정합니다.
        run = client.beta.threads.runs.create(
          thread_id=thread_id,
          assistant_id=assistant_id,
        )

        run_id = run.id

        while True:
          run = client.beta.threads.runs.retrieve(
            thread_id=thread_id,
            run_id= run_id,
          )
          if run.status == "completed":
            break
          else:
            time.sleep(2)


        thread_messages = client.beta.threads.messages.list(thread_id)
        ai_response = thread_messages.data[0].content[0].text.value

        return jsonify({"description": ai_response})

    except Exception as e:
        return jsonify({"error": str(e)})

if __name__ == '__main__':
    print("Flask 애플리케이션이 실행되었습니다.")
    app.run(debug=True)

pip install Flask

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'he'

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, request, jsonify
from flask_cors import CORS
from openai import OpenAI
import requests
import json

app = Flask(__name__)
CORS(app)  # 모든 출처에서의 요청을 허용합니다.

# OpenAI API 키 설정
client = OpenAI(api_key="")

@app.route('/sendMessage', methods=['POST'])
def send_message():
    data = request.get_json()
    user_input = data.get('user_input')

    try:
        # OpenAI에 사용자 입력 전달하여 응답 받기
        completion = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "user", "content": user_input}
            ]
        )
        ai_response = completion.choices[0].message.content.strip()

        return jsonify({"description": ai_response})

    except Exception as e:
        return jsonify({"error": str(e)})


if __name__ == '__main__':
    print("Flask 애플리케이션이 실행되었습니다.")
    app.run(debug=True)

from openai import OpenAI
import re

client = OpenAI(api_key=".....")

# 사용자로부터 질문 입력 받기
user_input = input("질문을 입력하세요: ")

# 질문에 대한 대화 완성 생성
completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": user_input}
    ]
)

# 답변 내용 가져오기
answer = completion.choices[0].message.content

# 문장으로 분리
sentences = re.split(r'(?<=[.!?]) +', answer)

# 4~5문장까지 선택하여 출력
print("답변:")
for sentence in sentences[:5]:
    print(sentence)

import pymysql
from bs4 import BeautifulSoup
import requests
from openai import OpenAI

# OpenAI API 키 설정
client = OpenAI(api_key="....")

# MySQL 데이터베이스 연결 설정
db_connection = pymysql.connect(host="localhost", user="root", password="....", db="rs", charset="utf8")

# MySQL 커서 생성
cursor = db_connection.cursor()

# 데이터 크롤링
data = requests.get('https://sports.news.naver.com/wfootball/index')
soup = BeautifulSoup(data.text, 'html.parser')
soccer_rank = soup.select('#_team_rank_epl > table > tbody > tr')

# 데이터를 담을 리스트 초기화
team_data = []

for tr in soccer_rank:
    team_name = tr.select_one("td > div > div.info > span")
    if team_name:
        team_name = team_name.text.strip()
        # GPT 모델에 전달하여 팀 설명 얻기
        completion = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "user", "content": team_name}
            ]
        )
        team_description = completion.choices[0].message.content.strip()
        team_data.append((team_name, team_description))

try:
    # 축구팀 이름과 설명을 MySQL에 저장
    query = "INSERT INTO my_schema.football_content2 (name, content) VALUES (%s, %s)"
    cursor.executemany(query, team_data)

    # 변경사항 저장
    db_connection.commit()

    print("데이터가 성공적으로 저장되었습니다.")

except Exception as e:
    print("데이터 저장 중 오류가 발생하였습니다:", e)

finally:
    # 연결 종료
    cursor.close()
    db_connection.close()