Here's the files and directories up to 2 levels deep in /HakjunMIN__python-workshop, excluding hidden items:
/HakjunMIN__python-workshop
/HakjunMIN__python-workshop/test.ipynb
/HakjunMIN__python-workshop/chainlit.md
/HakjunMIN__python-workshop/README.md
/HakjunMIN__python-workshop/requirements.txt
/HakjunMIN__python-workshop/app.py

Here's the result of running `cat -n` on /HakjunMIN__python-workshop/README.md:
     1	# Python
     2	
     3	
     4	
     5	## Github 가입
     6	https://docs.github.com/ko/get-started/start-your-journey/creating-an-account-on-github
     7	
     8	## Github Copilot 연동 
     9	https://copilot.github.microsoft.com/
    10	
    11	## VSCode 설치
    12	https://code.visualstudio.com/download
    13	
    14	### 익스텐션설치
    15	https://marketplace.visualstudio.com/VSCode 혹은 VSCode내 Extensions
    16	Github Copilot & Chat, Python, Jupyter
    17	
    18	## 문제풀이
    19	
    20	### Dict
    21	
    22	##### 문제1: 학생 점수 관리
    23	다음과 같은 학생들의 이름과 점수가 주어졌을 때,
    24	        1.      학생 이름을 입력받아 해당 학생의 점수를 출력하는 프로그램을 작성하세요.
    25	        2.      만약 입력한 이름이 존재하지 않으면 “해당 학생이 없습니다.“를 출력하세요.
    26	
    27	```python
    28	students = {
    29	    "철수": 85,
    30	    "영희": 92,
    31	    "민수": 78,
    32	    "지영": 90
    33	}
    34	```
    35	
    36	출력
    37	
    38	```
    39	학생 이름을 입력하세요: 영희
    40	영희의 점수는 92점입니다.
    41	
    42	학생 이름을 입력하세요: 수진
    43	해당 학생이 없습니다.
    44	```
    45	
    46	<details>
    47	<summary>풀이</summary>
    48	
    49	<!-- summary 아래 한칸 공백 두어야함 -->
    50	```python
    51	students = {
    52	    "철수": 85,
    53	    "영희": 92,
    54	    "민수": 78,
    55	    "지영": 90
    56	}
    57	
    58	name = input("학생 이름을 입력하세요: ")
    59	
    60	if name in students:
    61	    print(f"{name}의 점수는 {students[name]}점입니다.")
    62	else:
    63	    print("해당 학생이 없습니다.")
    64	
    65	```
    66	</details>
    67	
    68	#### 문제2: 반별 최고 점수 학생 찾기
    69	여러 반의 학생 이름과 점수가 다음과 같이 딕셔너리로 주어집니다.
    70	각 반에서 최고 점수를 받은 학생의 이름과 점수를 출력하는 프로그램을 작성하세요.
    71	```python
    72	
    73	classes = {
    74	    "1반": {"철수": 85, "영희": 92, "민수": 78},
    75	    "2반": {"지영": 90, "수진": 88, "현우": 95},
    76	    "3반": {"민지": 91, "지수": 89, "준호": 87}
    77	}
    78	```
    79	출력
    80	```
    81	1반: 영희 (92점)
    82	2반: 현우 (95점)
    83	3반: 민지 (91점)
    84	```
    85	<details>
    86	<summary>풀이</summary>
    87	
    88	```python
    89	classes = {
    90	    "1반": {"철수": 85, "영희": 92, "민수": 78},
    91	    "2반": {"지영": 90, "수진": 88, "현우": 95},
    92	    "3반": {"민지": 91, "지수": 89, "준호": 87}
    93	}
    94	for class_name, students in classes.items():
    95	    max_score = max(students.values())
    96	    top_student = [name for name, score in students.items() if score == max_score]
    97	    print(f"{class_name}: {top_student[0]} ({max_score}점)")
    98	```
    99	</details>
   100	
   101	#### 백준 문제 20291
   102	문제: 파일 정리
   103	문제 링크:https://www.acmicpc.net/problem/20291
   104	
   105	### 함수
   106	
   107	#### 문제3. 학생 점수 평균과 최고점수 반환 함수 만들기
   108	학생들의 이름과 점수가 담긴 딕셔너리가 주어집니다.
   109	이 딕셔너리를 인자로 받아,
   110	        •       전체 학생의 평균 점수와
   111	        •       최고 점수를 받은 학생의 이름과 점수
   112	를 튜플로 반환하는 함수를 작성하세요.
   113	
   114	```python
   115	students = {
   116	    "철수": 85,
   117	    "영희": 92,
   118	    "민수": 78,
   119	    "지영": 90
   120	}
   121	```
   122	
   123	함수 사용예시
   124	```python
   125	result = analyze_scores(students)
   126	print(result)
   127	# 출력 예시: (86.25, '영희', 92)
   128	```
   129	
   130	<details>
   131	<summary>풀이</summary>
   132	
   133	```python
   134	def analyze_scores(students):
   135	    total_score = sum(students.values())
   136	    average_score = total_score / len(students)
   137	    
   138	    max_score = max(students.values())
   139	    top_student = [name for name, score in students.items() if score == max_score]
   140	    
   141	    return (average_score, top_student[0], max_score)
   142	students = {
   143	    "철수": 85,
   144	    "영희": 92,
   145	    "민수": 78,
   146	    "지영": 90
   147	}
   148	result = analyze_scores(students)
   149	print(result)
   150	# 출력 예시: (86.25, '영희', 92)
   151	```
   152	</details>
   153	
   154	#### 문제4: 점수 기준으로 학생 정렬하기 (람다 함수 활용)
   155	학생들의 이름과 점수가 담긴 리스트가 있습니다.
   156	이 리스트를 점수를 기준으로 내림차순 정렬하는 프로그램을 작성하세요.
   157	단, 정렬에는 람다(lambda) 함수를 사용해야 합니다.
   158	```python
   159	students = [
   160	    ("철수", 85),
   161	    ("영희", 92),
   162	    ("민수", 78),
   163	    ("지영", 90)
   164	]
   165	
   166	[('영희', 92), ('지영', 90), ('철수', 85), ('민수', 78)]
   167	
   168	```
   169	
   170	<details>
   171	<summary>풀이</summary>
   172	
   173	```python
   174	students = [
   175	    ("철수", 85),
   176	    ("영희", 92),
   177	    ("민수", 78),
   178	    ("지영", 90)
   179	]
   180	sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
   181	print(sorted_students)
   182	```
   183	</details>
   184	
   185	#### 문제5: 학생 점수 5점씩 올리기 (map 함수 활용)
   186	학생들의 이름과 점수가 담긴 리스트가 있습니다.
   187	모든 학생의 점수를 5점씩 올린 새로운 리스트를 만들어 출력하세요.
   188	단, 점수 변환에는 map 함수를 사용해야 합니다.
   189	```python
   190	students = [
   191	    ("철수", 85),
   192	    ("영희", 92),
   193	    ("민수", 78),
   194	    ("지영", 90)
   195	]
   196	```
   197	출력 예시
   198	```
   199	[('철수', 90), ('영희', 97), ('민수', 83), ('지영', 95)]
   200	```
   201	
   202	<details>
   203	<summary>풀이</summary>
   204	
   205	```python
   206	students = [
   207	    ("철수", 85),
   208	    ("영희", 92),
   209	    ("민수", 78),
   210	    ("지영", 90)
   211	]
   212	
   213	# map 함수를 사용하여 점수 5점씩 올리기
   214	new_students = list(map(lambda x: (x[0], x[1] + 5), students))
   215	
   216	print(new_students)
   217	
   218	```
   219	</details>
   220	
   221	#### 문제6: 학생(Student) 클래스 만들기
   222	학생의 이름과 점수를 저장하는 Student 클래스를 만드세요.
   223	이 클래스는 다음과 같은 기능을 가져야 합니다.
   224	        1.      생성자에서 이름과 점수를 입력받아 저장한다.
   225	        2.      학생 정보를 출력하는 `show_info()` 메서드를 가진다.
   226	        3.      점수를 변경하는 `update_score(new_score)` 메서드를 가진다.
   227	아래와 같이 클래스를 사용했을 때, 예시와 같은 결과가 나오도록 하세요.
   228	예시 코드
   229	```python
   230	s1 = Student("철수", 85)
   231	s2 = Student("영희", 92)
   232	
   233	s1.show_info()      # 이름: 철수, 점수: 85
   234	s2.show_info()      # 이름: 영희, 점수: 92
   235	
   236	s1.update_score(90)
   237	s1.show_info()      # 이름: 철수, 점수: 90
   238	```
   239	
   240	<details>
   241	<summary>풀이</summary>
   242	
   243	```python
   244	class Student:
   245	    def __init__(self, name, score):
   246	        self.name = name
   247	        self.score = score
   248	
   249	    def show_info(self):
   250	        print(f"이름: {self.name}, 점수: {self.score}")
   251	
   252	    def update_score(self, new_score):
   253	        self.score = new_score
   254	s1 = Student("철수", 85)
   255	s2 = Student("영희", 92)
   256	s1.show_info()      # 이름: 철수, 점수: 85
   257	s2.show_info()      # 이름: 영희, 점수: 92
   258	s1.update_score(90)
   259	s1.show_info()      # 이름: 철수, 점수: 90
   260	```
   261	</details>
   262	
   263	
   264	#### 문제7: 학생과 대학생 클래스 만들기 (상속 활용)
   265	        1.      Student 클래스를 만드세요.
   266	        •       이름(name)과 점수(score)를 저장합니다.
   267	        •       학생 정보를 출력하는 `show_info()` 메서드를 가집니다.
   268	        2.      UniversityStudent 클래스를 만드세요.
   269	        •       Student 클래스를 상속받습니다.
   270	        •       추가로 전공(major) 정보를 저장합니다.
   271	        •       학생 정보를 출력하는 `show_info()` 메서드를 오버라이드하여,
   272	이름, 점수, 전공을 모두 출력하도록 하세요.
   273	
   274	```python
   275	s = Student("철수", 85)
   276	u = UniversityStudent("영희", 92, "컴퓨터공학")
   277	
   278	s.show_info()   # 이름: 철수, 점수: 85
   279	u.show_info()   # 이름: 영희, 점수: 92, 전공: 컴퓨터공학
   280	```
   281	
   282	<details>
   283	<summary>풀이</summary>
   284	
   285	```python
   286	class Student:
   287	    def __init__(self, name, score):
   288	        self.name = name
   289	        self.score = score
   290	
   291	    def show_info(self):
   292	        print(f"이름: {self.name}, 점수: {self.score}")
   293	class UniversityStudent(Student):
   294	    def __init__(self, name, score, major):
   295	        super().__init__(name, score)
   296	        self.major = major
   297	
   298	    def show_info(self):
   299	        print(f"이름: {self.name}, 점수: {self.score}, 전공: {self.major}")
   300	s = Student("철수", 85)
   301	u = UniversityStudent("영희", 92, "컴퓨터공학")
   302	s.show_info()   # 이름: 철수, 점수: 85
   303	u.show_info()   # 이름: 영희, 점수: 92, 전공: 컴퓨터공학
   304	```
   305	</details>
   306	
   307	
   308	#### 문제8: Pydantic BaseModel을 활용한 학생 정보 검증 및 JSON 변환
   309	        1.      Student 클래스를 Pydantic의 `BaseModel`을 상속받아 만드세요.
   310	        •       이름(name, str)과 점수(score, int)를 필드로 가집니다.
   311	        •       점수는 0 이상 100 이하만 허용되도록 검증하세요.
   312	        2.      여러 명의 학생 정보를 담은 딕셔너리 리스트가 있습니다.
   313	이 리스트를 이용해 Student 인스턴스 리스트를 만드세요.
   314	        3.      Student 인스턴스 리스트를 JSON 문자열로 변환하세요.
   315	        4.      JSON 문자열을 다시 읽어와 Student 인스턴스 리스트로 복원하세요.
   316	        5.      각 학생의 정보를 출력하세요.
   317	
   318	```python
   319	data = [
   320	    {"name": "철수", "score": 85},
   321	    {"name": "영희", "score": 92},
   322	    {"name": "민수", "score": 78},
   323	    {"name": "지영", "score": 90}
   324	]
   325	
   326	이름: 철수, 점수: 85
   327	이름: 영희, 점수: 92
   328	이름: 민수, 점수: 78
   329	이름: 지영, 점수: 90
   330	
   331	```
   332	
   333	<details>
   334	<summary>풀이</summary>
   335	
   336	```python
   337	from pydantic import BaseModel, Field, ValidationError
   338	import json
   339	
   340	class Student(BaseModel):
   341	    name: str
   342	    score: int = Field(..., ge=0, le=100)  # 0 이상 100 이하
   343	
   344	    def show_info(self):
   345	        print(f"이름: {self.name}, 점수: {self.score}")
   346	
   347	# 1. 딕셔너리 리스트로부터 Student 인스턴스 리스트 생성
   348	data = [
   349	    {"name": "철수", "score": 85},
   350	    {"name": "영희", "score": 92},
   351	    {"name": "민수", "score": 78},
   352	    {"name": "지영", "score": 90}
   353	]
   354	
   355	students = [Student(**d) for d in data]
   356	
   357	# 2. Student 인스턴스 리스트를 JSON 문자열로 변환
   358	json_str = json.dumps([s.dict() for s in students], ensure_ascii=False, indent=2)
   359	
   360	# 3. JSON 문자열을 다시 Student 인스턴스 리스트로 복원
   361	loaded_data = json.loads(json_str)
   362	loaded_students = [Student(**d) for d in loaded_data]
   363	
   364	# 4. 학생 정보 출력
   365	for s in loaded_students:
   366	    s.show_info()
   367	```
   368	</details>
   369	
   370	### 모듈화
   371	
   372	#### 문제9: 학생 관리 시스템 모듈화
   373	학생 정보를 관리하는 프로그램을 다음과 같이 **3개의 파일(모듈)**로 나누어 작성하세요.
   374	1. `student.py`
   375	        •       `Student` 클래스를 정의합니다.
   376	        •       이름(name), 점수(score) 필드를 가집니다.
   377	        •       점수는 0~100 사이만 허용하며, 범위를 벗어나면 예외를 발생시킵니다.
   378	        •       학생 정보를 출력하는 `show_info()` 메서드를 가집니다.
   379	2. `manager.py`
   380	        •       `StudentManager` 클래스를 정의합니다.
   381	        •       학생(Student) 인스턴스 리스트를 관리합니다.
   382	        •       학생 추가, 전체 학생 정보 출력, 학생 정보를 파일로 저장/불러오기 기능을 메서드로 구현합니다.
   383	        •       파일 저장/불러오기 시 JSON 형식을 사용합니다.
   384	3. `main.py`
   385	        •       사용자로부터 학생 정보를 입력받아 추가하고,
   386	전체 학생 정보를 출력하며,
   387	프로그램 종료 시 학생 정보를 파일로 저장하는 코드를 작성하세요.
   388	
   389	```python
   390	1. 학생 추가
   391	2. 전체 학생 보기
   392	3. 종료
   393	메뉴 선택: 1
   394	이름: 철수
   395	점수: 105
   396	점수는 0~100 사이여야 합니다.
   397	
   398	메뉴 선택: 1
   399	이름: 영희
   400	점수: 92
   401	
   402	메뉴 선택: 2
   403	이름: 영희, 점수: 92
   404	
   405	메뉴 선택: 3
   406	학생 정보가 저장되었습니다.
   407	
   408	```
   409	
   410	<details>
   411	<summary>풀이</summary>
   412	
   413	1. `student.py`
   414	
   415	```python
   416	class ScoreError(Exception):
   417	    pass
   418	
   419	class Student:
   420	    def __init__(self, name, score):
   421	        if not (0 <= score <= 100):
   422	            raise ScoreError("점수는 0~100 사이여야 합니다.")
   423	        self.name = name
   424	        self.score = score
   425	
   426	    def show_info(self):
   427	        print(f"이름: {self.name}, 점수: {self.score}")
   428	
   429	    def to_dict(self):
   430	        return {"name": self.name, "score": self.score}
   431	
   432	    @classmethod
   433	    def from_dict(cls, data):
   434	        return cls(data["name"], data["score"])
   435	```
   436	
   437	2. `manager.py`
   438	
   439	```python
   440	import json
   441	from student import Student, ScoreError
   442	
   443	class StudentManager:
   444	    def __init__(self):
   445	        self.students = []
   446	
   447	    def add_student(self, name, score):
   448	        try:
   449	            student = Student(name, score)
   450	            self.students.append(student)
   451	        except ScoreError as e:
   452	            print(e)
   453	
   454	    def show_all(self):
   455	        if not self.students:
   456	            print("등록된 학생이 없습니다.")
   457	        for s in self.students:
   458	            s.show_info()
   459	
   460	    def save_to_file(self, filename):
   461	        with open(filename, "w", encoding="utf-8") as f:
   462	            json.dump([s.to_dict() for s in self.students], f, ensure_ascii=False, indent=2)
   463	
   464	    def load_from_file(self, filename):
   465	        try:
   466	            with open(filename, "r", encoding="utf-8") as f:
   467	                data = json.load(f)
   468	                self.students = [Student.from_dict(d) for d in data]
   469	        except FileNotFoundError:
   470	            self.students = []
   471	
   472	```
   473	3. `main.py`
   474	
   475	```python
   476	from manager import StudentManager
   477	
   478	def main():
   479	    manager = StudentManager()
   480	    manager.load_from_file("students.json")
   481	
   482	    while True:
   483	        print("\n1. 학생 추가")
   484	        print("2. 전체 학생 보기")
   485	        print("3. 종료")
   486	        menu = input("메뉴 선택: ")
   487	
   488	        if menu == "1":
   489	            name = input("이름: ")
   490	            try:
   491	                score = int(input("점수: "))
   492	            except ValueError:
   493	                print("점수는 숫자로 입력하세요.")
   494	                continue
   495	            manager.add_student(name, score)
   496	        elif menu == "2":
   497	            manager.show_all()
   498	        elif menu == "3":
   499	            manager.save_to_file("students.json")
   500	            print("학생 정보가 저장되었습니다.")
   501	            break
   502	        else:
   503	            print("잘못된 입력입니다.")
   504	
   505	if __name__ == "__main__":
   506	    main()
   507	
   508	```
   509	</details>
   510	
   511	
   512	### 기본 챗봇 만들기
   513	
   514	https://docs.chainlit.io/integrations/openai
   515	
   516	```sh
   517	pip install -r requirements.txt
   518	
   519	chainlit run app.py
   520	```
   521	
   522	
   523	
   524

Here's the result of running `cat -n` on /HakjunMIN__python-workshop/app.py:
     1	import os
     2	from dotenv import load_dotenv
     3	import chainlit as cl
     4	from openai import AsyncAzureOpenAI
     5	
     6	# Load environment variables
     7	load_dotenv(override=True)
     8	API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
     9	ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
    10	DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4")  # Your deployment name
    11	API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2025-01-01-preview")
    12	
    13	# Initialize Azure OpenAI client
    14	client = AsyncAzureOpenAI(
    15	    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    16	    api_version="2025-01-01-preview",
    17	    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
    18	)
    19	
    20	settings = {
    21	    "model": DEPLOYMENT_NAME,
    22	    "temperature": 0.7,
    23	    "max_tokens": 500,
    24	    "top_p": 1,
    25	    "frequency_penalty": 0,
    26	    "presence_penalty": 0,
    27	}
    28	
    29	
    30	@cl.on_chat_start
    31	def start_chat():
    32	    cl.user_session.set(
    33	        "message_history",
    34	        [{"role": "system", "content": "You are a helpful assistant."}],
    35	    )
    36	
    37	@cl.on_message
    38	async def main(message: cl.Message):
    39	    message_history = cl.user_session.get("message_history")
    40	    message_history.append({"role": "user", "content": message.content})
    41	
    42	    msg = cl.Message(content="")
    43	
    44	    stream = await client.chat.completions.create(
    45	        messages=message_history, stream=True, **settings
    46	    )
    47	
    48	    async for part in stream:
    49	        if part.choices and (token := part.choices[0].delta.content or ""):
    50	            await msg.stream_token(token)
    51	
    52	    message_history.append({"role": "assistant", "content": msg.content})
    53	    await msg.update()

Here's the result of running `cat -n` on /HakjunMIN__python-workshop/requirements.txt:
     1	chainlit==2.5.5
     2	openai==1.75.0
     3	python-dotenv==1.1.0

Here's the result of running `cat -n` on /HakjunMIN__python-workshop/chainlit.md:
     1	# Welcome to Chainlit! 🚀🤖
     2	
     3	Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
     4	
     5	## Useful Links 🔗
     6	
     7	- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
     8	- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
     9	
    10	We can't wait to see what you create with Chainlit! Happy coding! 💻😊
    11	
    12	## Welcome screen
    13	
    14	To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.
    15

Traceback (most recent call last):
  File "/HakjunMIN__python-workshop/app.py", line 2, in <module>
    from dotenv import load_dotenv
ModuleNotFoundError: No module named 'dotenv'

WARNING: Package(s) not found: python-dotenv

Collecting python-dotenv
  Downloading python_dotenv-1.2.1-py3-none-any.whl.metadata (25 kB)
Downloading python_dotenv-1.2.1-py3-none-any.whl (21 kB)
Installing collected packages: python-dotenv
Successfully installed python-dotenv-1.2.1
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

[notice] A new release of pip is available: 24.0 -> 25.3
[notice] To update, run: pip install --upgrade pip

Traceback (most recent call last):
  File "/HakjunMIN__python-workshop/app.py", line 3, in <module>
    import chainlit as cl
ModuleNotFoundError: No module named 'chainlit'