diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..0e71aef3deaad041f372d172bfea681b698376dc --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# Haptix_image_dataset +물리적 정보와 감각정 정보를 연결하고 라벨링한 데이터셋 diff --git a/README_IMAGE_ANALYSIS.md b/README_IMAGE_ANALYSIS.md new file mode 100644 index 0000000000000000000000000000000000000000..67d42a312324bc5ccccf5e4af5a45f9d573aceda --- /dev/null +++ b/README_IMAGE_ANALYSIS.md @@ -0,0 +1,180 @@ +# 이미지 데이터셋 상태 분석 시스템 + +## 개요 +이 노트북 파일(`iamge_status.ipynb`)은 Haptix 이미지 데이터셋의 라벨 분포를 자동으로 분석하고 시각화하는 종합 관리 시스템입니다. + +## 주요 기능 + +### 1. **자동 라벨 인식** + - `_`(언더스코어)로 구분된 라벨을 자동으로 추출 + - 새로운 폴더 추가 시 자동으로 인식 + - 폴더명 형식: `LABEL1_LABEL2_LABEL3...` + +### 2. **다중 소스 지원** + - EmoSet_images + - Midjourney_images + - unsplash_images + - 새로운 소스 폴더 추가 시 자동 처리 + +### 3. **생성 파일** + +#### 📊 시각화 파일 +- **`image_distribution_overview.png`**: 전체 라벨 분포 종합 분석 + - 전체 라벨별 이미지 개수 (막대 그래프) + - 데이터 소스별 이미지 개수 비교 + - 라벨 분포 비율 (파이 차트) + - 통계 정보 표시 + +- **`image_distribution_by_source.png`**: 소스별 상세 분석 + - EmoSet_images: 라벨별 분포 + - Midjourney_images: 라벨별 분포 + - unsplash_images: 라벨별 분포 + +#### 📋 데이터 파일 +- **`image_label_distribution.csv`**: 라벨별 이미지 개수 (Excel/Google Sheets에서 열 수 있음) + - 전체 라벨 목록 + - 각 소스별 이미지 개수 + - Excel 등에서 추가 분석 가능 + +## 분석 결과 요약 + +### 📈 현재 상태 (2025-11-14) + +| 항목 | 값 | +|------|-----| +| **총 라벨 종류** | 22개 | +| **총 이미지 개수** | 14,070개 | +| **라벨당 평균** | 636.4개 | +| **라벨당 최대값** | 1,575개 (P5Static) | +| **라벨당 최소값** | 2개 (E5St, messy) | +| **표준편차** | 470.0개 | + +### ⚠️ 주의 - 불균형 라벨 + +평균의 **50% 이상 부족**한 라벨: +- `P1Soft`: 293개 (평균의 46.0%) +- `P1Hard`: 243개 (평균의 38.2%) +- `energy`: 74개 (평균의 11.6%) +- `pleasure`: 55개 (평균의 8.6%) +- `unpleasnat`: 14개 (평균의 2.2%) +- `E5St`: 2개 (평균의 0.3%) +- `messy`: 2개 (평균의 0.3%) + +### 💡 권장사항 + +**균형도 지표: 787.5x (최대값/최소값)** +- ⚠️ **심각한 불균형이 존재합니다** + +#### 해결 방안: +1. **데이터 보강 (Data Augmentation)** + - 부족한 라벨에 대해 이미지 회전, 확대/축소, 색상 변환 등 적용 + - 특히 `E5St`, `messy`, `unpleasnat`, `pleasure`, `energy` 라벨 우선 + +2. **모델 학습 시 클래스 가중치 조정** + ```python + class_weights = { + 'P5Static': 1.0, # 충분함 + 'E3N-Chaotic': 1.0, + # ... + 'E5St': 318.75, # 매우 부족 (636.4 / 2) + 'messy': 318.75, + } + ``` + +3. **샘플링 전략** + - 언더샘플링(undersampling): 많은 라벨의 데이터 일부만 사용 + - 오버샘플링(oversampling): 부족한 라벨의 데이터 반복 사용 + +## 사용 방법 + +### 1. 노트북 실행 +```bash +# VS Code에서 Jupyter Notebook 커널 선택 후 +# 모든 셀을 순서대로 실행 +Ctrl + Shift + Enter (현재 셀) +또는 +셀 > 모두 실행 (Run All) +``` + +### 2. 새 이미지 소스 추가 +```bash +# image 폴더에 새 폴더 추가 (예: new_source/) +c:\Users\EL081\Desktop\backup\Haptix_image_dataset\image\new_source\ + ├── LABEL1_LABEL2\ + │ ├── image1.jpg + │ └── image2.png + └── LABEL3_LABEL4\ + └── image3.jpg + +# 노트북을 다시 실행하면 자동으로 분석됨 +``` + +### 3. 결과 해석 +- **빨간색 막대**: 평균 이하의 라벨 (주의 필요) +- **파란색 막대**: 평균 이상의 라벨 (충분함) +- **초록색 점선**: 평균값 + +## 기술 사항 + +### 지원 이미지 형식 +- JPG, JPEG, PNG, GIF, BMP, WEBP + +### 폴더 구조 자동 처리 +- 라벨 폴더 내 하위 폴더도 재귀적으로 검색 +- 파일명 무시 (라벨은 폴더명에서만 추출) + +### 확장성 +- 새 소스 추가 시 자동 인식 +- 새 라벨 추가 시 자동 처리 +- 코드 수정 불필요 + +## 주의사항 + +1. **파일명 규칙** + - 이미지가 포함된 폴더명은 반드시 `_`로 라벨을 구분해야 함 + - 예: ✅ `P1Hard_E1N-Risky` / ❌ `P1Hard E1N-Risky` + +2. **이미지 개수** + - 폴더 내 모든 파일을 카운팅 + - 비이미지 파일(텍스트, 문서)은 무시됨 + +3. **성능** + - 수천 개 이미지 분석 시 약 15-20초 소요 + - 처음 로드 시간이 가장 오래 걸림 + +## 문제 해결 + +### Q: 새 데이터를 추가했는데 반영이 안 됨 +A: 노트북의 **모든 셀을 다시 실행**해주세요. (`Ctrl + Shift + Enter`) + +### Q: CSV 파일이 Excel에서 한글이 깨짐 +A: CSV 파일을 메모장으로 열어 `UTF-8 BOM` 인코딩으로 저장 후 Excel에서 열기 + +### Q: 특정 라벨만 분석하고 싶음 +A: 노트북의 첫 번째 셀에서 `base_path`를 수정하면 됨 + +## 파일 목록 + +``` +backup/ +├── iamge_status.ipynb ← 메인 분석 노트북 +├── image_distribution_overview.png ← 전체 분석 그래프 +├── image_distribution_by_source.png ← 소스별 분석 그래프 +├── image_label_distribution.csv ← 라벨별 통계 데이터 +├── README_IMAGE_ANALYSIS.md ← 이 파일 +└── Haptix_image_dataset/ + ├── image/ + │ ├── EmoSet_images/ (3,143개) + │ ├── Midjourney_images/ (17개) + │ └── unsplash_images/ (1,910개) + └── ... +``` + +## 라이선스 및 지원 + +작성 날짜: 2025-11-14 +최종 업데이트: 2025-11-14 + +--- + +**질문이나 개선 사항이 있으면 노트북의 코드를 수정하거나 새로운 분석 셀을 추가할 수 있습니다.** diff --git a/aaa.ipynb b/aaa.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..11abcfc60774793a13d1ae74dd0b327d99b7706c --- /dev/null +++ b/aaa.ipynb @@ -0,0 +1,608 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ac1c7423", + "metadata": {}, + "source": [ + "# Upload Image Dataset to Hugging Face (Preserve Folders)\n", + "\n", + "This minimal workflow uploads your local folder to a Hugging Face dataset repo, keeping the directory structure intact." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "277a6040", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ready: huggingface_hub installed and imports ok.\n" + ] + } + ], + "source": [ + "# Install and import\n", + "import sys, subprocess, os\n", + "subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", \"huggingface_hub\", \"hf_transfer\"])\n", + "from huggingface_hub import HfApi\n", + "os.environ[\"HF_HUB_ENABLE_HF_TRANSFER\"] = \"1\"\n", + "print(\"Ready: huggingface_hub installed and imports ok.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "32833fb5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Token OK for: Smilesjs\n" + ] + } + ], + "source": [ + "# Set or prompt for HF token (safe)\n", + "import os\n", + "from getpass import getpass\n", + "from huggingface_hub import HfApi\n", + "\n", + "if not os.getenv(\"HF_TOKEN\"):\n", + " token = getpass(\"Enter your HF_TOKEN (input hidden): \")\n", + " os.environ[\"HF_TOKEN\"] = token\n", + "\n", + "# Optional: validate token early\n", + "try:\n", + " _api = HfApi(token=os.environ[\"HF_TOKEN\"])\n", + " who = _api.whoami()\n", + " owner = who.get(\"name\") or who.get(\"email\") or who.get(\"id\")\n", + " print(f\"Token OK for: {owner}\")\n", + "except Exception as e:\n", + " raise RuntimeError(\"HF token seems invalid or network issue. Double-check the token.\") from e" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "fe562d45", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Repo ready: https://huggingface.co/datasets/Smilesjs/Haptix_dataset\n" + ] + } + ], + "source": [ + "# Configure local path and repo\n", + "from pathlib import Path\n", + "import os\n", + "from huggingface_hub import HfApi\n", + "\n", + "LOCAL_FOLDER = Path(r\"c:\\\\Users\\\\EL081\\\\Desktop\\\\local_backup\\\\image\").resolve()\n", + "REPO_ID = \"Smilesjs/Haptix_dataset\" # change if needed\n", + "REPO_TYPE = \"dataset\"\n", + "PRIVATE = True\n", + "\n", + "HF_TOKEN = os.getenv(\"HF_TOKEN\")\n", + "if not HF_TOKEN:\n", + " raise ValueError(\"HF_TOKEN is not set. In PowerShell: $env:HF_TOKEN='hf_...'\")\n", + "\n", + "if not LOCAL_FOLDER.exists():\n", + " raise FileNotFoundError(f\"Local folder not found: {LOCAL_FOLDER}\")\n", + "\n", + "api = HfApi(token=HF_TOKEN)\n", + "api.create_repo(repo_id=REPO_ID, repo_type=REPO_TYPE, private=PRIVATE, exist_ok=True)\n", + "print(f\"Repo ready: https://huggingface.co/datasets/{REPO_ID}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9da1f410", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting resumable upload to Smilesjs/Haptix_dataset with upload_large_folder... (this can take time)\n", + "Local: C:\\Users\\EL081\\Desktop\\local_backup\\image\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2d2dc4acd4ed4ffb8d0ad51d3efda3f9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Recovering from metadata files: 0%| | 0/6920 [00:00 str:\n", + " if n is None:\n", + " return \"?\"\n", + " units = ['B','KB','MB','GB','TB']\n", + " i = 0\n", + " f = float(n)\n", + " while f >= 1024 and i < len(units)-1:\n", + " f /= 1024.0\n", + " i += 1\n", + " return f\"{f:.2f} {units[i]}\"\n", + "\n", + "fs = HfFileSystem(token=HF_TOKEN)\n", + "repo_url = f\"https://huggingface.co/datasets/{REPO_ID}\"\n", + "root = f\"hf://datasets/{REPO_ID}\"\n", + "print(f\"Scanning repo: {repo_url}\")\n", + "\n", + "# Try to invalidate any local cache to avoid stale listings\n", + "if hasattr(fs, \"invalidate_cache\"):\n", + " try:\n", + " fs.invalidate_cache()\n", + " # Also try root-specific invalidation if supported\n", + " try:\n", + " fs.invalidate_cache(root)\n", + " except Exception:\n", + " pass\n", + " print(\"Cache invalidated for HfFileSystem.\")\n", + " except Exception as _e:\n", + " print(\"Cache invalidation skipped:\", type(_e).__name__)\n", + "\n", + "# List all files recursively\n", + "t0 = time.time()\n", + "paths = fs.find(root) # returns file paths recursively\n", + "if not isinstance(paths, list):\n", + " paths = list(paths)\n", + "elapsed = time.time() - t0\n", + "print(f\"Found {len(paths):,} candidate paths in {elapsed:.2f}s\")\n", + "\n", + "# Fallback cross-check with API listing to detect propagation delays\n", + "try:\n", + " api_files = api.list_repo_files(repo_id=REPO_ID, repo_type=REPO_TYPE)\n", + " print(f\"API list_repo_files reports: {len(api_files):,} files\")\n", + " if len(paths) < len(api_files):\n", + " print(\"Note: HfFileSystem may be stale; UI/CDN can lag for ~1-2 minutes.\")\n", + "except Exception as _e:\n", + " print(\"API list_repo_files failed:\", type(_e).__name__)\n", + "\n", + "# Fetch sizes concurrently\n", + "def _info(pth: str):\n", + " try:\n", + " info = fs.info(pth)\n", + " if info.get('type') == 'file':\n", + " return pth, int(info.get('size') or 0)\n", + " except Exception:\n", + " return pth, None\n", + " return pth, None\n", + "\n", + "sizes = {}\n", + "errors = 0\n", + "t0 = time.time()\n", + "with ThreadPoolExecutor(max_workers=24) as ex:\n", + " futs = [ex.submit(_info, p) for p in paths]\n", + " for fut in as_completed(futs):\n", + " p, sz = fut.result()\n", + " if sz is None:\n", + " errors += 1\n", + " else:\n", + " sizes[p] = sz\n", + "elapsed = time.time() - t0\n", + "print(f\"Fetched metadata for {len(sizes):,} files ({errors} errors) in {elapsed:.2f}s\")\n", + "\n", + "# Summaries\n", + "total_files = len(sizes)\n", + "total_bytes = sum(sizes.values())\n", + "by_ext_count = Counter()\n", + "by_ext_bytes = defaultdict(int)\n", + "for p, sz in sizes.items():\n", + " ext = os.path.splitext(p)[1].lower() or \"\"\n", + " by_ext_count[ext] += 1\n", + " by_ext_bytes[ext] += sz\n", + "\n", + "print(\"\\n=== Summary ===\")\n", + "print(f\"Total files: {total_files:,}\")\n", + "print(f\"Total size : {human_bytes(total_bytes)}\")\n", + "\n", + "# Top extensions by bytes\n", + "top_ext = sorted(by_ext_bytes.items(), key=lambda x: x[1], reverse=True)[:10]\n", + "print(\"\\nTop extensions by size:\")\n", + "for ext, b in top_ext:\n", + " print(f\" {ext or '(no ext)'}: {by_ext_count[ext]:,} files, {human_bytes(b)}\")\n", + "\n", + "# Top-level folder distribution\n", + "top_level = Counter()\n", + "for p in sizes.keys():\n", + " rel = p.replace(root.rstrip('/'), '').lstrip('/')\n", + " parts = rel.split('/')\n", + " top = parts[0] if parts and parts[0] else '/'\n", + " top_level[top] += 1\n", + "print(\"\\nTop-level folder counts:\")\n", + "for name, cnt in top_level.most_common(15):\n", + " print(f\" {name}: {cnt:,} files\")\n", + "\n", + "# Largest files\n", + "top_k = 20\n", + "largest = sorted(sizes.items(), key=lambda x: x[1], reverse=True)[:top_k]\n", + "print(f\"\\nTop {top_k} largest files:\")\n", + "for p, sz in largest:\n", + " rel = p.replace(root.rstrip('/'), '').lstrip('/')\n", + " print(f\" {human_bytes(sz)} | {rel}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "beb35ad2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Repo: Smilesjs/Haptix_dataset type: dataset\n", + "list_repo_files count: 3\n", + "First 10: ['.gitattributes', 'augmented_images/E3P-Harmonic_P3Rough_P2Cold_P5Static/E3P+P3R+P2Co+P5St_aug_001.png', 'test_probe.txt']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No files have been modified since last commit. Skipping to prevent empty commit.\n", + "WARNING:huggingface_hub.hf_api:No files have been modified since last commit. Skipping to prevent empty commit.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uploaded marker: test_probe.txt\n", + "list_repo_files after: 3\n", + "Contains marker? True\n", + "\n", + "Recent commits:\n", + "- 8e57433 sample image upload\n", + "- 6a8d3d3 probe upload\n", + "- 16f395e initial commit\n" + ] + } + ], + "source": [ + "# Probe: list files and upload a tiny marker file to confirm branch\n", + "from io import BytesIO\n", + "print(\"Repo:\", REPO_ID, \"type:\", REPO_TYPE)\n", + "files = api.list_repo_files(repo_id=REPO_ID, repo_type=REPO_TYPE)\n", + "print(\"list_repo_files count:\", len(files))\n", + "print(\"First 10:\", files[:10])\n", + "\n", + "marker_path = \"test_probe.txt\"\n", + "api.upload_file(path_or_fileobj=BytesIO(b\"probe\"), path_in_repo=marker_path, repo_id=REPO_ID, repo_type=REPO_TYPE, commit_message=\"probe upload\")\n", + "print(\"Uploaded marker:\", marker_path)\n", + "files2 = api.list_repo_files(repo_id=REPO_ID, repo_type=REPO_TYPE)\n", + "print(\"list_repo_files after:\", len(files2))\n", + "print(\"Contains marker?\", marker_path in files2)\n", + "\n", + "# Show latest commits\n", + "commits = api.list_repo_commits(repo_id=REPO_ID, repo_type=REPO_TYPE)\n", + "print(\"\\nRecent commits:\")\n", + "for c in commits[:5]:\n", + " print(\"-\", c.commit_id[:7], c.title)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "dbc2c9de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uploading sample: C:\\Users\\EL081\\Desktop\\local_backup\\image\\augmented_images\\E3P-Harmonic_P3Rough_P2Cold_P5Static\\E3P+P3R+P2Co+P5St_aug_001.png\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b0ce6dca03e4dcfbd235e3e9c1573e7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Processing Files (0 / 0): | | 0.00B / 0.00B " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fb3e8bf2c1b5438aaf6334a4333e0c8a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "New Data Upload: | | 0.00B / 0.00B " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uploaded to: augmented_images/E3P-Harmonic_P3Rough_P2Cold_P5Static/E3P+P3R+P2Co+P5St_aug_001.png\n" + ] + } + ], + "source": [ + "# Probe: upload one image file to confirm dataset accepts content\n", + "import os\n", + "from pathlib import Path\n", + "from itertools import chain\n", + "exts = {\".jpg\",\".jpeg\",\".png\"}\n", + "sample_path = None\n", + "for root_dir, dirs, files in os.walk(LOCAL_FOLDER):\n", + " for fn in files:\n", + " if Path(fn).suffix.lower() in exts:\n", + " sample_path = Path(root_dir) / fn\n", + " break\n", + " if sample_path:\n", + " break\n", + "if not sample_path:\n", + " raise RuntimeError(\"No image file found under LOCAL_FOLDER.\")\n", + "rel = sample_path.relative_to(LOCAL_FOLDER).as_posix()\n", + "dest = rel # or f\"image/{rel}\" to nest under image/\n", + "print(\"Uploading sample:\", sample_path)\n", + "api.upload_file(path_or_fileobj=str(sample_path), path_in_repo=dest, repo_id=REPO_ID, repo_type=REPO_TYPE, commit_message=\"sample image upload\")\n", + "print(\"Uploaded to:\", dest)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5a5057d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No .hf_transfer metadata directories found under LOCAL_FOLDER.\n" + ] + } + ], + "source": [ + "# Optional: clear hf_transfer cached metadata under LOCAL_FOLDER to avoid stale plans\n", + "import os, shutil\n", + "found = []\n", + "for root_dir, dirs, files in os.walk(LOCAL_FOLDER):\n", + " if \".hf_transfer\" in dirs:\n", + " found.append(os.path.join(root_dir, \".hf_transfer\"))\n", + "if found:\n", + " print(\"Found hf_transfer metadata dirs:\")\n", + " for d in found:\n", + " print(\" -\", d)\n", + " # Uncomment next lines to clear the cached metadata that may point to another repo\n", + " # for d in found:\n", + " # shutil.rmtree(d, ignore_errors=True)\n", + " # print(\"Cleared hf_transfer metadata.\")\n", + "else:\n", + " print(\"No .hf_transfer metadata directories found under LOCAL_FOLDER.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "1668f9a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "upload_large_folder signature: (repo_id: 'str', folder_path: 'Union[str, Path]', *, repo_type: 'str', revision: 'Optional[str]' = None, private: 'Optional[bool]' = None, allow_patterns: 'Optional[Union[list[str], str]]' = None, ignore_patterns: 'Optional[Union[list[str], str]]' = None, num_workers: 'Optional[int]' = None, print_report: 'bool' = True, print_report_every: 'int' = 60) -> 'None'\n", + "\n", + "Doc (first 40 lines):\n", + " Upload a large folder to the Hub in the most resilient way possible.\n", + "\n", + "Several workers are started to upload files in an optimized way. Before being committed to a repo, files must be\n", + "hashed and be pre-uploaded if they are LFS files. Workers will perform these tasks for each file in the folder.\n", + "At each step, some metadata information about the upload process is saved in the folder under `.cache/.huggingface/`\n", + "to be able to resume the process if interrupted. The whole process might result in several commits.\n", + "\n", + "Args:\n", + " repo_id (`str`):\n", + " The repository to which the file will be uploaded.\n", + " E.g. `\"HuggingFaceTB/smollm-corpus\"`.\n", + " folder_path (`str` or `Path`):\n", + " Path to the folder to upload on the local file system.\n", + " repo_type (`str`):\n", + " Type of the repository. Must be one of `\"model\"`, `\"dataset\"` or `\"space\"`.\n", + " Unlike in all other `HfApi` methods, `repo_type` is explicitly required here. This is to avoid\n", + " any mistake when uploading a large folder to the Hub, and therefore prevent from having to re-upload\n", + " everything.\n", + " revision (`str`, `optional`):\n", + " The branch to commit to. If not provided, the `main` branch will be used.\n", + " private (`bool`, `optional`):\n", + " Whether the repository should be private.\n", + " If `None` (default), the repo will be public unless the organization's default is private.\n", + " allow_patterns (`list[str]` or `str`, *optional*):\n", + " If provided, only files matching at least one pattern are uploaded.\n", + " ignore_patterns (`list[str]` or `str`, *optional*):\n", + " If provided, files matching any of the patterns are not uploaded.\n", + " num_workers (`int`, *optional*):\n", + " Number of workers to start. Defaults to `os.cpu_count() - 2` (minimum 2).\n", + " A higher number of workers may speed up the process if your machine allows it. However, on machines with a\n", + " slower connection, it is recommended to keep the number of workers low to ensure better resumability.\n", + " Indeed, partially uploaded files will have to be completely re-uploaded if the process is interrupted.\n", + " print_report (`bool`, *optional*):\n", + " Whether to print a report of the upload progress. Defaults to True.\n", + " Report is printed to `sys.stdout` every X seconds (60 by defaults) and overwrites the previous report.\n", + " print_report_every (`int`, *optional*):\n", + " Frequency at which the report is printed. Defaults to 60 seconds.\n", + "\n", + "> [!TIP]\n", + "> A few things to keep in mind:\n" + ] + } + ], + "source": [ + "# Inspect upload_large_folder signature\n", + "import inspect, textwrap\n", + "sig = inspect.signature(api.upload_large_folder)\n", + "print(\"upload_large_folder signature:\", sig)\n", + "doc = inspect.getdoc(api.upload_large_folder)\n", + "print(\"\\nDoc (first 40 lines):\\n\", \"\\n\".join(doc.splitlines()[:40]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/check.ipynb b/check.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4e38f59798ec8651bdf4cfeaf6a4ae8e4a0144d6 --- /dev/null +++ b/check.ipynb @@ -0,0 +1,219 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "afc7ef8c", + "metadata": {}, + "source": [ + "# Image Folder Analysis\n", + "이 노트북은 `image` 폴더 내의 모든 이미지 파일 수를 분석합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7a5442aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "이미지 폴더 분석 결과\n", + "============================================================\n", + "\n", + "전체 파일 수: 13,841\n", + "이미지 파일 수: 6,918\n", + "기타 파일 수: 6,923\n", + "\n", + "============================================================\n", + "메인 폴더별 이미지 수\n", + "============================================================\n" + ] + } + ], + "source": [ + "import os\n", + "import pandas as pd\n", + "from pathlib import Path\n", + "from collections import defaultdict\n", + "\n", + "# 이미지 폴더 경로\n", + "image_folder = r\"C:\\Users\\EL081\\Desktop\\local_backup\\image\"\n", + "\n", + "# 이미지 파일 확장자\n", + "image_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff', '.tif', '.ico', '.svg'}\n", + "\n", + "# 전체 파일 수 계산\n", + "total_files = 0\n", + "total_images = 0\n", + "folder_stats = defaultdict(lambda: {'total': 0, 'images': 0})\n", + "\n", + "for root, dirs, files in os.walk(image_folder):\n", + " for file in files:\n", + " total_files += 1\n", + " ext = Path(file).suffix.lower()\n", + " if ext in image_extensions:\n", + " total_images += 1\n", + " \n", + " # 메인 폴더별 통계\n", + " relative_path = os.path.relpath(root, image_folder)\n", + " main_folder = relative_path.split(os.sep)[0]\n", + " folder_stats[main_folder]['total'] += 1\n", + " if ext in image_extensions:\n", + " folder_stats[main_folder]['images'] += 1\n", + "\n", + "print(\"=\" * 60)\n", + "print(\"이미지 폴더 분석 결과\")\n", + "print(\"=\" * 60)\n", + "print(f\"\\n전체 파일 수: {total_files:,}\")\n", + "print(f\"이미지 파일 수: {total_images:,}\")\n", + "print(f\"기타 파일 수: {total_files - total_images:,}\")\n", + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"메인 폴더별 이미지 수\")\n", + "print(\"=\" * 60)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "be675b07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ".cache 이미지: 0 전체: 6,921\n", + "EmoSet_images 이미지: 2,888 전체: 2,888\n", + "Midjourney_images 이미지: 17 전체: 17\n", + "augmented_images 이미지: 1,313 전체: 1,315\n", + "generated_images 이미지: 795 전체: 795\n", + "unsplash_images 이미지: 1,905 전체: 1,905\n", + "\n", + "============================================================\n", + "메인 폴더별 이미지 수 (상세)\n", + "============================================================\n", + " 폴더명 이미지수 전체파일수\n", + " EmoSet_images 2888 2888\n", + " unsplash_images 1905 1905\n", + " augmented_images 1313 1315\n", + " generated_images 795 795\n", + "Midjourney_images 17 17\n", + " .cache 0 6921\n" + ] + } + ], + "source": [ + "# 메인 폴더별 상세 통계\n", + "for folder in sorted(folder_stats.keys()):\n", + " stats = folder_stats[folder]\n", + " print(f\"{folder:<40} 이미지: {stats['images']:>6,} 전체: {stats['total']:>6,}\")\n", + "\n", + "# 데이터프레임으로 정렬된 결과 표시\n", + "df_stats = pd.DataFrame([\n", + " {'폴더명': folder, '이미지수': stats['images'], '전체파일수': stats['total']}\n", + " for folder, stats in folder_stats.items()\n", + "]).sort_values('이미지수', ascending=False)\n", + "\n", + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"메인 폴더별 이미지 수 (상세)\")\n", + "print(\"=\" * 60)\n", + "print(df_stats.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84374e6a", + "metadata": {}, + "outputs": [], + "source": [ + "# 파일 타입별 분석\n", + "extension_count = defaultdict(int)\n", + "\n", + "for root, dirs, files in os.walk(image_folder):\n", + " for file in files:\n", + " ext = Path(file).suffix.lower()\n", + " if ext:\n", + " extension_count[ext] += 1\n", + "\n", + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"파일 형식별 수\")\n", + "print(\"=\" * 60)\n", + "\n", + "df_ext = pd.DataFrame([\n", + " {'파일형식': ext, '수': count}\n", + " for ext, count in extension_count.items()\n", + "]).sort_values('수', ascending=False)\n", + "\n", + "print(df_ext.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d37eae36", + "metadata": {}, + "outputs": [], + "source": [ + "# 시각화\n", + "import matplotlib.pyplot as plt\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# 1. 메인 폴더별 이미지 수 차트\n", + "plt.subplot(1, 2, 1)\n", + "df_sorted = df_stats.sort_values('이미지수', ascending=True)\n", + "plt.barh(df_sorted['폴더명'], df_sorted['이미지수'], color='steelblue')\n", + "plt.xlabel('이미지 수')\n", + "plt.title('메인 폴더별 이미지 수')\n", + "plt.grid(axis='x', alpha=0.3)\n", + "\n", + "# 2. 상위 10개 파일 형식 차트\n", + "plt.subplot(1, 2, 2)\n", + "df_ext_top = df_ext.head(10)\n", + "plt.bar(df_ext_top['파일형식'], df_ext_top['수'], color='coral')\n", + "plt.xlabel('파일 형식')\n", + "plt.ylabel('수')\n", + "plt.title('상위 10개 파일 형식')\n", + "plt.xticks(rotation=45)\n", + "plt.grid(axis='y', alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\n✓ 분석 완료!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b91d4a75", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/hug.ipynb b/hug.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..a1104e5e6e046a63eb239c69d4160005f4cf65fd --- /dev/null +++ b/hug.ipynb @@ -0,0 +1,79 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ae64f9ce", + "metadata": {}, + "outputs": [], + "source": [ + "from huggingface_hub import HfApi" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "167062d2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f64faaf886b47e483da57cac528c88f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Recovering from metadata files: 0%| | 0/6920 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TagCount
5E1P-Cozy1405
7P2Warm1273
11E2P-Energetic1128
2P2Cold1103
12E4N-Unpleasant1031
13E4P-Pleasant1015
0E3P-Harmonic1001
16E3N-Chaotic980
14P4Dynamic956
8P1Soft928
15E1N-Risky888
9P3Delicate878
3P5Static872
6E2N-Dull845
4P1Hard844
1P3Rough811
10P3Smooth784
\n", + "" + ], + "text/plain": [ + " Tag Count\n", + "5 E1P-Cozy 1405\n", + "7 P2Warm 1273\n", + "11 E2P-Energetic 1128\n", + "2 P2Cold 1103\n", + "12 E4N-Unpleasant 1031\n", + "13 E4P-Pleasant 1015\n", + "0 E3P-Harmonic 1001\n", + "16 E3N-Chaotic 980\n", + "14 P4Dynamic 956\n", + "8 P1Soft 928\n", + "15 E1N-Risky 888\n", + "9 P3Delicate 878\n", + "3 P5Static 872\n", + "6 E2N-Dull 845\n", + "4 P1Hard 844\n", + "1 P3Rough 811\n", + "10 P3Smooth 784" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Analyze tag distribution from folder names separated by underscores\n", + "import os\n", + "from collections import Counter\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from IPython.display import display\n", + "\n", + "# Image folder path\n", + "image_root = 'image'\n", + "\n", + "# List of source folders\n", + "sources = [d for d in os.listdir(image_root) if os.path.isdir(os.path.join(image_root, d))]\n", + "\n", + "def get_tag_counts(image_root, sources):\n", + " tag_counter = Counter()\n", + " for source in sources:\n", + " source_path = os.path.join(image_root, source)\n", + " if not os.path.isdir(source_path):\n", + " continue\n", + " for label_folder in os.listdir(source_path):\n", + " label_path = os.path.join(source_path, label_folder)\n", + " if not os.path.isdir(label_path):\n", + " continue\n", + " # Split tags by underscore\n", + " tags = label_folder.split('_')\n", + " # Count image files\n", + " img_count = len([f for f in os.listdir(label_path) if f.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp', '.gif'))])\n", + " for tag in tags:\n", + " tag_counter[tag] += img_count\n", + " return tag_counter\n", + "\n", + "tag_counter = get_tag_counts(image_root, sources)\n", + "\n", + "tag_df = pd.DataFrame(tag_counter.items(), columns=[\"Tag\", \"Count\"]).sort_values(by=\"Count\", ascending=False)\n", + "display(tag_df)\n", + "\n", + "plt.figure(figsize=(14, 6))\n", + "plt.bar(tag_df[\"Tag\"], tag_df[\"Count\"], color='skyblue')\n", + "plt.xticks(rotation=45, ha='right')\n", + "plt.title(\"Image Count per Tag (from folder names)\")\n", + "plt.xlabel(\"Tag\")\n", + "plt.ylabel(\"Image Count\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5b619924", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\3116535003.py:5: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=tag_df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Alternative visualization with Seaborn (English title, slanted tags)\n", + "import seaborn as sns\n", + "\n", + "plt.figure(figsize=(16, 7))\n", + "sns.barplot(x=\"Tag\", y=\"Count\", data=tag_df, palette=\"viridis\")\n", + "plt.xticks(rotation=45, ha='right')\n", + "plt.title(\"Image Count per Tag (Seaborn style)\")\n", + "plt.xlabel(\"Tag\")\n", + "plt.ylabel(\"Image Count\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "44ae616a", + "metadata": {}, + "source": [ + "## 태그별 이미지 개수 분석 및 시각화 결과\n", + "\n", + "- 아래 표와 그래프는 현재 이미지 폴더 내 각 태그별 이미지 개수를 보여줍니다.\n", + "- 태그는 폴더명에서 _로 구분하여 자동 추출되며, 폴더 구조가 추가되어도 자동으로 반영됩니다.\n", + "- Custom Vision 등 데이터셋 균형 확인 및 관리에 활용할 수 있습니다." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6325abc1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TagCount
5E1P-Cozy1405
7P2Warm1273
11E2P-Energetic1128
2P2Cold1103
12E4N-Unpleasant1031
13E4P-Pleasant1015
0E3P-Harmonic1001
16E3N-Chaotic980
14P4Dynamic956
8P1Soft928
15E1N-Risky888
9P3Delicate878
3P5Static872
6E2N-Dull845
4P1Hard844
1P3Rough811
10P3Smooth784
\n", + "
" + ], + "text/plain": [ + " Tag Count\n", + "5 E1P-Cozy 1405\n", + "7 P2Warm 1273\n", + "11 E2P-Energetic 1128\n", + "2 P2Cold 1103\n", + "12 E4N-Unpleasant 1031\n", + "13 E4P-Pleasant 1015\n", + "0 E3P-Harmonic 1001\n", + "16 E3N-Chaotic 980\n", + "14 P4Dynamic 956\n", + "8 P1Soft 928\n", + "15 E1N-Risky 888\n", + "9 P3Delicate 878\n", + "3 P5Static 872\n", + "6 E2N-Dull 845\n", + "4 P1Hard 844\n", + "1 P3Rough 811\n", + "10 P3Smooth 784" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 태그별 개수 표로 안내\n", + "from IPython.display import display\n", + "\n", + "display(tag_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "093c62f3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TagCountSource
0E1P-Cozy525augmented_images
1P3Smooth406augmented_images
2P1Hard344augmented_images
3P1Soft285augmented_images
4E2N-Dull268augmented_images
............
66E4N-Unpleasant133unsplash_images
67E3N-Chaotic132unsplash_images
68P4Dynamic123unsplash_images
69P3Delicate90unsplash_images
70P5Static23unsplash_images
\n", + "

71 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " Tag Count Source\n", + "0 E1P-Cozy 525 augmented_images\n", + "1 P3Smooth 406 augmented_images\n", + "2 P1Hard 344 augmented_images\n", + "3 P1Soft 285 augmented_images\n", + "4 E2N-Dull 268 augmented_images\n", + ".. ... ... ...\n", + "66 E4N-Unpleasant 133 unsplash_images\n", + "67 E3N-Chaotic 132 unsplash_images\n", + "68 P4Dynamic 123 unsplash_images\n", + "69 P3Delicate 90 unsplash_images\n", + "70 P5Static 23 unsplash_images\n", + "\n", + "[71 rows x 3 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\2269313953.py:27: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\2269313953.py:27: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAJOCAYAAADMCCWlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqN1JREFUeJzs3Qec1MX5+PGhgwUQFBC7sSv2hhq7YomxEHtBJVZsqKhYELtiDdboT7FE7CWKiiJ2QcWOGrHEBBMFVAQEAwjs//UZ/7N8d28PKQe3x37er9d53u7esTf3LTPPPPNMvVwulwuSJEmSJEmSpLJQv7bfgCRJkiRJkiRpJoO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJqgi9e/cO9erVq+23oQq27bbbxg9JkqTfYtBWkiT9pjvvvDMGu95+++2wsJswYUK44IILwnrrrRcWW2yx0KxZs7DOOuuEM888M3zzzTehHDz99NMxAFmXAqW/9VFXA1nfffddOPnkk8Maa6wRj5U2bdqETTfdNB4vEydODJXkX//61yz/xpdffnmtvK/hw4eHP/3pT2GFFVYITZs2Dcsss0zYaaedwvXXXz9XP69///7huuuuq/H3KUmSlFUvl8vlCh6RJEkqEbQ94ogjwrBhw8LGG28cFlb//Oc/w4477hhGjhwZ9t1337DVVluFxo0bhw8//DDcd999oVWrVuGzzz6r7bcZTjjhhHDjjTeGutCNo+34SAhkHnfccWHvvfcO++yzT/7xtm3bxkDa/DRt2rT4QeCuJowdOzZssMEGMdB/5JFHxsDtDz/8EH/fAQMGxM8rrrhiqKSg7UorrRQOPPDAsNtuu1V5nrZae+21F+h7GjJkSNhuu+3C8ssvH7p06RLatWsXvv766/DGG2+EL7/8MnzxxRdz/DP/8Ic/hI8++ij+vnNq6tSp8TPXFUmSpFlpOMtnJUmSKgTBPIKIo0ePDi+99FIM2GZdcskl4Yorrqi191cX2m/GjBlVglHrrrtu/Ei+//77GLTlsUMOOWSBvseGDRvGj5py++23xwD/66+/HrbYYouC5wjkLujAXHV/gwVtww03XOB/2+pw3rZo0SJOOLVs2bLguTFjxizw91PbfxtJklR3WB5BkiTNlcMPPzyWDyBoReYZ/8+yYzJA05Lk7bffPiy66KJxWTJLiouzFE8//fTQoUOH+L3NmzcPu+66a/jggw+q/Fv//ve/wx//+Mf4s1h+3r179/Dss8/GJdcEWLPefPPNsMsuu8RAzSKLLBK22WabGFT7LY888kj8t88555wqAVvw/ggAZT300ENho402isvil1xyyRio+u9//ztbNSxpv2wWZlpaftVVV4Vbb701/O53vwtNmjQJm2yySQw4Zb8vtXF26fms8O/wN3ruuefC+uuvHzNN11prrfDoo49Wee24cePCKaecEpZbbrn476+yyioxWE0wsNR7ZZl4eq+ffPJJmBv8fY8//viw+uqrx7Zs3bp1zHQulclI9ip/U1637LLLhosvvjj069cvvp/fynwsVdOWr8lcfvzxx2MZDH4PskEHDhz4m++bTM0GDRqEzTffvOTxUpzRO7+Ol1J/g08//TTst99+Yamllor/Hm3LsZ3Fv02GMFnO6fe+4447qvzbnOP8vJqUjknOX7L3eY9cC9L5zLHJ17Qhbfbee+9V+RkvvPBC+P3vfx+vCwRk99xzz/CPf/yjyt+I36s4YAuuJcX+9re/5f9GZNYfcMABMTM34W/z1FNPxWM2nXtzkk1d/Pfl9+VnPPjgg7EsC9fQxRdfPJZzGD9+fJgyZUo8H3mvXCdZ8cBjWRz/XGt5DX9Hzu2bb765yr/NOcw50L59+3htJAOZ44X3z/E1p9cB3H///bG9eM8c8/zN/vKXv8x2e0iSpOqZaStJkuba9OnTY6B16623Dn369An33ntvDIARRCFAdPDBB8fs1VtuuSUcdthhoWPHjnH5dCpFQKCM4ByPkeH617/+NQbkCCQQWMCkSZNiQOLbb7+NtUNZ3kwA+MUXXywZxOH9EEQ4//zzQ/369fMBjVdffTXWGq3OE088ET8feuihc1QygqDqZZddFt8/wQoCxASYSgWJZge/208//RSOOeaYGMyhXWlD2qtRo0bxcWrrDho0KNxzzz2z/XM///zzsP/++4djjz02LhOnXWh7gpOpLMHPP/8c259gHv8OS8pZXt6zZ8/Y/sV1PPkZkydPDkcffXQM7BDkmhsEpfl3CJARiCUgSdCJ4BbHAgEm8L4INNEuvCeOs//7v/+L//a8eO2112KQkMAxwae+ffuGzp07x2AlAeTqMBnBOcDfgTatjeOl1N+AwDbBTI4XHicoR/DyySefzE888O8TbE5Ba4K7zzzzTOjatWvMEiZgl3Duvvzyy7NdjoPjiIzqYvyO2UxnShMcdNBB8VgjgE0Aeo899ojXi7PPPjv+PUB7EYAeMWJEPKfx/PPPx3N95ZVXjoHI//3vf7FG7ZZbbhnefffdfCCVv9HQoUNjOQOC8rNC25x33nnx3/rzn/8c6xXzM7m+pb8R1zWCqf/5z3/CtddeG7+PYOq84nckUHzWWWfFduHf5e/H7/vjjz/G35GSDhxHXC979eqV/17OFQLTTGzRvvydaTsCrN26dcu/jnOG6wlt3KlTpzhJxWeOn6zZvQ5wDaIUxg477JBfhUDQnGOaa7UkSZpH1LSVJEmalX79+hGtyQ0bNiz/WJcuXeJjl156af6xH3/8MdesWbNcvXr1cvfff3/+8U8//TS+9vzzz88/Nnny5Nz06dML/p2vvvoq16RJk9yFF16Yf+zqq6+O3/v444/nH/vf//6XW2ONNeLjL774YnxsxowZuVVXXTXXqVOn+P/Jzz//nFtppZVyO+200yx/xw022CDXokWL2WqPqVOn5tq0aZNbZ5114ntJBgwYEN9Tr1698o9ts8028aMY7bfCCisU/O58b+vWrXNjx47NP/73v/89Pv7kk0/mH+vWrVt8bHbx7/D6Rx55JP/Y+PHjc0svvXT8vZOLLroot+iii+Y+++yzgu8/66yzcg0aNMiNHDmy4L02b948N2bMmNyc+O6776ocC/yNig0dOjS+7u67784/duKJJ8Zj67333ss/9sMPP+RatWoVX8v7mhX+zeJ24+vGjRvnvvjii/xjH3zwQXz8+uuvn+XPGzVqVG6ppZaKr+V4PPbYY3P9+/fPjRs3boEdL6X+BltvvXVu8cUXz/373/8ueDx7XnTt2jX+/b///vuC1xxwwAHxPMj+TXg/s3O8pfdU3Qd/0+JjcsiQIfnHnn322fgY15Dse//rX/9acK5j/fXXj23K3z/7d6tfv37usMMOyz/23HPPxWOXj44dO+bOOOOM+O/wN8n617/+FV9zySWXFDw+fPjwXMOGDQse33333Qv+FnOi+O/L78TvxrGRfU8HHnhgPNZ33XXXgu/ndyj+t0udP1wHV1555YJjld9jr732Knhd796947/P8TWn14GTTz45Hn/Tpk2bi5aQJEm/xfIIkiRpnpCRlpCJxjJsMiDJVkt4jOfIFk3ICkxZc2QrsoETGWu8lky5hExQlgyTRZawZPqoo44qeB/vv/9+zCYlc4+fRaYfH2Tqkgn2yiuvVFnam0V2IVmWs+Ptt9+O9TDJZssugd99993jZlQsn55bZMMuscQS+a/JmES27eYGmcts/pWwlJkMSjIIR40alV++z7/Hv5/ajw82Z+NvRBtmkY1Khua8IsMw+eWXX+Lfj+XYHDPFxwLZ2pR4SMgsJaN7XvD7UV4god4u7fNbbU5ZAbIVyV4mG5IMUY4/lqlfdNFF+czU+Xm8FP8NyA7l70TZAzIks1JpCN4X5UDIuOT/s39rMi/JJM22O0v452TTO7J7ycIs/mDZfhZf8/dMNttss/iZzPjse0+Pp78H2Z6c7yzpz2Z383cja/zpp5/OP8bXZNpy/eBvRaYpvyPXlJRdDzKtuT5w3cq2B5n9q666asnM/prEuUhmbfZ3ps35O2bxOOUaqF9c6vzhb8f7JlOW9uJrDB48OH5Pyl5OTjzxxCrvZXavA5yfXF/520qSpJpneQRJkjTXCEAVB+2oJcsS9+LaoTxOYCshQMLy8Jtuuil89dVXMRiQZJekUzuSgFrxzyOol0XAFrNapk4AIxsQzZqdIF32PYEAczGCcCy3n1vFgbb0frNtNzdor+I2XG211eJnyhEQnKINWVpfXSC2eOOmVOpiXrG0neXhLPVnSXY2QJiCTqnds0G+6o6FeW3z1O6z0+ZLL710XJ7OcUz7UWuZpeIsX+c5JjXm5/FS/DdIx/CsSgEQ2KVmKbWT+ShlXjbpIshJgG9O251rBKijWurx9PeYVXuuueaa8W9AMJHJI1CSgqDs1KlTY+D2sccei6UNqBtL8JfgMX87jjveeynZgOr8MCdtwbWT8yJdJylHQDkYgtOUNsjidXxParPic4Wgd/E1cXavAwSAqcVLmQqC4DvvvHMMelNTXJIkzTuDtpIkaa6xCdOcPJ4Nxl166aWxfiSZZGQlEjwg85ZamrPKiK1O+p4rr7yyIBMza1a1JwmekXVKFltxoGReECgtlaWYDVLPadvNL7QhmYlnnHFGyedTkLdUht+8INuPgC1/e4KyBJloN2rczs2xMKdqos15v7QPH2TQEvyjxnM2E31+HC9z8zdIbUod2eomOchaLefrx9xo3LhxDODywd+JGsNklRLwpE1oe+r6lvr3a6Ju7fxoC2oVs5KA69c111wTr138nmQbE5ie22vp7FwHyCgn6E2QnHbjg/OYrOG77rprjv9dSZJUyKCtJEmqFQ8//HDcVOr2228veJwMwCWXXDL/NRsJsRkVQYpspiib9WSl5e1kzM5Oll8xlorfd999cfd4NtyZFd4T2BiJpdxZPJaeB1lspTJ4U+bb3CjOmJ0dtFdxG3722Wfxc9q0iTacOHHiXLXfvB4LBA+vvvrq/GNsjsSxkEW7Fv/dUeqx2sTmWPzdWca/oI8X/m2w8VZ1yKCkFAiB4AX9t64J2fYs9umnn8brR8qyrc7GG28cP6e/Ecc+5weZy8WTEzVx/s0vbDo2ZcqUWOohm61bXM4htRnnSjY7m1IkxRnlc3IdIEDMtZMPgr1k37KhJBNy85oBL0lSpbOmrSRJqhVkkBVnzpH1xvL4LOpP8li2/iQBvdtuu63gdRtttFEMNrADPQGHUkvCZ4Wl0h06dIg7yLPMuNhPP/0Ud45PAR+yzKhhSsAkIdOM3dPJtEx4TwSSsv8+S7RZ0jy3UkCqOKg5K998801cFp6t4Xv33XfHrGRKI4ClzfzuZM4V49/K1tGc38fC9ddfXyW7lGOB90d2XzJ27NiY0Vob3nzzzbgMv9hbb70Vg2Fp+f6CPF4IyG699dbhjjvuCCNHjix4LrUx7U0tXOralgruFp8r/BzeU7mg7ATHLdmc2XOA3+W5554Lu+22W0HwslSGbqp7m/5G++yzT2yXCy64oMrr+Zq/Z/b8y5btqE0pE7e4pAgZr1lk4zZs2DCW8si64YYbqvzM2b0OZNsErJRIGdrZ41ySJM0dM20lSVKt+MMf/hAuvPDCuER5iy22CMOHD4/Bt5QpmBxzzDExsHDggQeGk08+OQZseF3a0CllvREw+L//+79YX3HttdeOP5c6iwR8CdyQgUtWWnWoWUndS7LLCHoRuNhyyy3j4x9//HHo379/zIIkqMtj1C3l32DDH97b6NGjY41esla7d++e/7mUf2DZMgHHrl27xnqQBO94jwRO5wYBapx00knx5xK4oZTArJA9yL8/bNiwuIEWQT3ecza406NHjxgc52/DJk/8OwQl+duQDUvt22wWdE3h37vnnntiWQTqixIwev755wtqG4Pl2mRCs3SbkgoEz/ibk2FI8HZBZ0DynjkW2eCNtiLrkCAsbcvxefbZZ8fXLejjpW/fvmGrrbYKG264YdwUjMxK/nZseJYC3pdffnk8L9jYik39aHfakA3IaHv+P2G5+8svvzzb5Qn4GfydihGQLlWTeG5QBoVznZ9HO1EXmUA/x1Dv3r3zr+M4oc4rfyNKCFDXdsiQIeGBBx6Ibc/fJL23iy++OGbZ01Z77bVXzEam3jaTHbTj6aefHl/L35rvP/XUU2OpBUonkGlaG6gjm7JduVYyYcWEFpMEKYsYnPNcP8lmZ1M26s4yGcDEAed09tyZ3esApT84Tsgep4452eD8DQioU1tYkiTNo5wkSdJv6NevH9Ga3LBhw/KPdenSJbfoootWee0222yTW3vttas8vsIKK+R23333/NeTJ0/OnXbaabmll14616xZs9yWW26ZGzp0aPx+PrL++c9/xu/ldUsttVT8vkceeSS+pzfeeKPgte+9915un332ybVu3TrXpEmT+O/ut99+ucGDB8/W7/rjjz/mevXqlevQoUNukUUWyTVt2jS3zjrr5Hr27Jn79ttvC177wAMP5DbYYIP477Rq1Sp38MEH5/7zn/9U+Zl/+9vfciuvvHKucePGufXXXz/37LPPxvbjvSVfffVV/H2uvPLKKt/P4+eff37+62nTpuVOPPHE2Bb16tWLz89Kanv+3XXXXTe+3zXWWCP30EMPVXntTz/9FH/XVVZZJb7fJZdcMrfFFlvkrrrqqtzUqVN/873+lu+++67K70ObH3HEEfHfWmyxxXKdOnXKffrpp/F9007Ff9/f//738XdYdtllc5dddlmub9++8WeOGjVqlv82/2ZxW/F1t27dSrZZ8b9d7MMPP8z16NEjt+GGG8a/f8OGDePxvO++++befffdKq9fUMcLPvroo9zee++da9myZTyGV1999dx5551X8JrRo0fH33255ZbLNWrUKNeuXbvcDjvskLv11lsLXsf5ODvDhvSeqvvItmfx9WBWf4/qftfnn38+Xje4LjRv3jy3xx575D755JOC1zzzzDO5I488Mh7vHFu0Kcc25w+/fzGuK1tttVW8tvHB9/F+RowYkX/NxIkTcwcddFBsW95X9u/yW4qvby+++GL8GcXnYqlrbvYY5jxKnnjiiXhe83deccUVc1dccUXujjvuiK+j7bLXDY4B/s602fbbb5/7xz/+Ea+Vxx577BxfBx5++OHczjvvnGvTpk18zfLLL5875phjqlwnJUnS3KnHf+Y18CtJkrSgXXfddTFD8T//+U/MqFX1yChcZ511woABA8LCiA3MqKNJlmF1GzdJCiXLHbCCgCzjVP5FkiSVB2vaSpKkssfS5yxq2hKkW3XVVQ3YVvixQF1NyhRQDsCArTT7506a/MK2225bC+9IkiTNijVtJUlS2WOTIOqWUiuRTXaol8nGSLW1AZVqDzVMCTBRM5O6sLfffnus9cpu9VJtYfO24o3zsqg726pVq1CbqMN75513xo3aqMP72muvhfvuuy/WxaV+tyRJKi8GbSVJUtljUyY2nCJIS2CETZPuv//+sP/++9f2W9MCRsCJzZBuvfXWuHkSm20RuGXzOKm2sCEZG3FVhw3oXnrppVCb1l133dCwYcPQp0+fONGRNiejNIIkSSo/1rSVJEmSpHnw+uuvlyw/kFA3dqONNlqg70mSJNVtBm0lSZIkSZIkqYy4EZkkSZIkSZIklRFr2oYQZsyYEb755puw+OKLx9pokiRJkiRJklTTKHrw008/hfbt24f69avPpzVoG0IM2C633HK1/TYkSZIkSZIkVYCvv/46LLvsstU+b9A2hJhhmxqrefPmtf12JEmSJEmSJC2EJkyYEJNHUzyyOgZt2Y3t/5dEIGBr0FaSJEmSJEnS/PRbJVrdiEySJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIw1r+w3UFZ1WPry230JZePafd87T9+++Sfcaey912VPDrq3ttyBJkiRJkqQyZaatJEmSJEmSJJURg7aSJEmSJEmSVEYM2kqSJEmSJElSGTFoK0mSJEmSJEllxKCtJEmSJEmSJJURg7aSJEmSJEmSVEYM2kqSJEmSJElSGTFoK0mSJEmSJEllxKCtJEmSJEmSJJWRhrX9BiTNuT90Ore230JZGPDsxbX9FiRJkiRJkmqcmbaSJEmSJEmSVEYM2kqSJEmSJElSGTFoK0mSJEmSJEllxKCtJEmSJEmSJJURg7aSJEmSJEmSVEYM2kqSJEmSJElSGTFoK0mSJEmSJEllpFaDttOnTw/nnXdeWGmllUKzZs3C7373u3DRRReFXC6Xfw3/36tXr7D00kvH1+y4447h888/L/g5Y8eODQcffHBo3rx5aNmyZejatWuYOHFiLfxGkiRJkiRJklSHg7ZXXHFFuPnmm8MNN9wQ/vGPf8Sv+/TpE66//vr8a/i6b9++4ZZbbglvvvlmWHTRRUOnTp3C5MmT868hYPvxxx+HQYMGhQEDBoRXXnklHH300bX0W0mSJEmSJEnS3GsYatGQIUPCnnvuGXbffff49Yorrhjuu+++8NZbb+WzbK+77rpw7rnnxtfh7rvvDm3btg2PP/54OOCAA2Kwd+DAgWHYsGFh4403jq8h6LvbbruFq666KrRv374Wf0NJkiRJkiRJqkOZtltssUUYPHhw+Oyzz+LXH3zwQXjttdfCrrvuGr/+6quvwqhRo2JJhKRFixZhs802C0OHDo1f85mSCClgC15fv379mJkrSZIkSZIkSXVJrWbannXWWWHChAlhjTXWCA0aNIg1bi+55JJY7gAEbEFmbRZfp+f43KZNm4LnGzZsGFq1apV/TbEpU6bEj4T3IEmSJEmSJEmh0jNtH3zwwXDvvfeG/v37h3fffTfcddddsaQBn+enyy67LGbspo/llltuvv57kiRJkiRJklQngrY9evSI2bbUpu3QoUM49NBDQ/fu3WNQFe3atYufR48eXfB9fJ2e4/OYMWMKnp82bVoYO3Zs/jXFevbsGcaPH5//+Prrr+fTbyhJkiRJkiRJdSho+/PPP8fas1mUSZgxY0b8/5VWWikGXql7my1lQK3ajh07xq/5PG7cuPDOO+/kX/PCCy/En0Ht21KaNGkSmjdvXvAhSZIkSZIkSaHSa9rusccesYbt8ssvH9Zee+3w3nvvhWuuuSYceeSR8fl69eqFU045JVx88cVh1VVXjUHc8847L7Rv3z7stdde8TVrrrlm2GWXXcJRRx0VbrnllvDLL7+EE044IWbv8jpJkiRJkiRJqktqNWh7/fXXxyDs8ccfH0scEGQ95phjQq9evfKvOeOMM8KkSZPC0UcfHTNqt9pqqzBw4MDQtGnT/Guoi0ugdocddoiZu507dw59+/atpd9KkiRJkiRJkuZevVwulwsVjpILbEhGfdvqSiV0WvnwBf6+ytGz/7xznr5/902619h7qcueGnbtPH3/HzqdW2PvpS4b8OzFtf0WJEmSJEmSajQOWes1bSVJkiRJkiRJhQzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZMWgrSZIkSZIkSWXEoK0kSZIkSZIklRGDtpIkSZIkSZJURgzaSpIkSZIkSVIZqdWg7Yorrhjq1atX5aNbt27x+cmTJ8f/b926dVhsscVC586dw+jRowt+xsiRI8Puu+8eFllkkdCmTZvQo0ePMG3atFr6jSRJkiRJkiSpDgdthw0bFr799tv8x6BBg+Lj++67b/zcvXv38OSTT4aHHnoovPzyy+Gbb74J++yzT/77p0+fHgO2U6dODUOGDAl33XVXuPPOO0OvXr1q7XeSJEmSJEmSpHnRMNSipZZaquDryy+/PPzud78L22yzTRg/fny4/fbbQ//+/cP2228fn+/Xr19Yc801wxtvvBE233zz8Nxzz4VPPvkkPP/886Ft27Zh/fXXDxdddFE488wzQ+/evUPjxo1r6TeTVBd0+tMFtf0WysKzD59f229BkiRJkiSVY01bsmX/9re/hSOPPDKWSHjnnXfCL7/8Enbcccf8a9ZYY42w/PLLh6FDh8av+dyhQ4cYsE06deoUJkyYED7++ONq/60pU6bE12Q/JEmSJEmSJKkclE3Q9vHHHw/jxo0Lhx9+ePx61KhRMVO2ZcuWBa8jQMtz6TXZgG16Pj1Xncsuuyy0aNEi/7HccsvNh99IkiRJkiRJkupw0JZSCLvuumto3779fP+3evbsGcsvpI+vv/56vv+bkiRJkiRJklT2NW2Tf//737Eu7aOPPpp/rF27drFkAtm32Wzb0aNHx+fSa956662Cn8Xz6bnqNGnSJH5IkiRJkiRJUrkpi0xbNhhr06ZN2H333fOPbbTRRqFRo0Zh8ODB+cdGjBgRRo4cGTp27Bi/5vPw4cPDmDFj8q8ZNGhQaN68eVhrrbUW8G8hSZIkSZIkSQtBpu2MGTNi0LZLly6hYcOZb4das127dg2nnnpqaNWqVQzEnnjiiTFQu/nmm8fX7LzzzjE4e+ihh4Y+ffrEOrbnnntu6Natm5m0kiRJkiRJkuqkWg/aUhaB7NkjjzyyynPXXnttqF+/fujcuXOYMmVK6NSpU7jpppvyzzdo0CAMGDAgHHfccTGYu+iii8bg74UXXriAfwtJkiRJkiRJWkiCtmTL5nK5ks81bdo03HjjjfGjOiussEJ4+umn5+M7lCRJkiRJkqQKq2krSZIkSZIkSfqVQVtJkiRJkiRJKiMGbSVJkiRJkiSpjNR6TVtJUt223eEX1fZbKAsv3nlebb8FSZIkSdJCwkxbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIkqYwYtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojtR60/e9//xsOOeSQ0Lp169CsWbPQoUOH8Pbbb+efz+VyoVevXmHppZeOz++4447h888/L/gZY8eODQcffHBo3rx5aNmyZejatWuYOHFiLfw2kiRJkiRJklSHg7Y//vhj2HLLLUOjRo3CM888Ez755JNw9dVXhyWWWCL/mj59+oS+ffuGW265Jbz55pth0UUXDZ06dQqTJ0/Ov4aA7ccffxwGDRoUBgwYEF555ZVw9NFH19JvJUmSJEmSJElzr2GoRVdccUVYbrnlQr9+/fKPrbTSSgVZttddd10499xzw5577hkfu/vuu0Pbtm3D448/Hg444IDwj3/8IwwcODAMGzYsbLzxxvE1119/fdhtt93CVVddFdq3b18Lv5kkSZIkSZIk1cFM2yeeeCIGWvfdd9/Qpk2bsMEGG4Tbbrst//xXX30VRo0aFUsiJC1atAibbbZZGDp0aPyaz5RESAFb8Pr69evHzNxSpkyZEiZMmFDwIUmSJEmSJEmh0jNt//nPf4abb745nHrqqeHss8+O2bInnXRSaNy4cejSpUsM2ILM2iy+Ts/xmYBvVsOGDUOrVq3yryl22WWXhQsuuGC+/V6SJM2NLY+/KFS61286r7bfgiRJkiRVdqbtjBkzwoYbbhguvfTSmGVLHdqjjjoq1q+dn3r27BnGjx+f//j666/n678nSZIkSZIkSXUiaLv00kuHtdZaq+CxNddcM4wcOTL+f7t27eLn0aNHF7yGr9NzfB4zZkzB89OmTQtjx47Nv6ZYkyZNQvPmzQs+JEmSJEmSJClUetB2yy23DCNGjCh47LPPPgsrrLBCflMyAq+DBw/OP0/9WWrVduzYMX7N53HjxoV33nkn/5oXXnghZvFS+1aSJEmSJEmS6pJarWnbvXv3sMUWW8TyCPvtt1946623wq233ho/UK9evXDKKaeEiy++OKy66qoxiHveeeeF9u3bh7322iufmbvLLrvkyyr88ssv4YQTTggHHHBAfJ0kSZIkSZIk1SW1GrTdZJNNwmOPPRZrzF544YUxKHvdddeFgw8+OP+aM844I0yaNCnWuyWjdquttgoDBw4MTZs2zb/m3nvvjYHaHXbYIdSvXz907tw59O3bt5Z+K0mSJEmSJEmqo0Fb/OEPf4gf1SHbloAuH9Vp1apV6N+//3x6h5IkSZIkSZJUITVtJUmSJEmSJEmFDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklSXg7bbb799GDduXJXHJ0yYEJ+TJEmSJEmSJC3AoO1LL70Upk6dWuXxyZMnh1dffXUe3ookSZIkSZIkqeHsvvDDDz/M//8nn3wSRo0alf96+vTpYeDAgWGZZZap+XcoSZIkSZIkSRVktoO266+/fqhXr178KFUGoVmzZuH666+v6fcnSZIkSZIkSRVltoO2X331VcjlcmHllVcOb731VlhqqaXyzzVu3Di0adMmNGjQYH69T0mSJEmSJEmqCLMdtF1hhRXi5xkzZszP9yNJkiRJkiRJFW22g7ZZn3/+eXjxxRfDmDFjqgRxe/XqVVPvTZIkSZIkSZIqzhwHbW+77bZw3HHHhSWXXDK0a9cu1rhN+H+DtpIkqTZtevpFodK9ddV58/wzNuh1QY28l7ruvQvPr+23IEmSpAo0x0Hbiy++OFxyySXhzDPPnD/vSJIkSZIkSZIqWP05/YYff/wx7LvvvvPn3UiSJEmSJElShZvjoC0B2+eee27+vBtJkiRJkiRJqnBzXB5hlVVWCeedd1544403QocOHUKjRo0Knj/ppJNq8v1JkiRJkiRJUkWZ40zbW2+9NSy22GLh5ZdfDjfccEO49tpr8x/XXXfdHP2s3r17x83Lsh9rrLFG/vnJkyeHbt26hdatW8d/s3PnzmH06NEFP2PkyJFh9913D4ssskho06ZN6NGjR5g2bdqc/lqSJEmSJEmSVDczbb/66qsafQNrr712eP7552e+oYYz31L37t3DU089FR566KHQokWLcMIJJ4R99tknvP766/H56dOnx4Btu3btwpAhQ8K3334bDjvssJj9e+mll9bo+5QkSZIkSZKksgza1vgbaNgwBl2LjR8/Ptx+++2hf//+Yfvtt4+P9evXL6y55pqxNMPmm28ea+t+8sknMejbtm3bsP7664eLLroonHnmmTGLt3HjxrXwG0mSJEmSJEnSAgzaHnnkkbN8/o477pijn/f555+H9u3bh6ZNm4aOHTuGyy67LCy//PLhnXfeCb/88kvYcccd86+ldALPDR06NAZt+UxdXQK2SadOncJxxx0XPv7447DBBhvM6a8nSZIk1Zj1ruhd22+hLHxwpu0gSZI0X4O2P/74Y8HXBFY/+uijMG7cuHxG7OzabLPNwp133hlWX331WNrgggsuCL///e/jzxs1alTMlG3ZsmXB9xCg5TnwORuwTc+n56ozZcqU+JFMmDBhjt63JEmSJEmSJJVN0Paxxx6r8tiMGTNiduvvfve7OfpZu+66a/7/11133RjEXWGFFcKDDz4YmjVrFuYXsnkJEEuSJEmSJElSualfIz+kfv1w6qmnhmuvvXaefg5Ztauttlr44osvYp3bqVOnxgzerNGjR+dr4PKZr4ufT89Vp2fPnrFmbvr4+uuv5+l9S5IkSZIkSVJZBW3x5ZdfhmnTps3Tz5g4cWL8OUsvvXTYaKONQqNGjcLgwYPzz48YMSKMHDky1r4Fn4cPHx7GjBmTf82gQYNC8+bNw1prrVXtv9OkSZP4muyHJEmSJEmSJNXJ8ghk1GblcrlYj/app54KXbp0maOfdfrpp4c99tgjlkT45ptvwvnnnx8aNGgQDjzwwNCiRYvQtWvX+O+1atUqBlZPPPHEGKhlEzLsvPPOMTh76KGHhj59+sQ6tueee27o1q1bDMxKkiRJkiRJ0kIftH3vvfeqlEZYaqmlwtVXXx2OPPLIOfpZ//nPf2KA9ocffog/Y6uttgpvvPFG/H9QboGf37lz57hxWKdOncJNN92U/34CvAMGDIj1dAnmLrroojFwfOGFF87pryVJkiRJkiRJdTNo++KLL9bYP37//ffP8vmmTZuGG2+8MX5Uhyzdp59+usbekyRJkiRJkiTVqaBt8t1338Uas1h99dXz2bGSJEmSJEmSpAW4EdmkSZNiGQQ2C9t6663jR/v27WP92Z9//nke3ookSZIkSZIkaY6DtmwM9vLLL4cnn3wyjBs3Ln78/e9/j4+ddtpp8+ddSpIkSZIkSVKFmOPyCI888kh4+OGHw7bbbpt/bLfddgvNmjUL++23X7j55ptr+j1KkiRJkiRJUsWY40xbSiC0bdu2yuNt2rSxPIIkSZIkSZIkLeigbceOHcP5558fJk+enH/sf//7X7jgggvic5IkSZIkSZKkBVge4S9/+Uvo1KlTWHbZZcN6660XH/vggw9C06ZNw7PPPjsPb0WSJEmSJEmSNMdB23XWWSd8/vnn4d577w2ffvppfOzAAw8MBx98cKxrK0mSJEmSJElagEFbLLLIIuGoo46ah39WkiRJkiRJkjRPNW3feeedsN1224UJEyZUeW78+PHxOcokSJIkSZIkSZIWQND26quvDttvv31o3rx5ledatGgRdtppp3DllVfOw1uRJEmSJEmSJM120PbNN98Me+65Z7XP77HHHmHIkCE19b4kSZIkSZIkqSLNdtD2v//9b1h88cWrfX6xxRYL3377bU29L0mSJEmSJEmqSLMdtF1qqaXCiBEjqn3+008/DUsuuWRNvS9JkiRJkiRJqkizHbTdcccdwyWXXFLyuVwuF5/jNZIkSZIkSZKkuddwdl947rnnho022ihsttlm4bTTTgurr756PsOWTco+++yzcOedd87DW5EkSZKkqja8qVdtv4Wy8O7xF87T9297z9k19l7qspcOvbS234IkSTUXtP3d734Xnn/++XD44YeHAw44INSrVy+fZbvWWmuFQYMGhVVWWWV2f5wkSZIkSZIkaV6Ctth4443DRx99FN5///3w+eefx4DtaqutFtZff/05+TGSJEmSJEmSpJoI2iYEaQ3USpIkSZIkSVKZBG0lSZIkSapE+z3Ro7bfQll48I9X1vZbkKSFWv3afgOSJEmSJEmSpJkM2kqSJEmSJElSGTFoK0mSJEmSJEl1PWj76quvhkMOOSR07Ngx/Pe//42P3XPPPeG1116r6fcnSZIkSZIkSRVljoO2jzzySOjUqVNo1qxZeO+998KUKVPi4+PHjw+XXnrp/HiPkiRJkiRJklQx5jhoe/HFF4dbbrkl3HbbbaFRo0b5x7fccsvw7rvv1vT7kyRJkiRJkqSKMsdB2xEjRoStt966yuMtWrQI48aNq6n3JUmSJEmSJEkVaY6Dtu3atQtffPFFlcepZ7vyyivX1PuSJEmSJEmSpIo0x0Hbo446Kpx88snhzTffDPXq1QvffPNNuPfee8Ppp58ejjvuuPnzLiVJkiRJkiSpQjSc028466yzwowZM8IOO+wQfv7551gqoUmTJjFoe+KJJ86fdylJkiRJkiRJFWKOg7Zk155zzjmhR48esUzCxIkTw1prrRUWW2yx+fMOJUmSJEmSJKmCzHHQNmncuHEM1kqSJEmSJEmSajFou/fee8ds22I81rRp07DKKquEgw46KKy++uo19R4lSZIkSZIkqWLM8UZkLVq0CC+88EJ49913Y6CWj/feey8+Nm3atPDAAw+E9dZbL7z++uvz5x1LkiRJkiRJ0kJsjjNt27VrFzNpb7jhhlC//q8xXzYmO/nkk8Piiy8e7r///nDssceGM888M7z22mvz4z1LkiRJkiRJ0kJrjjNtb7/99nDKKafkA7bxh9SvH0488cRw6623xszbE044IXz00Uc1/V4lSZIkSZIkaaE3x0FbSiB8+umnVR7nsenTp8f/p7Ztqbq3kiRJkiRJkqQaDtoeeuihoWvXruHaa6+N5Q/44P957LDDDouvefnll8Paa689Rz/38ssvj4FesniTyZMnh27duoXWrVuHxRZbLHTu3DmMHj264PtGjhwZdt9997DIIouENm3ahB49esTAsiRJkiRJkiRVRE1bArRt27YNffr0yQdQ+bp79+6xji123nnnsMsuu8z2zxw2bFj461//GtZdd92Cx/mZTz31VHjooYfiBmiUXdhnn33ym5yR2UvAljq7Q4YMCd9++20MHDdq1Chceumlc/qrSZIkSZIkSVLdy7Rt0KBBOOecc2KAdNy4cfGD/z/77LPjc1h++eXDsssuO1s/b+LEieHggw8Ot912W1hiiSXyj48fPz7Wz73mmmvC9ttvHzbaaKPQr1+/GJx944034muee+658Mknn4S//e1vYf311w+77rpruOiii8KNN94Ypk6dOqe/miRJkiRJkiTVvaBtVvPmzePHvKD8AdmyO+64Y8Hj77zzTvjll18KHl9jjTViQHjo0KHxaz536NAhZvomnTp1ChMmTAgff/zxPL0vSZIkSZIkSaoT5RHw8MMPhwcffDDWky3OaH333Xdn++fcf//98fWURyg2atSo0Lhx49CyZcuCxwnQ8lx6TTZgm55Pz1VnypQp8SMhyCtJkiRJkiRJdTLTtm/fvuGII46IwdH33nsvbLrppnGjsH/+85+xPMHs+vrrr8PJJ58c7r333tC0adOwIF122WWxRm76WG655Rbovy9JkiRJkiRJNRa0vemmm8Ktt94arr/++pgJe8YZZ4RBgwaFk046KdahnV2UPxgzZkzYcMMNQ8OGDePHyy+/HIPC/D9BYbJ4qZmbxeZnbDwGPqfN0LLPp+eq07Nnz/he0wcBZEmSJEmSJEmqk0FbSiJsscUW8f+bNWsWfvrpp/j/hx56aLjvvvtm++fssMMOYfjw4eH999/Pf2y88cZxU7L0/40aNQqDBw/Of8+IESPiv9+xY8f4NZ/5GQR/EwLI1Nlda621qv23mzRpkq/HWxN1eSVJkiRJkiSp1mraksE6duzYsMIKK8RNwd54442w3nrrha+++irkcrnZ/jmLL754WGeddQoeW3TRRWOphfR4165dw6mnnhpatWoVA6snnnhiDNRuvvnm8fmdd945BmcJGPfp0yfWsT333HPj5mYEZiVJkiRJkiRpoQ/abr/99uGJJ54IG2ywQaxt271797gx2dtvvx322WefGn1z1157bahfv37o3Llz3DisU6dOsTxD0qBBgzBgwIBw3HHHxWAuQd8uXbqECy+8sEbfhyRJkiRJkiSVbdCWerYzZsyI/09GK5mxQ4YMCX/84x/DMcccM09v5qWXXir4mg3KbrzxxvhRHTJ+n3766Xn6dyVJkiRJkiSpzgZtyXzlIznggAPihyRJkiRJkiSpFoK2mDx5cvjwww/jBmAp6zYh41aSJEmSJEmStICCtgMHDgyHHXZY+P7776s8V69evTB9+vS5fCuSJEmSJEmSpJl1DmbTiSeeGPbdd9/w7bffxizb7IcBW0mSJEmSJElawEHb0aNHh1NPPTW0bdt2Hv9pSZIkSZIkSdI8B23/9Kc/hZdeemlOv02SJEmSJEmSND9q2t5www2xPMKrr74aOnToEBo1alTw/EknnTSnP1KSJEmSJEmSNLdB2/vuuy8899xzoWnTpjHjls3HEv7foK0kSZIkSZIkzb05Dtqec8454YILLghnnXVWqF9/jqsrSJIkSZIkSZJmYY6jrlOnTg3777+/AVtJkiRJkiRJmg/mOPLapUuX8MADD8yP9yJJkiRJkiRJFW+OyyNMnz499OnTJzz77LNh3XXXrbIR2TXXXFOT70+SJEmSJEmSKsocB22HDx8eNthgg/j/H330UcFz2U3JJEmSJEmSJEkLIGj74osvzsU/I0mSJEmSNNOpL54QKt01291Q229BUplyNzFJkiRJkiRJqouZtvvss89sve7RRx+dl/cjSZIkSZIkSRVttoO2LVq0mL/vRJIkSZIkSZI0+0Hbfv36zd93IkmSJEmSJEmypq0kSZIkSZIklRODtpIkSZIkSZJURgzaSpIkSZIkSVJdrGkrSZIkSZKk8nLlaweHStdjq3tr+y1INc5MW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSykitBm1vvvnmsO6664bmzZvHj44dO4Znnnkm//zkyZNDt27dQuvWrcNiiy0WOnfuHEaPHl3wM0aOHBl23333sMgii4Q2bdqEHj16hGnTptXCbyNJkiRJkiRJdTxou+yyy4bLL788vPPOO+Htt98O22+/fdhzzz3Dxx9/HJ/v3r17ePLJJ8NDDz0UXn755fDNN9+EffbZJ//906dPjwHbqVOnhiFDhoS77ror3HnnnaFXr161+FtJkiRJkiRJ0txrGGrRHnvsUfD1JZdcErNv33jjjRjQvf3220P//v1jMBf9+vULa665Znx+8803D88991z45JNPwvPPPx/atm0b1l9//XDRRReFM888M/Tu3Ts0bty4ln4zSZIkSZIkSarjNW3Jmr3//vvDpEmTYpkEsm9/+eWXsOOOO+Zfs8Yaa4Tll18+DB06NH7N5w4dOsSAbdKpU6cwYcKEfLZuKVOmTImvyX5IkiRJkiRJUjmo9aDt8OHDY73aJk2ahGOPPTY89thjYa211gqjRo2KmbItW7YseD0BWp4Dn7MB2/R8eq46l112WWjRokX+Y7nllpsvv5skSZIkSZIk1bmg7eqrrx7ef//98Oabb4bjjjsudOnSJZY8mJ969uwZxo8fn//4+uuv5+u/J0mSJEmSJEl1oqYtyKZdZZVV4v9vtNFGYdiwYeEvf/lL2H///eMGY+PGjSvIth09enRo165d/H8+v/XWWwU/j+fTc9Uhq5cPSZIkSZIkSSo3tZ5pW2zGjBmx5iwB3EaNGoXBgwfnnxsxYkQYOXJkrHkLPlNeYcyYMfnXDBo0KDRv3jyWWJAkSZIkSZKkuqZWM20pU7DrrrvGzcV++umn0L9///DSSy+FZ599Ntaa7dq1azj11FNDq1atYiD2xBNPjIHazTffPH7/zjvvHIOzhx56aOjTp0+sY3vuueeGbt26mUkrSZIkSZIkqU6q1aAtGbKHHXZY+Pbbb2OQdt11140B25122ik+f+2114b69euHzp07x+zbTp06hZtuuin//Q0aNAgDBgyItXAJ5i666KKxJu6FF15Yi7+VJEmSJEmSJNXRoO3tt98+y+ebNm0abrzxxvhRnRVWWCE8/fTT8+HdSZIkSZIkSdKCV3Y1bSVJkiRJkiSpkhm0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiRJksqIQVtJkiRJkiRJKiMGbSVJkiRJkiSpjNRq0Payyy4Lm2yySVh88cVDmzZtwl577RVGjBhR8JrJkyeHbt26hdatW4fFFlssdO7cOYwePbrgNSNHjgy77757WGSRReLP6dGjR5g2bdoC/m0kSZIkSZIkqY4HbV9++eUYkH3jjTfCoEGDwi+//BJ23nnnMGnSpPxrunfvHp588snw0EMPxdd/8803YZ999sk/P3369BiwnTp1ahgyZEi46667wp133hl69epVS7+VJEmSJEmSJM29hqEWDRw4sOBrgq1kyr7zzjth6623DuPHjw+333576N+/f9h+++3ja/r16xfWXHPNGOjdfPPNw3PPPRc++eST8Pzzz4e2bduG9ddfP1x00UXhzDPPDL179w6NGzeupd9OkiRJkiRJkup4TVuCtGjVqlX8TPCW7Nsdd9wx/5o11lgjLL/88mHo0KHxaz536NAhBmyTTp06hQkTJoSPP/645L8zZcqU+Hz2Q5IkSZIkSZLKQdkEbWfMmBFOOeWUsOWWW4Z11lknPjZq1KiYKduyZcuC1xKg5bn0mmzANj2fnquulm6LFi3yH8stt9x8+q0kSZIkSZIkqY4Gbalt+9FHH4X7779/vv9bPXv2jFm96ePrr7+e7/+mJEmSJEmSJJV9TdvkhBNOCAMGDAivvPJKWHbZZfOPt2vXLm4wNm7cuIJs29GjR8fn0mveeuutgp/H8+m5Upo0aRI/JEmSJEmSJKnc1GqmbS6XiwHbxx57LLzwwgthpZVWKnh+o402Co0aNQqDBw/OPzZixIgwcuTI0LFjx/g1n4cPHx7GjBmTf82gQYNC8+bNw1prrbUAfxtJkiRJkiRJquOZtpRE6N+/f/j73/8eFl988XwNWurMNmvWLH7u2rVrOPXUU+PmZARiTzzxxBio3XzzzeNrd9555xicPfTQQ0OfPn3izzj33HPjzzabVpIkSZIkSVJdU6tB25tvvjl+3nbbbQse79evXzj88MPj/1977bWhfv36oXPnzmHKlCmhU6dO4aabbsq/tkGDBrG0wnHHHReDuYsuumjo0qVLuPDCCxfwbyNJkiRJkiRJdTxoS3mE39K0adNw4403xo/qrLDCCuHpp5+u4XcnSZIkSZIkSRVW01aSJEmSJEmSVMigrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZcSgrSRJkiRJkiSVEYO2kiRJkiRJklRGDNpKkiRJkiRJUhkxaCtJkiRJkiRJZaRWg7avvPJK2GOPPUL79u1DvXr1wuOPP17wfC6XC7169QpLL710aNasWdhxxx3D559/XvCasWPHhoMPPjg0b948tGzZMnTt2jVMnDhxAf8mkiRJkiRJkrQQBG0nTZoU1ltvvXDjjTeWfL5Pnz6hb9++4ZZbbglvvvlmWHTRRUOnTp3C5MmT868hYPvxxx+HQYMGhQEDBsRA8NFHH70AfwtJkiRJkiRJqjkNQy3adddd40cpZNled9114dxzzw177rlnfOzuu+8Obdu2jRm5BxxwQPjHP/4RBg4cGIYNGxY23njj+Jrrr78+7LbbbuGqq66KGbySJEmSJEmSVJfUatB2Vr766qswatSoWBIhadGiRdhss83C0KFDY9CWz5RESAFb8Pr69evHzNy99967lt69JEmSJEmS6or+b+xU22+hLBy0+aDafgsq96AtAVuQWZvF1+k5Prdp06bg+YYNG4ZWrVrlX1PKlClT4kcyYcKEGn73kiRJkiRJklQHa9rWlssuuyxm7aaP5ZZbrrbfkiRJkiRJkiSVd9C2Xbt28fPo0aMLHufr9Byfx4wZU/D8tGnTwtixY/OvKaVnz55h/Pjx+Y+vv/56vvwOkiRJkiRJkrTQBG1XWmmlGHgdPHhwQRkDatV27Ngxfs3ncePGhXfeeSf/mhdeeCHMmDEj1r6tTpMmTULz5s0LPiRJkiRJkiQpVHpN24kTJ4YvvviiYPOx999/P9akXX755cMpp5wSLr744rDqqqvGIO55550X2rdvH/baa6/4+jXXXDPssssu4aijjgq33HJL+OWXX8IJJ5wQNynjdZIkSZIkSZJU19Rq0Pbtt98O2223Xf7rU089NX7u0qVLuPPOO8MZZ5wRJk2aFI4++uiYUbvVVluFgQMHhqZNm+a/5957742B2h122CHUr18/dO7cOfTt27dWfh9JkiRJkiRJqtNB22233Tbkcrlqn69Xr1648MIL40d1yMrt37//fHqHkiRJkiRJkrRglW1NW0mSJEmSJEmqRAZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIwZtJUmSJEmSJKmMGLSVJEmSJEmSpDJi0FaSJEmSJEmSyohBW0mSJEmSJEkqIw3DQuLGG28MV155ZRg1alRYb731wvXXXx823XTT2n5bkiRJkiRJUkV45a2Na/stlIWtN317nn/GQpFp+8ADD4RTTz01nH/++eHdd9+NQdtOnTqFMWPG1PZbkyRJkiRJkqTKC9pec8014aijjgpHHHFEWGuttcItt9wSFllkkXDHHXfU9luTJEmSJEmSpMoK2k6dOjW88847Yccdd8w/Vr9+/fj10KFDa/W9SZIkSZIkSVLF1bT9/vvvw/Tp00Pbtm0LHufrTz/9tOT3TJkyJX4k48ePj58nTJhQ7b8zbcbUGnvPddms2mh2/DJ9ZrtXsnlux2m2Y02047RfJtfYe6nodpxqO9ZEO8K2rJl2nD7FdrQdy6ctp0/2nl0j7fg/27FG7tm2Y830xX+2HWvqXjNlkuPsmmjHyZN+CZWuJtrx50nTauS9VHpbTpo4vcbey8Lajum5XC43y59RL/dbryhz33zzTVhmmWXCkCFDQseOHfOPn3HGGeHll18Ob775ZpXv6d27d7jgggsW8DuVJEmSJEmSpBC+/vrrsOyyyy68mbZLLrlkaNCgQRg9enTB43zdrl27kt/Ts2fPuHFZMmPGjDB27NjQunXrUK9evVCOiMIvt9xy8Q/avHnz2n47dZbtWDNsx5phO9YM27Fm2I41x7asGbZjzbAda4btWDNsx5phO9YM27Hm2JY1w3asnHbM5XLhp59+Cu3bt5/l6+p80LZx48Zho402CoMHDw577bVXPgjL1yeccELJ72nSpEn8yGrZsmWoCzjgyvWgq0tsx5phO9YM27Fm2I41w3asObZlzbAda4btWDNsx5phO9YM27Fm2I41x7asGbZjZbRjixYtfvM1dT5oC7Jmu3TpEjbeeOOw6aabhuuuuy5MmjQpHHHEEbX91iRJkiRJkiRpjiwUQdv9998/fPfdd6FXr15h1KhRYf311w8DBw6ssjmZJEmSJEmSJJW7hSJoC0ohVFcOYWFAOYfzzz+/SlkHzRnbsWbYjjXDdqwZtmPNsB1rjm1ZM2zHmmE71gzbsWbYjjXDdqwZtmPNsS1rhu1YM5osRO1YL0f1W0mSJEmSJElSWahf229AkiRJkiRJkjSTQVtJkiRJkiRJKiMGbSVJkiRJkiSpjBi0lSRJkiRJkqQyYtBWkiRJkiQtNGbMmFHbb6HOc8/6mjFt2rTafguqwwzaSpLqREfRjqPKYfDncShJUvl64oknwldffRXq16/vPXseff/99/GzAfC5d9lll4W+ffuGSZMm1fZbqfNyuVxFntMGbWvJl19+mf//O+64I4wfP75W34+kmpHt1FTiTaUm269evXrx87/+9a8wderU/NeaM3a0awaDP3z99de1/VYWGl4jVU7H4S+//FLbb0XyujiP3n333XDOOeeEnj17hpEjR8a+o206dx588MGw5ZZbhuHDh8c+kP3JuQ98n3766eGee+4xcDuXpk+fHj9nx4NffPFF+OGHH0IlMGhbC15//fVw0EEHhQceeCB07949/PnPfw5jx46t7bdVZ6Ub8SeffBLef/99b8w10I5jxoyp7bdTJ9GZSYEdzu+HH344TJ48ubbfVp1C+/3zn/8Mhx9+ePz6scceC/vss0/seGvejskPP/wwfPvtt7X9luq0AQMGhC222CL85z//qe23UqfvM1OmTIn/70TMnKPdHDjXnHQcDho0KPTp0yf2gTTnsn1v++HzJl0Xb7vttvDGG2/U9tupczbccMNw7LHHhtGjR8fA7b///W8Dt3NpkUUWCSuvvHJsTwO3c+/qq68OvXr1CieccEIM3E6YMKG231Kd89NPP8WPzp07h//973/hySefDNtuu2347rvvQiUwaFsLVltttbD88svHGReybN97772w0kor5WcQNOed7UcffTTssssu4fnnn483Z81dOxIg23XXXcNf//rXMHHixNp+W3VOCo716NEjnHbaaWHcuHFOyMzFsUhwkZvx1ltvHW/OtOUqq6xS22+tTrZlOibPPvvscNxxx4VXX33VWf550KxZs9C8efPwzTffxK8dvMz5feapp54KRxxxRPjjH/8YXn75ZQcvc4g2TOf1iy++GM/pDz74IP+8gYk5k/qQTA7+/PPPoWHDhrX9lursuU0fnCDZ7rvvHu67777w0Ucf1fZbq7P++9//hltvvTW89tpr8WvHiL+Nsctf/vKX+P/dunUL++23X1wZQ//HwO3c+cMf/hDOPPPM0K5du5hk9umnnxq4nUNpBUfv3r1j3+fcc8+NiT2Os2dfjx494sTBc889FwO3m2++eRwfEgxfY401QkXIaYGaNm1a/HzNNdfkFl100dwGG2yQu/fee3PTp0+Pj6fPmn2DBw+ObXnzzTfnxo4dW9tvp8569tlnc82aNcvddtttuX/961+1/XbqlBkzZuT/n/Zr165d7o033ih4XHOmR48euXr16uU222yz/GO//PJLrb6nuuqCCy7ILbXUUvEc//HHH2v77dQZ1d2Pd9lll9zWW2+9wN/PwuDVV1/NLbbYYrk///nPua222irXunXrXJ8+fXKjRo2q7bdW9k444YTcX/7yl/zX3bt3z7Vt2zae2xtttFHu6quvzj/nvWf2ffzxx7lll10293//93+1/VbqtEcffTSe2yeeeGLuuOOOi+ObHXbYIfef//yntt9anXXaaaflVl55Zfs+s+GHH37IHX744bnf/e53uVtvvTX/+E033ZT7/e9/nzvooIPyYxuvj7MnHXdcIy+88MLckksumdtiiy1yn3zySXzcmMXsu//++3Mbbrhh7uCDD479nqZNm8Zjc+LEibX91sre3/72t1yTJk3y5+8VV1wRx4drrLFG7rvvviuIry3MzLRdQNKMVIMGDeLnjh07hhdeeCFm3d58882hX79+BVlRKm3UqFH5/0+zpffff3/Yd9994wzMEkssER9zBnDO0F7M+nXp0iXOpK6wwgr5x1W9V155JX7OLvEdOnRozCDbbLPN8o+7odbsS23DagSWEbHshdlUkAFVXHPQtixEpli2bVjG//e//z1cf/31Yeeddw4tW7bMP6dZS/fjbJvivPPOixkSZJXBtpx9HI9nnHFGXPZLhijZUDfccEPsA7GUVaWR2c3eB7fccku488474wY7gwcPDs8880x45JFH4goZMswuvvji+Hozykojy/vHH3+s0q9s0aJFvD6mPo99nzlDFuP5558fs57YbOeqq64Kn3/+edhkk03CMsssU9tvr+wVn6spq5ZrJSs7brzxxlp6Z3VHq1atYkYomaEch2QpgxVGBx54oBm3c4E+NzVtWcnKvXuDDTaI9x6yRcmiN+N29lC68eijj479He7TZCtzXJ500knh7rvvNuP2N7Aaa8stt4yxiZdeeim0bds2XHjhhXGVOitkKKlHfG3atGlhYWaEcAHXFPz4449jB5Fg7aabbhpvLG3atImd8Lvuuiv/PZdeemlM/9ZMF1xwQTxJqYWHFBDjZKVTk+3opPb+7LPPvDEXYekagdksinq/8847YfHFF88/lp1EcKO8qk4++eS4/C97fHH8saQttVs6HjlWCTZys6HGrXUcqyo+TwnYcn28/PLLw9tvv50P3DZq1CjfCXJzskIHHHBAGDhwYP5r2oZODMckS9uy7cxztF9a5q+ZsoMQShhRz417z4gRI+JjHTp0iMch5WTgMVi9dLxRBoqSJ2wQs+SSSxbc16lffdNNN8XBizWXS2vfvn3cWGennXaKATGCs9RyYxD9+9//Phx//PFxUMjy4EsuuSR+j8dl4Tk9bNiweI1MfcjsxsAEcpZddtl47+aame7hlJ2wxu1v36+5l/AYwTE2hll99dXj/7NjOoYMGWKpqGpka3tzv+FYTEEc+uTUZ2VJsH77ns0y6WOOOSZOwFxzzTXVBm7dnGz22pNALUv52X+HewvHIZMyTP5bKqF6HFfZY4t+DbGeTp06hdatW8c+EMcnQVzKvxEYd5xdPYK077//fkws23777WN/iOOSPk/jxo1jH5INq1NpI8aMC+X9prZTfStJz549c8svv3xuxRVXzO255565t956Kz7+3//+N/enP/0pLjlg+dvuu+8eU+crIdV7TgwcODD30Ucfxf//6aef8o+z5GXdddfNf53a7dtvv81ddNFF+e/Rr1gi/cEHH1R5/Mgjj8zttttu+WWqafnQp59+mjv77LNz33///QJ/r+Xs888/z02dOjX+/4gRIwqWs3H+FrfXyJEjYxtTNkGF0rHGOX7MMcfEc/r111+Pj02ZMiX30EMP5VZYYYXc3nvvHc/9c889N7fpppt6TBY577zzYnshHZtcB1u0aJG79tpr822d2nvo0KFxedaECRNq8V2Xl+xyvyFDhsT2497NtZEyPGeccUbu7bffzr3yyitxabrn82975JFH4lLA1VZbLS5p22mnnaqU4KGEB+3LcWrfp1C2PVimetJJJ8USPFwPs7755pvcxRdfHK+VHKcqvYQ63bPT/YPl+yuttFLu5JNPrnIdOProo2PZCZcBl14K/cUXX8TlvcOHD8+ts846uffffz+2JeVP0uvffffd+HWpfmelyy7T//LLL3Mbb7xxbL+99tor9/TTT8fHuVbSp7znnntq8Z2Wt+JyBx9++GEs07H66qvn/vrXv+Yfp7+z3Xbb5f7whz/EPrlmuvLKK3OXXXZZlXEOJRHSsZhd6s/jlImirVV934d7zYsvvhj7QNyj8b///S9/bjdv3jz2i26//XbLdszCfvvtl2vcuHGuc+fOuZ9//jn/+OOPPx77lFtuuWXunXfeyZ1//vkxzjZmzJjcwsag7XyUPfmee+653DLLLBMDZgxK9tlnnziAYVAITuRTTjklBmy5WacBtx3FXJV2eOGFF3JdunSJJyfefPPN2Jb7779/wfcw0OaGzaBbVXFMHnjggfmvqQlM7Sxu3Nn6gr169cqtueaatmM15za1dqi7+uCDD+YHhdQtotbOP//5z1hnefTo0bldd901Tsx4Tpf2zDPP5BZZZJF4/aOduDmnzjaByL///e+x7iATXwQs0qSXqt4nbrjhhlzfvn3zNb4J5i699NK5/v3751/DPWbnnXeO11I7ilXbkfptLVu2zL322mvxawLbDJoZ7BEU22STTeI9/brrrovPG2gs7euvv4413DiXOR4ZFK699tpxcqs4cMtzn332Wa2917qCANnxxx8f64dmAxLgPn3mmWfG66jn9UypLThPCdIySOYY5JjkWti7d+94TtOuBCGp2cjkIMGyf/zjH7X99ssGfRoGz2mwTKCWwC0YONOuBLqzOB7pI9mHrP5+Q7+7W7du+T4lxyF9IMY1XBcJQB511FHxWLUPWRoTqeuvv37BdZJEqOLALZMw9MettTzTpEmT4nnKvib0HRMCXx07dox154vrKhOwJSGAutWTJ0/2flOEyX2uhxx7nLMEFbfddtuCGrYk7XFen3766fk6wSrEPZvjc8MNN4z9Go45EvJSABxPPfVUHM8wkUAcY2EdHxq0XQC4AZ9zzjn5wR3IziG7dpVVVskHbpk5YPYlXfgqvfB8tmOSgticvMxYMZjmQkdnmva68847c2uttVa8OTNAZGC9xBJL5N57771cpauug8dFjhvKoYcemn+M7BwG1NxYunbtGjN5mAW0HatHFgntRSeQQQzIKOEx2o5znExwNopxMqY0Nse69NJL48RBNmjWoEGDmBmRMOhjsxMzJGaNTGWydZi5pzNNcIyNYRZffPGY8cTgcJtttokD7nRMVnqHOxt0JZORrM9shnLCpAyDQQIXBG+ZRHBzt9K4b9DJJpiTHSAToGBwzUT1v//971p9j+Use5+4++674z0kYYBHQILJweINtMggTedzpZ/X1WEg3ahRozi5zzVw3LhxMZhDAgCTh/Ql2dCI+7sK+41MALLShf4jGykn9HuYcKUvzoaD3KvZLI/7jlm2M3EvZjIrO87jOnn55ZcXvI42ZMKVpAnamo14UmDH87oqVmdxbGY3r+VenTJu2SQ48Z5dFck6BMM4X7PxCsaCtB+JPul4JZHisMMOi/0jJ2OqIvuYe0w2c/nJJ5/Mbb755nFTPLLqWcVKbIjjlX66Zu2n/7/Cmk3IGFtzrGaPPSYYSOJbmCdjDNrOZ2SNsEMyA0AOtCwOrn333TdeDJkhzPKG/Ctm8FkOiIcffjh36qmnxv9nqcZyyy0XdwpNs/wEcAlGHHLIIfF1XBA1czYvTQ7cd999MROPY4zsRgLg2SxlJhkI3m6//fYxeJHaX9UHW1kSuOOOO8bgBDfmhMzGfv36xaVEKShU6ZMxxShfwrIhBiYpWzkbuK1fv37ulltusVNTDe4j2WAYJSZSR5sJAwI6HHMEJe66666YHcFKD87tdCx6TM5EIJEJP+4n3F/ItiuVScu1gNl8ghRcT+F9e2YbsKySpfrrrbderlWrVlUyaDlWyWxk8tVJmFnfa+jvkAVF4CZbEiEFJAjcMkFTzOOxsB3SBFVCm9GmZ511VgxC0OYMDB977LF4Xc1m8mgmAg20WzarkTbmPjJs2LBcp06d4ioE7ulk4dE/0q8IMjAxwIRA9vhikj/dR7LHLMckWWYEx7hesjKm+DhWLt9WlHyifbMTXFwnua8vtdRSMcFHsw7cUqqIwC2TWAklJYhVsPScfjqlZOhfLswBsrlFf4ZALCthGMMknLfcy+mDMwFDRiirBsnIVaF0/WN8OHjw4Bir+D5TDi8FbuljVtKkgUHbBYBlvZyk1NjI1r4Egz6CY2m5kWYiSEPGGAHva665JnYSCTpkZ/xT4NbAYvUXPpZisGyAQM0ll1ySr52TnucmQuD2gAMOKPheghQO+mbKtgXLpLlpUGs13UjIKmOAQuCWOkaluIS6NDLGOC7T7H62rdMxe8cdd9TiOyzfpaqcuwRoe/ToEZe2MUBJuDamwG2apS4O0BqwnYnJAY61lBVGVnIqIVNqoMz5TH0tBtKaievfqquuGoM1ZIh26NAh98c//jEGcrMY0NA3ypbjUSGW8BP84vwmGEYAnPtMwvnOAJrrQHbCULmCe8mgQYPiBAGTVQwC0/mcArdk3FojffYmErifcFwyWbDLLrtUW5+VzKfx48fXynstZySakG1H0IaECpDck1YVcU9ObZ3tM7JsnUA5E7D6VXEmPO1Gxi2BW+oDJ/TPSUZJST6qfpKQQGwK3DK5mqQVWoy7OQ5TiUIVYszNWIZjkEn9Ul566aU4MZgy7lUV42vKHdB/5B69zTbbFKy8pGQH5YvYc+e7777LVQKDtjVoVkueCTCSiUdNk+LALctdXC5dGst6N9hgg1zDhg3j8mmQEZE6hylwS2c8O1tlsLEQmdx0sLnwsdwqKxu4zZZKUGkM7riRsASQUhJkPqXZZjqGBG0plZBdNqhZ4/pHDTeWpQ4YMKDK83QcrfdUFRk4ZIXRbnSwGSgjW6SfwC2dRwbaqcZt4nWysC2Y1U9tCJb2EijLYsVHdkKLpa5MilV6Tbf0uzM5wLLJq666Kv8cEy50uFnRkW3f7MZQqorl0WSHMcADxx2rNgiIc59JuO8wse2kYGkEbCm1wyosSppQo5H+ZNq0kcAtpRLIxiu+Rqo0AouUg+JYLL5GEkjLbhasX2XHeQQPCeiQzEMQlmvj9ddfH59j8iC1XzbISGCCzLxUZ73SFN9fmexj/Je9FoLrIBMz9Im4NyfpfFfVNqVmf3aChfIRZNUWB245VhnvWF7itwO3lEeg703JxnTumyU/e4jnMEFNSRMm/0hQOeCAA2I/MlufmhIJlCgzaKt5qj1G5gNLiBhQZzNuuYEQuC212YaB26oY0DFbSoCMTYhSFlm2GD8BR7JxmQX0plwaG2FRv5KZfW4gpcpxsPyg1CYSlS4dZ7QRHWlqUZOJx7FGxi03ETKfsoFbZqEJ+Kj6pdPUfCpeFsTkC+dyqcCtSuO8pc3o4GTP3bQ7LY488sjY+X7iiSdq6V2Wn1ndb1MpDparcr9Oxy73byZf0/dyrrM5gjW/ZwYZqd/NNZG6/VlMGpBVy/3HzcZmD/1HMkm4fydMyNx6662xbEy2VEIK2Bq4LUQmE1nKN954Y34wzQQhgVsGfKnPyPNMXC+MO07XxD2brDrOYSZgUuIJk4aMawhMEDgj2Eg5Gfo/lTKInpv7De0GAhEsoyYQSy1WxjgkV5AU0L59+xjQpdZtwsQM14NKW5Je3b2aPs4DDzwQS01k2yldJ8leZkzDfQeVPKlaSmoP+oW0FUkolOBgYpAgLtfKFLjN1rhV1TZkPEO70ZZpRRFtyH2FxDMSorKbYSpX8pxM5zr3GfqSXCvTa0aOHBnH3/TBs+ObSpr4N2hbw1h+QS0nZk1ZVslNOLu5Dh0csvDo5FjH7bdxstL5o5O4++67x7bl4lg8Y8XMswPBWWMZFrPPdBKppVwqcEuheWsBV58ZwXFIgDa7pIUlHHQKuZGkzjTHopMwhdKNl0AEkwcMTqhlS3ZT9lpI4JbBc3UlJipd8XHF4OSrr76Kx2GbNm1yRxxxRMnXki1hZ7H0JCs10Hv16hU73VlkyzNwJvuO+w9ZZcWZEi6pnonrHx1tBsppqX62rVNHnEkEM04KlQoocB8hIMExWtzOXEMJ4LDpqkoj45NgIhPW9G2y2WJM8rMpDOV30iSNy85LH5PciwkiMkHFsn6yv6kdmu4/TBxybaR/zsfCunP33MpeAwm8cswRsE3nOKXLuGZSK5TEFDZbZgKM/nr2nk0mbqVt6Jbajvq/bGx3zDHHxMlp/j8Fa/h/su2KA7dMztDfZMWmSuPcbdy4cez/UO+X2AW1a5nQIkmFvg//z/FJ+SiVvj6S8c19hvE1k1ZprwmylwncEgzn+HTioPS5zarpbKY3pTCJk6XJv1TG7eOPP47HYna1QSW1qUHbGkQaNwO8lGHCQceyfgIT1N5ImBkkC88BdFXp5GMTGDbOotOS8BgDZwLhLGMFu62SRVFJJ+3sSO1Bp4YOS7bTyGCaGwtLDVLglpIJ2VoxKsRGJQxUyPgmK6I404El09SmZtOdbKaOgdtCbJLVokWLOJHFLD7XQm7A1GTNdqw5Nhn88RrlSh5PdFqYBGSAnDo7BHc4PqnFmlDD8fnnn89/7X1nJu4dnNfUpSXzjqA3g8LsgIbl1AR36ECmQGO25qAKcW1k0EJwlsmEUvXAHURXj1rpacKKAfMee+yR22233eIS/+wELINr+pwMFIs3cFQuPxgkqE35mOKyUGRBcW1k8jAt//Wcrurll1+OkwNkd4P7Dfds2vTZZ5/N31OYvGLVmzUaf/t+w306uwkZmXlkOtK/LJXpXakTXOl8ZLzHiksSJsgG5f85Bvfcc8/8BEEK3LLKg/44+yQwkZBqBqsQ5yyrDFitwWaWWVwr2QuB8ifgnOa+ZELPTKlP88ILL8RVbik5j1WCxH3oS3LtTPcaNnXj2PR4rHpuk4lM6SICtwmTV5Q0IsaT9cUXX8RrQHEt60ph0LaGMFNPYCfttkiKPMEJLnSnn356PImzGbeJA+iqF0Eyxgg8MEjmpCUYlrJ2CNxyo6Y9udmwRNClqaXbkYAONbPatm0b24ylvuk52pOMCWb/GBDSjmZHzJQNMpChw0QBHRgmXwhGMNArzrCjI072jgO/0qiBxYZNzNqDTBOyyAhKMLHFsulsvUt37q4eO8kzQcgkAcci5zDnbyrZQYeRZf1cOwk6utlYVWQzsSSVjCYQ+CbTlvs2wZx0jLI0kAyzbMBWM6+RLN3ng4FJNnDL5lncX/79738XvF7Voz/INZL7cSplQi1vJlnZvZs+Jvch/p/rJpOyZPhkd6hWrkrdS5ZUbrrpplU2s+ScJ5CWJhdUiCxaMvD4SOc1gTFWc3C/ZuPL4hVbKq1fv37xfpNWCoKlv2nnc9qW/jpt6uqNmUEdNrPknsx5mq3vy7m8xBJLxJJFBH64v3AvJ6DL2JHJrEoN7FTXliwpLz62aD9WGiGtOAAbh6ayEqj0WEWpmrQklTDmoyQMCMhyfWRClfajzEkaV9M/sl56rqAvSGCWc5gkxlJ7lpChTKzn4osvjhP9Y8eOjWVHGdNU6vjQoO1cygZmUk0sBi7MmNIBZCDNMhiQLcryA2YGyb5V9VhSwNJoNoZgwMxNmgEKM1TM4qfODcFxZlLdnKg0Zvuoc3nZZZfFmwYdbGadqU+ULpgELdghlCxHlhyoKpYDkYH8l7/8Jf8YHUM613QKq+tcV3oHpxSWWrHcnOsj7UbAkWMPFJYnULHffvvlgzwqjck/JrVSsJGdUznXyWJOHW82LuKcp0OZOpkek4X37b/97W/xmpgdqPD/HIssD2QgSNDivvvuy7edAdvCdiSwSFYtGWJkxpPtlIK3KXBLBrNBsdJKTfBxDDJp0KRJk3ymE2V5KCNDv5K2JuMs1XTbdttt88tWKzkwnn53gjxMvrAsOmWGMcBjCTrZjMWB20pus1KK24M+OaveOK+ZPEh107n/MKbhg2wzzcSEKfeXLEoipOX7jBMJSHCfoU1T0IdSCccee6z36v+Pe/Biiy2WnzRI7ZKum/QnGVuTGJVFuS1LneQK2oprIdmMTEBTBiGd5wcddFB8rDiewUaiHMeVmuVdCvEIksWy42VWVnMtZAJwo402yl8fuf9wbWRck/rqmokALMcXkzGl+kBpM2XqqDORRaB2jTXWiGV6qK9eqQzazmNHm4sfH9kZFLIYGcikgA6dHi6WLGHzZjxrDD6YKWVAktqZmWiyQrO7gMK2LI2gF8t5U+F4OtsMqAmSEWgkUJtu2Hw2M7T6zFCWbXDjzXYK04w+N5zicgiaKR1jdHBS7bG0IzI3YtovzZYykOaYLVV6QoXIciJQmzqGzZs3zwdtyNwpNZFQ6cFGgtgsge7Zs2d+eRrlJViFkJawJQR9yK7N1sCE95vCvg8Tg7RTWjZJsIFl1AQjUrkO2ppzmozvSj8GZyVtNJaumQxamJQmIMGKGdB+9Iuy9xsyb2nfVB+z0rFKi+wmJguo+csS/hQ841hkwE0SgKWgSkvH3+uvv16wQ3cKTtA3Z7VbypJikvW0004zeSKDoBfJOdnJQPTu3Tsel8cdd1zsN9J2nL8sRSd4W1wyppLvNxyHXOs6dOgQMxezGbY8l51YYB8ZArv2G6u/X5PdTZY3K7S4n2SPTdqW8SGTWlkkVFCOsPg4rmTcQ1j926lTpyrXPMoXZSeouV7SfkzAWlaiKiauCMJmA9rcd8iqZWKaiYTU96GtSRB47LHHKn4vKIO2cyh7s2CGgA4zQdvsDYPBHlkSzAIygObEZaCdvtfBS/WY3eOETdINg5sOF0suhGZG/Kq6YCudRjKRGcgR8CabjIL8BG/JyuEGTUfbdvxtDFCoiUd5hGwGKG3HDYZlWEzIqFA6tsgUowQCmSR0wtPjBB0ZAKasPDqTBG7tIP72zqrU+6XzwrJUBispYMt9hYE2gYtsdkSln+ccVxyDBMGyGzrRuWbigMFJdnMXJhIYLGZriOrXbE82wgEdZzZeTLX6qXlHDTwmBblP9+3bN056pfbMDrpViPqLTAymMk/pfCXThH5jqQmEt99+OwYguS+5BPhXnMMstaTOL1l29H+YpGF5JdnyadDNcUs5GTPxqj8eCXwTbGACK5uMwnGaghXc0xnbMFGo0igFRYYt6P9QO5Q2Y9IgBXJY8UYZGYOOVbG6knv34YcfXnAsco1MQW2ujUxcWyavNO7VtCErNUqNH/nMuc29hNJvtDXL+1m9VWmb3s1KOt6YXKH8GGPpbMYt9xiyatNjjHHYjD4lqqgQk34EbSkbA66JlDBiFRHxCjLAiaPR19FMBm3nEoMSZq6K64BS44SLIJuZNGrUKM72cyFMg+hKH0D/Fm68DPpSlmjCzYPZaJfxF2IQMmzYsPj/ZJRQ/gApGMaNg0120gCar7mBU28nZfeoagA8uwyLGUGCO5zL2To6nMtMJlRyRsSsMDNKrVoCicUlDxiocJ6TPb/LLrvETne21psKZWfqmXAhg4wlQ0wMJmQzk9FYXLi/krHRHYMPAtmlJktZzk/2E9dIyk5wXLLbPMvcPK+rTqgStGEii7akZAxZn9QMpfOdNr877LDD4qCG12fr3Ko0At7Up2WDohSYSPcjJg7SEvTsbslpMoLl1PoVgQeyc7I7UKdMPEpupYkDjlc3y5o5FsmOSRjP0FbFWbZpEoHjlGORJf1MGGYDaaqaPEGtador7XVCW2eD3LQpSQFMIrjirVA6Lin7RLYtwcRsHzG1F6u22JgoreZSYfsxicX4ZVYbYNGW9NFZ2k9SgCXzCseEqS+Ykkr4moAiQdk0iUX77rrrrvH6STlH+p2OaarKJi9Sa36llVaK+3MwniEJIG0yzyQXj7NCQTMZtJ1LZNedfPLJ8f8J6jDLwoCZWXxmEEAmHhlR1sOb9SYmZDzRwUntxHJLlgXS0WGWiowIlhARbKTDrV/bjw4f2YpsMkaghs5hcWebupZ0tBOyJ6699trcd999VwvvuvxvzuyQzIQLs3ws/00Y8FHHlmOwVAF0AzyFOGcJxqYAIscqnRoy9QiMgZ2nCZbRQUzXTFU9JimrQ3mYtKM8bcmkC0Eerp+0NW1LezOY9j7zK65xZEMUd/qKl1dynnO+M3FAORRm+q0DXBUBWvo3HHvcl1NJKO7NDFZS5iLZjRybZOu58Uah6gIzHKu0K5mi2UAYWSZkSLGJaDqvDe5UnyHKRGAKTqRzl3sLm7Wl+45y+fFJMUqbsPSXYy1dI7PXQAJjvIa+uRMGhQh60U/MLt8liYe9Teibpz1OwMQC7ch1M5vU47k968AtmzRmsz9pt6OOOip35JFHukqrGqzWoP84q/ZNdWwT+z2/IjaRxsrZNiIrlEkr+oyU22EVEgjSUoaL5ChLIuQKrmnZyap0veOcJbGCiQXiaFmMsxnPpFUy+pVB27k4APmgfhsDGGZSGRgyW3rooYfGABk34eLZfi+CpZdOU9uJmzE1gFnmy8CPiyNZOgRuyW5kFpXag5VcfDopztTmZsGAhE5hyrIFnW6OUwr4s/kGwVqWHLALq/XvSmOJPkuEmNFnAyfalGMytTkdcjo/zKC6u++sEdShzAnLA7kxkx3KbD/lZDivyY5IN28HKoWy7cHyQI5FzlsmDdJEAhlR1ACm08gKBCZv6OAYbJyJTjPBQyYHSikObjMhyBJVyxjNVHxuEmhg4ipNIKQJbCYH0zHHTtTUKTPzqfq2ZKDC5DTBr7Raiz5jCtzy/NChQ+PGRWQuJx6TuWpXrHHuck2kn5OdWOW8pozRM888s4DfZflihQETVPRjssclfUj622mTu2w7szdH4orBQvfcc09cnUFNb45BrpMJbZlWKaQVhJzHZIAzjkzntOd21eMqW+aJ87c4cMvxyorXVGdZVVFDmZUwKehY6tylHAIJK4nn96/nLaVMGLNQZjAhEYV7NPEIJrKJTRADKq67rJl9Hs5PVrAxsZoUTxQUIxmA49aNqQsZtP0N1QUUGDyzjIDUbk7iVFeMIA9LXbwBz9pTTz0Va7XRdixVI1DG7oCcqGmwR5o89YIZwBQX6a/kY5HsOnbzpeQBs1csIeDGwfFIzd8s2pbMUQI+BM1czlYaG0dw/KUBNDP7aefP7HJzAkG0p0Gx33bZZZfFpULMSBN8SJ1CJre4RtqGs5Zqpl966aXxusiuqXQOsxng1GjlGsnSYFd0FOIayfGXgg2ljjc642wGU7zywImEXzvaDFq4D2ezmJisZmI6obYl5/g555wTg7fc11PmiapiU0uCO2Q0ct9mwjptLMhAkcyxNGHNZIy7dxdKA2KC2tTDo3+YEARnMxja8Msvv4xZt7QtE9vWDC08t1N7ZDNDuUdzTFKKI1s+gXsKGXupJrhBiZkY87G0l/I6HItMnjIuzPa1U+CWTHBWuqV7TKls5kqS7rNM8heX60htwhgmLZlOGbcEuynHQ/ktk3lyszwnKWPE5D7nbuobZo83xpCsNMoG1PQrNqklkzbts8NkDAHbbI15jk+SfSjNk7JrvT4WZiuz3wF9Hlaxsfp8Vv1sxuAkmdF3t15/VQZtZyF7QJFZwglLdkTqRLP0pTibhGAEdU48aavHQJkLYQqG0YYEHtnEhIEKAQrrrZY+FqkzRKeQ2kNsRARm+3icCyPLzRnMlGJ9wdIISNCxSRs6EQCjk8OSjdTR5twvPqcrtaM9O6VOwGcCZ1w7aat0DLOUjU2hbL/qsaSXIC2DlGy9b7LmCUpkA7dZtulMHIucu9nyCMXnMBlSHI8Gxqoi8MXEFYMRlvamjdloVwI7ZIAndLK5L1EiyonB6nFv4bxOk6usLOL4JDjLrsnZc52lluma6URM1XZkzwjajWOUTdlSdi1BMSaoeZyVXGy8amDnVwRusvcI6jHSb8zuIUHb8dhLL70UEwMIqBH4JjBBIFwz9e/fPx5n2Sxuak3zGIkpWYwXU8ZtdslvpY8VCXoxOUjiRGqLdD8mWYf6/UwMpudYOcNqNwLlBnV+le4TZM5z7yATOY2hmTAge54VMn//+98LJmBpU1ZjMvbOTt5Uuuw1kjIyXBMJ1jIhnfaQyd6XyQZlNYdZobmCY4vzmDKirCBiQov4BPV+qwvcMvFFH5L4kCXzSjNoW43sjZRl08zuceKSYVK8IRbL2ljGSuYEu0676dis0QkkO4wbMjcWLnZkL4LC1HSyqeNGMFIzjyMGcdw4uAhS6y49ni56DATpbO+7774xWAayyC644IJafPflp9R5yWCEshF0XOjApGwIBnsUnKejnd15XtWXOuEzAfDi7EWCPWTjcQynzAlV7bjQyeZYZJCcBn7peTrjDFjIuM12fLzXFErtQWCR4A6D6+J2ZvCyzz77xOX8qor7L4NpOtFkh3LMkT0PAo1MIGQzTpgUTMuqVXhOpuOO2rT0EbPtRDuzq/zWW29dcmLViZjCNqUtKclB/X6yxLgmUj+Z4zRtMEY7EkijTIcZtr/insKEAauuskkA9L0J6lBvPgUiGDSTncz9nPOcSRoDZIUIaDNpwJgwJVCAVUX0FymdRwB38ODBBd/HhsFOwsxEoJGSEhxz999/f/66ySQMK43Iqk3Ha3qOQJo1lX+V2obxIfcWzmWyFEkeY5yYxjcEbRlb099hsoYJa859ElQqfaK1VN3V7H2XlQf0hWi/VPqyeGWb9+nS2bMEudNeO2TR0ucuDtym85o++QsvvGDsZxYM2v4GMvComZNm6pkt4IZM4JYZLdBpZMkvSwOtT1SoumBCOikJKFIHmA5Q+ppgBZvqeOLORACMDiITCMWYJEg3GwK3LOWgE7TzzjvHWerqMm8r/YZChnfxpkR0Bun4pA4hnRuC5NxgPKdnv9QJmfNkzKdzmE1gGGgzqZCum6qKY42NnNLmOWk1QjZTmbrKdMzJLjP4PWtMXhFsZOKFiQQ63GQ8cZ1kkpUJhnReG/guRAeaFQZk0RL84jwnOEYgnF1+OcdL3Y80MxhB8JBJ6mzAhvtzqiufjjmuifQr02Srql/NwT2FzM/sztxMCHJssvyyeEMTzewnklzCNY97SLqf0MchSYLkCSYVsnVvOf+ZrKZ9VRX9RYKNBGoJ3O63335xbEj2InX7qXPL15RAIYiWJhVQyf3J4hUEnNPcj5kgSIFb2pYVHtn7svfo0ihHxMQKJbX4f+4zTM4Qv0hoY/beIRDOvYb7N2PvSs9onFXd1RSITccjx+eaa66Zz2LOnsMemzPbkolSzuN77723yvFFPIKMWyapU+CWdkylCTVrBm1/o9PNIDpl6bC0gFkpsvA44CiSnGao3MCkKtoju4MvJ2t2MwMwAORmnQY2bFhEFq4B20IcZ2SAZgNezGBxU+ZGQpA7TSzwGgY1LEHPZoRrpksuuSQGtrlJszQwLRkiKyItX6PtmF2lQ554bs9+qRNm9gncEihjUobrp7WpC2U7egQhyGxiVj8tFaKmMh3w5Oeff44ThGRJEKSgXI+qdhyznW02iGAFB+c1datpNwbTZOa5cdtMTFSxaQmrDVK7MCHNdTIN/qgRSnYOmaFsjkebFmeSKRcHLEwWMLlCVkkKenFPoQ9JkIzJg4THydjLBiJViME0fW7uL2TPcw3Moo1JsNh0000N3BbJjk0oucP9mX5jNuOWY5IAY8q41exhooUgOMkm3L+zK4wof8JGeIxzqAlc6feZ9PtnMxoT2olEE1a0Zje6NBg2a9xH6BOyQVsW9+g0KZ3Oc9qfgCPj8LFjxxZMKFayWdVdLS6VwLnOvTq7OZkKVwNS5pLgNuXJuGfTHyq+ZqZSCdzXOVbpSzJO9HyfNYO2GaUOFurnMFDhQCQIkWaimUHgIGPgkl2m4QGXixvn8JE89NBDsZ0ozs/SXnaUT8is5QLIQJCbDs9nd2HUr1gyQMCBOmOg3iqdG+pbUg6BSQQGg2mwkpYRqup5yVKNVq1axckXZpppQzY1SB1Jlg9xbnO+s8Oy5U7mvtQJyzG7d+/uTvK/geArWYtMWiWcv+yOzLHIgI/n6OSQtZPaNzuhUInY+IEsUO7PxUvzmWwlW5nHmTggGE7mDh9kflsvdCaubZQ4adiwYRzocY9Oq194nPsybZbOebLKyJzn2HTn7tIbE1G/kqx57iNk16ZgzhNPPBEHM9QMZnDIsnMmrqkJ7D27tFR7leshm4/RlyQozkYxWWQw8zprC1aVrRdK6QiOyVKBWyYauEZq9tuULDHakoDP888/n3++VJC20gO3HGdke9JPZJxIgk66NpIoRTYo10Lu3+nY9LpYKNse3I8ZszDOzh5fZMozOZ36N9nvsT3nrO5q9pwl+YzVmExmZzcTrGTZgC2re88444wYN2PvDZIjGEcT18m2Fe3IGIa+JSXzzLSdPQZtq7mIFd9Y6SjSSUxp8WSNMTtArbdKvwln0RbUcmIwR3YOX3OBI7DD4ISAGVkSBHISMkLZwI2Tm5O+0qVjkRnU9P9s6kR5BIIQdLbZNZWNS1KmNxdEskxS7RiVRuCBOr/ZZRnsOE0nkQ2JUuCHGwqzgcV1i1QVM/azKnVCQMLM+epxzDFhxTVz1113rfI8M9G0KwNCAmVpozeyxCt5eTr3FLLullpqqdh2BBxSRiMDFkp2pNrU1XWsHbwU4p5DeRMmBsiUILOEayD3GrJ5ijcrKa5bXenYTKc4+5j+DZPW2b4NQTOyHblnk4nCIDFNDnpMFqIEDLXQs7Wn6e/Qr2SFUZrITrxXF0rXPs5jVmqkxwgucuxlA7cEx5nA3mSTTfL3cc2UPTeLEyMIOpCFx706u4FodnxogOfXfiHXSLKSSdhhTENwkXrprB4kcEvGLe2YrXGrqkvQCTKSlcyqrOLrHxOrbCJKfzG1oZuNzX3d1XQe872MD101WIhji1VsJJFl3XrrrTEwW2pyn6QT6i9b5m32GbQtOoHJkmBwwgxA2nQDZJ6QOs8NhQ9uKNkBs4HbwiDElVdeGW/MdLZZcpldCsiNpnHjxnF2K/s3SB3KSpaORQrIM6ijgHw6tmgfghAsRWe2OtuZ4XVkSFGzTDNl24hsZQIRZH9mM3Q4XsksIXCbzbhNPLcL25JSJwyU6Sxm2+r444+31MlsKBWUIfhFUIJMRzIb0+uyBfoT2pwMvjZt2sRM00rESgPuIUym0oEmU5n7Td++fWNW94477ugE1mzI7jbNxi8geEhAh8wTagFzXFKjkWtjur+k49EBdeGghYwSAmHZ85VrIscm9xjuQSkLlNcwyUBJBLO+C6XjiiWoTFYxAVM8ocUKNwK3ZOYNGjSoyvdqZltw3h522GGxvShZlNqLjQSLSyVwT2GpumaiTbJBm+K2ffLJJ+P/M9HPqrc999wzJvaoKu4vZOJxb2HyilrpjK8Zv9Cn4d5NEg8rB8n6Tv0hVV2CTjkT2pF7TrakRFrRQdJEGnunzUP5upKvkfNSdzVt7Kaq6Msw2Ue/kdVvCfcYgrnZSeu0ipDyb+5xMmcM2mZwIyGgQyYedS7paBOISNlkdG6YMWC5G/+fMiMqXboIsukG7ZQy78hgJCOU9ipeukrglrZkiaAK25Hs2cUWWyxm6JRS6oZ77rnnxmOSJQmqig0gCHZxjtMxJACRbUeOT855ll1mS3voV6mt6BhyjSSjhBsxHWw2KkkZFHS8LXUyewFbJlroBBI4S/W/u3btGoORdHSyr0+f+R6C4XTGK7Wzk7IZqTudReYxnWxkN3xRaaV2my7eIZ5rIhknrO6gg82SQJXG+cskFccgk/oM8mhTMsmYvOaeQ1tybz/66KPjiqQsM2wLsTyaxAjKmtCeBCkYYGdRDoprIUkWTvqXRvCQJavsc0BSCmW1CPKQ+ZRq3HLf5lrgMVgVe0UwGUNgsXhyhf4Q96JsfWUCPiQH0NesdNUdT7QfKzpIhCJwC0oYMaHFpMKxxx4bJ7DpY6ZNGyvd7CxBp3+YLe1IqRgQIGOFa9r3pFJZd3X+YiKV1S9kyrNqgwQeVsKVuhYy9jHDds5VdNA2e0PhRktwkSUFoCPDDBap3QkzVGk31XTTrvTMiOzsPGnxpLtzgwAnLDWAuSiSeVuMdmTHy1RyQr/eTMgqSRc5bg5kKhKESMHwLC56LAumJkylBnF+CwNpsnFAGzIQpNQEncPszZdBHzduM2tnyrbPG2+8ETvZt99+e35JEZ2Y7MYl7DRPRpSlTmbdlgygWbrGsmky8Qh0cy/hmsn/M9mVzR7LTi7QrpW8zI2l+mmgzEAv4f7DxoHZLEfN3W7T2WsgnWsmYLmP0+5kqKg0zmGOS9qSayWZUNnVCCxV5X5EmROCuwbJSl8jWXlADX8mDVJwluskEzMPPvhgwfcwMZgNVmgm+o5k16XzmvsHx2W21AQI/FDb3yW/VdFnpKY8E9Ws6EjnLJs5MUYkEF6qX17p/cjUTgRi77jjjngPSZPR6Xnalcn9UisEaUM3e5r7JejENAg4Mj7kOK30LFHrri64wC1jQI492ozjLylepaA5V5FBW+rQpiW86SBiCQa7zqZ6eGRDpJsxMyvZGkWJN+Xp+YwdbiS0K8sqsxnIdBLZkIPBXqovmEV2rma2BVmgZD6l9j3ggANidhPBHbIas0uFKJPAcgQGiO46XT2WCXH8pSUbdMIJVnC+Fwduk0o/t1kulJZVpfOc6yFBMRDoYZKL7DHQhimb3lIns8Z5y/WSpdKc8wRwmKghKJ7uNwRuOWbtJJbGygKCiDfddFP8mo43X5NdornfbZpatmkiuvi6SOAsbXSpXzHJT0CMvg31f9O9g4xQgmDsg5D6mtkJ/uzEgoHbQvS1We1CWS0C3uk4JCBB4JZ+EJlPKlSqH8OkFpODBLX5WGaZZQpWtxFEoywKx2y2hFmly9YBTvdksj85p7l/c84S4MluOpb9vkrvR2bHhky+kN3Nag2yPVkpk8VeEoy3U8atamYJOoFw+pAEHCs9wzax7uqCC9wSCOfcz5YiNFg77youaMtMMictmXbZDIhURJ4OOAPo7Owpm0pQo8gBS1Vk3ZBNkt31vHggkg3cUnNQuWoHbP/3f/8Xd56m/hCDE+q5kf3J4ywnYqlBmq1m4MfSt1SLUIUzeekDBx98cFx6ngbQdMKZaaUTnq2trFys4cTuvtQLzV4jCXCnAR+DP5b4pvZmEM25nTbJUlUci+PGjYuz0Gk5JUFGOovUaEXaNILBNlk9lb6SIyuVkMhmK1NKgmOSGf2UAW4QbNZmd7dppOunx2FV3JO5TpJRwoY6TK5Saz4dgyl7mfqM1FlGcUktBzGFaDfOa/qK9CtTIDEdo6zoYuKQwIW1Ln/7GGK8wxJgJhFYKs0ka7o+Mp456KCDCrIflctnhxYHXDmHmUxlsp/xTHHpIhWirAFBG1a2MVYhe54SWmQ0kkGbPW4J3LZq1co6wDW4BJ1SR4wfSwUiK5V1Vxcc7i8cp0y0UuJINaPigrZp9o/6nwxQUlCCzDGWqzEITMv7U8CRTiKdGzvYVTHwoxPDLP6sOi8EI1LgNrvTZSUrVRCdmzCDZ9qJAV92d24ugtyoqXXrEuBZK87gZhMYdppPg+dsRiNBH8/tQtRyosYdWRHpGslyfQKMZEWw5CXbZmShcI00W2fWuA6SdUJpCTLAact0PeQ5ZvyzM9Oo9IBZCoSVCtxyr+ZaSe1QJwxmzd2maw71lJkoYKk+x+OLL74YVx5w/y4ulcD5Tk1WalertOy9hHZiE2AGy6k8Wfa8J+OJ+1Pa0K2SpT4kG4cR8CJbnuANx2c6r1kBxzVy7733LvheguNMNlj/uxDlS2iv7bbbLrf//vvHTVdT4It+N5P8TNBccskl+WOyUjNqZ5U0wSQ/wbHsqiuCY0x0lUo0IfuR+t/2IWtmCTpIElAh664u2LamNCHXS0pNaN5VZNAWzKiwXINBSgpKEIBkUwMGgGTt0CEn25HgReoAOataiBqWZETMqiNO+6YBC/UvswObSjWrguhkOrLUkiBudgd50AlKS9T1q2xGLQg0ch7zOTvLzLmelvMn3LDT91Zy4LZU1sh+++0Xj0cGMbQTAxMy9CjhkeoKUo+awR+z1J7XhUrdK7gWsqKD+wqZJWl5f8pMoSNZvNlOJSPoxQCa+0x1gVtWJbBpCatjspnhmsndpms2+M1gmRqNWbQVAz+CFUy8gn4j5/Nqq60Wg2ea9TL07IQq9xUCt+l6mD3v3QR45v2FoAIrhjj+KG/CKpi0SSgTMAQaKbNFnXQma1hN2K1bt7iikE1vVYjyB9xzNttss5iVxyZtzZs3jyVl/vrXv8bSUZSWoR9OIooB28LjkQQoJrGeeuqpGNjOIohIYLa6cm6uGqyZJejer2fNuqsLDmNw6gI7yVozKiZoW3wC8jUDGYJldHTSYI8lbcz4UUOUemTMtKYOojfnqtgVmQEgGYzVtQ/ZUOy8Ci+Esy6Izux+KohevEyV9qXznc0EV1Xs+skAmSAFM3zckLlhsBkegciUWZI9Xiv5uEzHIwFYal9ll0uSPcv5nTZfZHkqZSYIknHtpMzMSiutVGXX+UqXDdjSaSETKmV5MyFDwJala+D+wmCGZdR0Ir3P5PLtRJCRrDoCDGSRVRe45T5EMJJBdKqtrF+523TN4tgjK5l7dEL5LLJ1GJzQfyTok2o3cpxyTfW8LpTuudQFPeyww2Lb9ezZM/88kwVnnXVWDNySOZr9nkq+X2fvLwRdGatQnox7M7iXUBOY45FgLvdtHuP853pKIJK2dh+E6tF+3E+YsCYoTiIFE/5MatF+fOaaSiCc1QuVLh2PLCNnNRaT0aXK7HBOE7TN3ldSLX/NOZegzz3rri44roKrOaHSBtDMOmeXX3BDJijBbGoK3DLoY5CdXdZR6UtUq0NnhgFK//79S87ykaHHrDRBH/12QXRm8ksVROeYJYOHpUWpc65cXGZO9jYZigz8qA2azlWWtjBwZtkqu05TDoVjlZ1sVXXDCErGLL/88rGNyOhOu8RzjHKNJOuRwAPtSyeHzXdYkukS6uqRLUankAkElqem4Db1gglGkHWbPrgHOUE4EwM/SpdwvSOzm1rfswrckj1GO9rpnsndpmsONfDIrqXUDvscZNuSewsZZgm7olNui9rUWZ7XVfuPBB2pacnEfspoZAIx9XuYkOGelGowa+bYhaAhAcZijGFYecC5zzUzXRMpt+VGoaUV30+oxUq5vBtvvDH/GPfnJ598MpbvINmHfmWln9PZCQQC2bRbKfQbGVe3b98+f99hkoZze8yYMQv0PS9MXII+9wx6q66piKBtcuGFF8abLNkkFEQnIy/VzCNrjMyTUvV0HATOunYomVBk5dCZKdarV6/c2muvHTdE0NwVRKeWKIFvMifMaJyJiQACjSwD3GeffWJgkbZjsJyd2WMAQwb98ccfHzNEqcFsoLEw45uAGB1oghHUV2bJEFm2xaUSaPO0mZtmPUHILugMUNgVmQxQsvFow7SpAe1Om5NNxgA7TTZU+gQhy/bJsmWAl7JwaFeOy+LALbL1vc3EK+Ru0zWDyUDuv/QRqUPNRGA2iDh27NiC1x933HExm1G5as9HJgrpi6egGOc7k9JMZjEJm+r5c7+hv275ncJ+N4EG7tOpr5PuG9myZKwUpDRHmjzw+jhnNdOZdKVsGWUliuuDEmisrrxHpa4apL2yuM8QVARtxWoj+kSUgmI8zrWUTcA1b1yCPvcMeqsuCZUygGZmtHXr1nE2v0ePHrGeLZ2eFGhk1pqi/Cx7cXllacUdvdS+DKxZZkDglmVa1HNjZ2UCjS1btnTnxXksiM4MILWhzLCdiSAXWSYsX2OwBwYmBMeoucqywFJ178jYY0MyZ1VnzjQTqCFwmMXyaM7d7PJpBoBcI8kGN1Nn1qjDSGY89QMTJgn32muvOIhOA5XiAG2lDv4SBsfcR1544YUqz9E2xYFbBs5kmqWBt/XcqnK36XkP2JJxxzJorntsTERGNxuFptUIWUz8095MWGtmv5Hs2TR5z2NMapFFC0oWUWaHYDf9ScqhHHLIIXGX+ezP0My+N/tukBlPWZ20Z0S6f6T7Cv0crqeMb2zDuauZTiAy1UwvldRT6fucpNUcTOxnMdamFEL2fsLYOiVacE11NUfNcQn63DPorbpioQ7aZgct1Likllt2AM1yVYrJM+sHbiB0FCt94FzcGSm1WVNqIzritC8XPZbFsNSNTB0yymhfd16c+4Lo2ePQjTdmouQBHe3sEtV0XDKoJnOHwG1aplUcyGGQc/DBBzuIyeVicCwFbclYTMfZDTfcELOgGDRnA4scq8xIuyttITJD0xI/lkkT0OE6yCRCFjP5ZIWzssNZ/UIMihkcp02cSuFYJHhGVg+lE9h8h+O00gfOv8XdpucOG+pwfSTTE+me0adPn5gVml3Wy7FJAIOsHTa9rPSM+eKNxdgjgrIRqb9NAIcJfY4/+oqURaDNyBClVjrtzuOe26UDg/QPCTpyr6FPk7K9s/3G6667LiaoGNCpmZrplEcxqaf61RwpGYIkKQK5rDLKtilBMc5r7vPZVR5SbfMaqbpgoQ/asrQ8Lfkr3i2ZwC0DmFKDRAO3uXwGBIFtAmVpwJICO2RNkO2YBjRgoxOy9+hAmo03eyyIPvsYFLNElUmBNJBJ52p2swMynehIZqXXk+1IRo/n+K+oS0vWwwknnBC/pmPNRlnZTLFsW5XKLqv02qvcY7Ibuzz++OO5LbfcMi6jzmYrg0wygmdsKqiZdUE5BqlxWZzlmII8Cec5r6fNKXWS7kcGd2bN3abnrs3IqqW0SbbNrrjiilinOmWCEmxkFQd9JSa1rE1dFRnx3JPJaqSPmLBChvOY1QnpPOb+zAZl2c3eKlW6rnHfffjhh+OkVcpQ5Lij3VLgNm12yeMcg8ccc0z8YELWc7yQNdNrfjUHgVvalJUcbGxZjBUxlCrLlqSQJM2ehT5oi969e+ezJejMZG+6dLApl6DSWHZFG2233XZxaWpqu2+++SZmmhx77LEOTGqABdFnD8caEwhpWWAapBQvC2QgQ9Y3x2ka9PCZDjrXAmsDFyLIyDJKNnOjfASD5qTS67b9VnYowcbiCUE88cQTMUhGjeXiwC0rEAwyls5mTMhYJJhTXC+Ur9n4iY1grAM8Z7zPzFt5Cf6fFR5k3RWf85Q8oeZ38b2o0hVnfpJFS3CMDL20kos6l4cffnhu+PDhsT/OPcjNiQprhjJJQNvRNptttlm+7jSvIRBWHLhlWf8yyyxjWa0i1kyfP1hhxJ4xtGFaYZSdEDz33HPjRrepVrUkqYKDttlBcHGHmY4gQQkCPml5C8X8ydhjqZuqtmNqQzrPDPJYipoCt3R62EXZzkvNsSD67J3b/H82u6R4WSDPn3rqqfGYLaU4CKSZGbfs3k12qFnyv40sUDYpKc4OzZbhoU2p30bgtjhjFAZuZ2YzkqUzbNiw+BhLVqmfnAI72cEyday5F6VsRoNjc8b7zNyXl6DsAf1IgmTpnlOqD1TJE1ylrmnZpacEwMnEIziWNiliEzw2JaKuLYFGJ1VnovRY27ZtYwkjypcwycW4hVWECdfAVCqB8jv0fyghYzsWsmb6/EVmPJNbXCtfeeWV/OPU92eiyxq2kjT3FpqgbfZGSvYTmWJsppM6hejevXscZFMwnVnoPfbYI9ehQwfrhRYNNKgpVoxZaW7GLPnNZpjYgalZFkSvik3tCNJkj8viwG3KLkkdbTqNF198ccHPqdQsieLfN/t1caYiGzOSOXryySdb42kWCNSSHZrdQR7cU8gmydYGJeOWayd1bMn8VvXZjCwv51ynBEpxwBYEdfm6eGJRc8b7zNyXl2AjnZShV4n3k9nNuqOPTZZiNoh75ZVXxlqXLKEmAE5wLE1mUWqC8zttLKpfs5C5pxx99NEFj9Pnufzyy+PEYVqGnkolcJ8xQFaVNdMX7L2cpAkmDSglQxk9j0dJmjcLRdA222lmiSX1aw888MA4c08nO5sJRUeSwTaZJnRwXMpWiBllyh5QB4sZZgJgaTkLpRJoN5Zm9e/fv2DZuWqOwbKZ5zXnJZtFcM6SGZbdvZdzl3O4Y8eOcRDDACe7WVY6pyt5UJ3OTVYVMBjOLjlN1z6CYyxrY1PBVCqBa2jXrl09Fqvx1FNP5TdwS8gOZcl+CjZms+2oRUiAopIz8GZnsEdWMmVNqDFYfG9hEEi5hKSSz+ua4Lk99+Ul+LC8RPXInOX6yIZ3KSmCICN7SKQsx2uvvTZeL0mmcAn/TMX96YEDB+befPPN/NeXXHJJbFs2dqNsGf9P8BbcX7jXpHuQfmXN9NpZzcGGwGQ2G7CVpHm3UARtswFHsmhZug+CFNS+pGOTnV3t2bNnnPljRhUOpHMFQW86K2SLsTx1ueWWi/UD2Q2ULAgCt2SNMfufrXEr1bTUSSZYwzm7ww47xGORnagTjj+OQzLAOSY51wnyuhHMzPbjusjyc8oesMEYG3CkzGQ2E2Q5Klkl2XOZayNLMs16+u0N3M4444wYsCUDj/ZEakv+BsUbt1XyMTk7yys535l4yW78xNerrbaaq2JUFgEJMsKpL+oO6NVjhQHXR5ZGkwDAvee5554reE3fvn1jjdYzzzzTc7to0zHuwffdd1/u1VdfLQjgUv+XtqW9+KAUAveetCmeClkzvXYwEUPJI+r3S5IqPGibatOmWkVkgLJcOrsEleV/zEgXZ9yedtppMZuMGreaiU4g9X9ZXvXMM8/EjLKLLroot95668VZUzKhyGqk9uXaa68ds/Kk+emcc86Jgz4mY5hIIIuWHafZ2IDzm4EOgxuWsfG8tS5nDv7ef//9uOKALM/rr78+d+SRR8aBdKrJyKCFzQRLTb6kzGVVj3vK4osvHrNJUimebFty36HUhOZ8eSX3GbIZqdGYDdhW8nmt8vDJJ5/EYJnZd799faSfTdCM7NtSE1f03UvV+670Tccoc8ByfurXppUHKM5KvvDCC2OfyMnA0qyZXnuciJGkmlNng7bs4HvAAQfk/vvf/8avuRnTuWEAzSx01siRI2OWHvVrX3rppfzjBCvIJmPpcCWqbsDB4126dMm1bt06Bm5BkIwAGVkTtBudSWqT2dnW/EaGxGGHHRb/n2VWaTMYBioJAxY25rDcyUxk2LKigHM2i0ksMkkwZMgQs+XnEcEIJrkI4mQ3cCMbj8G3A5e5z2bkPM9mznteq9wYuJ01+pDch0iUoMZtYpCxdMCWeqqs3mBsw6aWTPxR47u6EhInnHBC7vDDDy9oWxWyZrokqa6rs0Fb6mERvDniiCNiUDYFKZidJkMnlUhIuEHTuSnuKKY6jpUmdUqo0UZQ55BDDol1nBI6LrQtWRLZDImEJS8ux1JNYyngVVddlbv66qvzu8++9957sbOdsusJhLVs2TJ2vLPZ9omDwV/17t07ZjildkwDEDZpZBLLmpZzJlvyIF0/UzYy5XfIYCZwy+CZe5DZofO+WRYZ4i5Rler2BpdsXusGl7PGOIZEiH333bfgcfrl9MO5HmZx72G1Ed/D2EezZs10SVJdVmeDtrjxxhtjLUuy8FLglgAPGbfUtywO3CaVHtTJzuovvfTSMSC255575ho0aBCXqhUHbllenTJupfmFTSGWWmqpOBnDMUe5AzbVIOOEzFAmGHiOpW4su6QcygorrFCQ3ajC6xy1all98OSTT8bHaEu+Zhdv/TYm+4YPHx5XGRQP5jg22QRv3Lhx8WtKxZAlRXboWmutZcC2BtmGUvlwg8uaR3ttsskmcRl/to4tdYAJzGbrJ7OZ29FHHx377++++24tveO6x5rpkqS6qk4GbbNBV+o0Erg99NBD84Fb6jiScbvXXnvld6pVIQJgbDbGBk+pA06Ah5n7Yiy9YhMJNt6R5lfAlkwcNt8gCEsZE4KzlEAYMWJEbuutt47lOthoLAXJ2JSDGq2VPglTPIieNGlSwXMMkskuoVbbSiutFDNtE7NJqnfPPffEpfkcdwQbrrvuuvyxR2YtEwts6pbF4wwKDdhKWhi5weX8X8bPZr/UTSablolsyiVkvfHGG7lrrrkmX0dds8+a6ZKkuqge/wl1wAcffBDat28fllpqqfj19OnTQ4MGDeL/33DDDeH+++8PHTp0CL179w5t27YNw4cPD9tuu23485//HK644opafvflYcaMGaF+/foE6kOPHj3CuHHjYts1bdo0Pn/ooYeGH374IT6/4YYbhn333Tesv/768bn99tsvvPHGG+Ef//hHWHTRRWv5N9HC5KWXXgrbb799PHd79eoVj7969eqFK6+8Mlx77bXhyy+/DGeffXYYMWJEuPPOO0ObNm0Kjufi60Gl+uyzz+I5e8opp4T9998/LLLIIvnnjj766PB///d/oVOnTuGZZ56Jj6V2VlW33nprOPHEE8P1118fWrduHV555ZVw8803hwcffDBsvfXWYauttortTLtWZ9q0aaFhw4YL9H1L0vyS7rn0x7kGHnHEEWG11VYL7733Xvjb3/4W7rjjjnDwwQeHzTbbLPYhb7rppir3mIkTJ4bFFlus1n6Hcvf555+Hk08+Ofz888/hww8/DF26dIn9oOJ+jveXeWvj7t27h+eeey6svPLKcbzYqFEj21SSVL5ydWBW/+uvv461GalJ+9133+Wfy2bYsdyXjcbuvvvu/GNffvmlWXhF2RFkLb711lu5b775pmBTtosvvjhXv379XLdu3eLGTyzH2nvvvQuWC/E90vza3ZcSHdkla1dccUUsf/Djjz/GrydOnJh/zgzRXJW2OOecc+J1kiWTZIlmy0ZwHnNukx1KhrKqxz2EdsxuaEn7sds0qzfSdVSSKo0bXC6YPhEbkNH/yfaJbNOaY810SVJd8muaWhljVn/ZZZcN9957b/jrX/8aLr/88vD999/H55hxZuYZp59+enxd//798xkBzKBmX1Pp2RHvv/9+zH546623wtJLLx222Wab+Py//vWvmEH71FNPxcxbsh0HDBgQHn/88fDOO+/kfw7fI9W0VVddNdx+++1hypQp4ZJLLolZEC+88EI8Dq+55prQsmXL+LpshrcZoqFKW7CygIzkww47LHTt2jVmhaaFFGSRcG6TiXvQQQeFJ554opbfdflK1zwybP9/CaHYflz/Fl988fg12WWSVGkeeuiheK/eaaed4tdkJ2LNNdeM9+qpU6eGjh07eo+exz4R4x3a9NJLLw2vv/56fNw2rTlrrLFG6Nu3b8ysNcNWklTuyj5omwbNBx54YAzcEsQpDtzSScTGG28cmjdvHv8/LZtOr6lU2eVsW265ZVzy261bt4LXrLjiinEZ8C677BLbmu/55ZdfYrkJA7VaUIMUOtCcqwcccEA8Fgnk7rPPPhU/6VIK52gpjz32WLw+smz1uOOOi8HZY445Jlx33XXxedp0hx12CCeccEKYNGnSAn7XdQP3GILeqZQEA2XacdCgQeHwww934CypYp177rnx+rj77rvHyX2CXd98800sj8B9u3HjxrX9FhcKq6yySuwTMWFIUgrlyTR/GLCVJJW7sr9TMUBOgVuyxEC9Rr6mJhHZtXQSmfkfOnRoWG+99Wr7LZddwJa6WFtssUWswUgmY0IQYvnllw+rr756PpuR9uaDrNslllgiHwSXFkTg9i9/+Us49thj4zHJoAUEcq2/WvW8JiP566+/jvWAQR3BJZdcMtbCu+WWW2JmcufOnWN2KLXbQBuSgfvtt99am7oatC1ZTrQz9RmZ5KKeLXVuaetsLWVJWliVutZxP77tttvic4cccki8Z19wwQXx/wkuwvt1zfWJqO1/3nnnxT09JElSZSrbjciynb6U/ZkyZgk6UJyf7FuWaC233HLhsssuC6NHj46z0c6azkRQh5IIBBseeOCB/OMXX3xxDEIQzGGZUPLVV1/FzSToiLMki2xbaUH64osvYkZ4yuohQ1xVS538/ve/D3369IkZtckmm2wSr4U77rhj3CTrvvvui1nzd911V/jjH/8YmjVrVqvvvxxRimPIkCFx9QbXSdop3XeOP/74GMAlcMtqBEmqpHsN9+O777479g3ZhPGoo47Kv8YNLhcMVhOawSxJUuWqX45BxtTpy8aTCdg+++yzMWt0v/32Cw8//HDcVZ7s0TPPPDN2aMi0JWDrcuqZaIuVVlopTJ48OV8Xi+XTBGUJ2mYDtp988kno2bNnuP/+++Nu6QZsVZvLAjnnOb8551W11AklDrIBW1BrlSAtu0+TLf/xxx/HzGUmuJ588smCa6p+LRdB27z55pvh3XffDXvttVcMdIN7EHWAaWOC3gMHDqzttytJC3SVFoFaro0//fRTvBayiiO58cYb44TWa6+9FvvnMGBb8wzYSpJU2coq05ZAIcurCDiwWQ6dP4KOBG+o1chSX+raMsjGDz/8ECZOnBgDtSwd4vUWlK+KZdQnnXRS7Pi1bds2bjBG/bGdd9654HXvvfdeXDLdtGnTWDZBqk1sjkcWD8sDK305enYQzSYvxaVOGDCvv/76cSPG0047LbRr1y7WYaXON3r06BHrEGYnaSodmWHUqCWDlolAykqwzPftt9+O9xuuhWl1x5///OfwyCOPhH79+sXAriQtzMiwpf45JWJYmcX9h8xa+pAXXXRRwWupoc79hutjWqkgSZKkhTBoO2bMmFi3ls4h2WEMpAnEvvrqq3H5FZvp0GmsjrUGq/fZZ5/FzDwyIuhwE9hJf3rauFevXrHDPXz48Hx9W6lceG7PutQJS/gHDx4cS8Tcc889cVk/Qdw06aVCTO6RIcYxddNNN+Wzw2hXVm4wYVBcSoJN8cg2oxa4JC2s91n6hkz0jRs3Lq42YCIfhx56aEyW4HnuRfTXuc+A/jrlybh2Wi9dkiRpIQrapk5iypD97rvvYseQnc0JMrLp2MsvvxwmTJgQ9thjj9p8q3Ue5SQI5hDEoQwCNTFBwJbamJRP2GijjWr7bUoq4V//+lccGC+99NLhjDPOiCUSKHVy9dVXx5qDu+66a3wdqw8WW2yx+P8Gu6t69NFHQ4sWLcL48eNjrcADDjigoEQM7chy4FatWlVZ6mt7SloYpWsbE/xcG9nkl//fZptt4vOs7KCvSImENm3axBUK9CGZ6GrUqFF8DRtccn+SJEnSQhS0HTVqVFzKm0W22GGHHRaDD5RL2HvvvePjbnBQc6USaEs2LCJr7Pzzz48ZuAZspbpb6iSbVUvwca211qrtt1t2qMdI+R2uewQcsptd8v///ve/w1ZbbRU3JmODS7DsN7vk18CtpIV1g0uuf1dccUVciZCdMGRT0EMOOSTssssu8THqgFOqh2vl5ptvXovvXpIkaeFWqyNPlvFSi5b6taeeemqsocUSYIIRbIbVunXrWM+SOo10KhlU81lzb9VVV42bPJEZQeebjrgBW6nunL9sIvi///0vBmtZyk/AlqBjCiSSDUU5GZa2llH1m1pHCYkTTzwxbjTG5jrZCcC08SUrPAh+pxIx1HRMk1yJAVtJC+sGl1wjswFbrLjiijGzlj4j10K+hw0v2azWzFpJkqT5q1ZHn8zqY8SIEXFp/k477RQH0wQiqI118803h0UWWSQ8+OCD4aGHHioITGjeAj9XXXVVzI5g8zEDtlLdsdpqq8VrI5mi1LGl5jdBx1SbmokuMnAJPLoy4Ve33XZbDL5yH6E2bcJGd1999VX+a8r0kMVMQIJyPKwEIbs5BXUlaWHc4HKLLbaIG1yyAithRQL9c6SJLK6FfM9TTz0VllhiidC8efNae/+SJEmVoFbLIzBAPuuss+KS1QEDBsQA7bBhw2LAgYAuy3spkUCHcoUVVogD7+2226623u5Ch8BEqkUmqW6x1Mnseemll+Lmbb17945B7YSgLJtfDhw4MAYfwEoPJg4J3HJ/+vTTT+M1MtVcl6RK2eDy1ltvDc8991xYY4018o8zyXXHHXfEFR8kW5BtK0mSpPmnfm10EAnEgkEwG2D96U9/itlP33//fVyWxQw+s/tsQsbyVDaNWWaZZeJgWjXHgK1Ud1nqZPZw76BO4zvvvBPefvvt+Bj3nJEjR8YgBQHbNHfJhpfUtW3WrFm8BxmwlbQwoxzMSiutFCZPnhyDsGCDS4KyBG2zAVtqpbOJLeXLXnnlFQO2kiRJC1umLUtTjz/++LjbOYNmMmuTrl27xgE0r0m7oGc3QVh++eXjkqzsZjuSVOkILp5xxhnh0ksvDWuvvXZtv52yzkrm3sHO6NSuffTRR2OtxrQJGZ9ffPHF8PPPP8cgOIFaA7aSKnmDyyzKaS266KKhadOmsU8uSZKkhSRomwbFRx99dKwhuOSSS4ZrrrkmdO7cOWY0JYcffnh45JFHwsMPPxw30inmrt2SVJWlTmYvMMGkISV4KLWz7777FtxTmCwkoEu2GfcrA7aSKsVnn30WTjjhhLha46KLLgqnnXZafgVCqpfer1+/MHz48Hx9W0mSJC0kQds0MO7fv3/44YcfwnfffRfLIrCbd5cuXQpe++c//zkGbu+8886w5557zu+3JkmqEF9++WUswcP9iHrqqeTObrvtFr744ovw8ccfx+B3mmiUpEq6PjKxxYoEyiCw2SUI2NJnZ0LL8juSJEkLcXkEyh9QJ2vIkCEx65blV2xCRtYTXx966KFxsEzpBGoLsrGOJEk1vRSYwO3ZZ58dV3189NFH8cMatpIqmRtcSpIkVVDQlpqBzZs3DzvuuGPsADKLf8QRR4RXX301Pn/cccfFjQ7YUGfw4MFxw5jEUgiSpPkVmOjevXvcGX3llVeOS34N2ErSr9fHU089Nbz11lvhxx9/DEOHDjVgK0mSVEvmW1SUDNoDDzwwX2eRpaarrLJK+N///he++uqr+Nibb74Zll566biLNzvRsgFM/o3Vrx8Dt5Ik1SQmCq+66qpw7LHHmmErSSWuj5tvvnncfMyArSRJ0kIWtKVW7Yknnhjuv//+sM0228THUkIvQdoPP/wwdOzYMbRo0SL85z//iXVsDz744HwGbv7NmWkrSZoP1lhjjdC3b98YqDVgK0kzrb766nFT4LXXXru234okSVJFq/GoKPVpqYf10EMPhb333rvg8dGjR4d11103Pt60adNw3333xecYOF955ZVhhx12qOm3I0nSLBmwlaRCaaWcJEmSFpKati+99FLYfvvtQ+/eveNus8kee+wRA7bPP/98rJFFfSw2Hmvbtm2YPn163Kk2MeNJkiRJkiRJUiWr0aAtmxd07do1LLHEEuG8884LG2+8cfjTn/4UH3/sscfihi/IBmrdcEySJEmSJEmS5lPQFgRoKY9AUHb8+PFh0qRJ4dFHHw0rrrhiQbD2tddeC1tttVVN/tOSJEmSJEmSVOfVeNA2BW6PP/74MGzYsFjLdt999y3IqN11113DuHHjwpAhQ0K9evVq+p+XJEmSJEmSpDprvgRt8eWXX4Zu3brFQO1ZZ50Vtt566/j4brvtFp/76KOP3ORAkiRJkiRJkhZU0DZbKoHA7dlnnx2uueaaGKxNAVs3HZMkSZIkSZKkQvN1B7BVV1019O3bN5ZA2G677cLHH39swFaSJEmSJEmSaivTNvn000/DTTfdFDNtCdQasJUkSZIkSZKkWgzaZhmwlSRJkiRJkqQyCtpKkiRJkiRJkmqppq0kSZIkSZIkac4YtJUkSZIkSZKkMmLQVpIkSZIkSZLKiEFbSZIkSZIkSSojBm0lSZIkSZIk6f+1d+8gcSxQGIDPgoKColamEQwomiIIPpoUaRQMioVgpSA2SWUpKSxEsBWxFivBgIUKtj6wsdHCpPKBiIgPsEljmigadkgWLhcueyEws8n3wcDsPODf9udwJkOUtgAAAAAAGaK0BQAAAADIEKUtAAD8lMvl/vOYnp5OOyIAAH+BsrQDAABAVtze3hbOV1ZWYmpqKk5OTgrXqqqqUkoGAMDfxKQtAAD89OLFi8JRU1OTTNf++v3t27cYGRmJ+vr6pLzt6uqKra2tf5W+/f39UVlZGS9fvoxPnz5FY2NjzM/Pp/afAAAoPUpbAAAowv39ffT19cX29nYcHh7Gu3fvYmBgIC4vLwvPjI6Oxs3NTezu7sbq6mosLCzE3d1dqrkBACg91iMAAEAR2trakuOXmZmZWF9fj42NjRgfH4/j4+Nk8vbg4CA6OzuTZxYXF6O5uTnF1AAAlCKTtgAAUOSk7cTERLx69Spqa2uTFQlHR0eFSdv87tuysrJob28vvNPU1BR1dXUppgYAoBSZtAUAgCLkC9vNzc2YnZ1Nytj83tqhoaH4/v172tEAAPjDKG0BAKAIe3t7MTY2FoODg4XJ24uLi8L9lpaWeHx8TPbddnR0JNfOzs7i69evqWUGAKA0WY8AAABFyO+mXVtbi8+fP8eXL19ieHg4np6eCvdbW1ujp6cnPnz4EPv7+0l5mz/PT+TmcrlUswMAUFqUtgAAUIS5ublkP+2bN29iYGAgent7/7G/Nm9paSnq6+vj7du3yUTu+/fvo7q6OioqKlLLDQBA6ck9Pz8/px0CAAD+RFdXV9HQ0BBbW1vR3d2ddhwAAEqE0hYAAH6TnZ2dZNft69ev4/b2Nj5+/BjX19dxenoa5eXlaccDAKBE+BAZAAD8Jg8PDzE5ORnn5+fJWoT8KoXl5WWFLQAA/4tJWwAAAACADPEhMgAAAACADFHaAgAAAABkiNIWAAAAACBDlLYAAAAAABmitAUAAAAAyBClLQAAAABAhihtAQAAAAAyRGkLAAAAAJAhSlsAAAAAgMiOH/S7tQxMMP9MAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\2269313953.py:27: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\2269313953.py:27: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\EL081\\AppData\\Local\\Temp\\ipykernel_24680\\2269313953.py:27: FutureWarning: \n", + "\n", + "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n", + "\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show tag distribution for each source folder\n", + "all_source_tag_dfs = []\n", + "for source in sources:\n", + " source_path = os.path.join(image_root, source)\n", + " tag_counter = Counter()\n", + " for label_folder in os.listdir(source_path):\n", + " label_path = os.path.join(source_path, label_folder)\n", + " if not os.path.isdir(label_path):\n", + " continue\n", + " tags = label_folder.split('_')\n", + " img_count = len([f for f in os.listdir(label_path) if f.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp', '.gif'))])\n", + " for tag in tags:\n", + " tag_counter[tag] += img_count\n", + " source_tag_df = pd.DataFrame(tag_counter.items(), columns=[\"Tag\", \"Count\"]).sort_values(by=\"Count\", ascending=False)\n", + " source_tag_df[\"Source\"] = source\n", + " all_source_tag_dfs.append(source_tag_df)\n", + "\n", + "# Concatenate all source tag dataframes\n", + "all_sources_df = pd.concat(all_source_tag_dfs, ignore_index=True)\n", + "display(all_sources_df)\n", + "\n", + "# Visualize for each source\n", + "import seaborn as sns\n", + "for source in sources:\n", + " plt.figure(figsize=(14, 6))\n", + " df = all_sources_df[all_sources_df[\"Source\"] == source]\n", + " sns.barplot(x=\"Tag\", y=\"Count\", data=df, palette=\"viridis\")\n", + " plt.xticks(rotation=45, ha='right')\n", + " plt.title(f\"Image Count per Tag in Source: {source}\")\n", + " plt.xlabel(\"Tag\")\n", + " plt.ylabel(\"Image Count\")\n", + " plt.tight_layout()\n", + " plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/unsplash_api_notebook.ipynb b/unsplash_api_notebook.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d2d7e550e79d8c3ccb52d8e99ed8008a15317fa9 --- /dev/null +++ b/unsplash_api_notebook.ipynb @@ -0,0 +1,1833 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a7e904d2", + "metadata": {}, + "source": [ + "# Unsplash API 활용 노트북 📸\n", + "\n", + "이 노트북은 Unsplash API를 사용하여 고품질 이미지를 검색하고 활용하는 방법을 다룹니다.\n", + "\n", + "## 📋 목차\n", + "1. [환경 설정 및 라이브러리 설치](#setup)\n", + "2. [API 키 설정 및 인증](#auth)\n", + "3. [기본 사진 검색](#search)\n", + "4. [랜덤 사진 가져오기](#random)\n", + "5. [특정 사진 정보 조회](#photo-info)\n", + "6. [컬렉션 탐색](#collections)\n", + "7. [토픽별 사진 검색](#topics)\n", + "8. [사진 다운로드 및 저장](#download)\n", + "9. [이미지 크기 조정 및 변환](#resize)\n", + "10. [데이터 시각화 및 분석](#visualization)\n", + "\n", + "---\n", + "\n", + "## 🔗 유용한 링크\n", + "- [Unsplash API 문서](https://unsplash.com/documentation)\n", + "- [개발자 계정 등록](https://unsplash.com/oauth/applications)\n", + "- [API 사용 가이드라인](https://help.unsplash.com/api-guidelines/unsplash-api-guidelines)" + ] + }, + { + "cell_type": "markdown", + "id": "c1c26a79", + "metadata": {}, + "source": [ + "## 1. 환경 설정 및 라이브러리 설치 \n", + "\n", + "Unsplash API를 사용하기 위해 필요한 라이브러리들을 설치합니다." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "031e0855", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: requests in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (2.32.5)\n", + "Requirement already satisfied: pillow in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (11.3.0)\n", + "Requirement already satisfied: pandas in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (2.3.2)\n", + "Requirement already satisfied: matplotlib in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (3.10.6)\n", + "Requirement already satisfied: seaborn in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (0.13.2)\n", + "Requirement already satisfied: plotly in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (6.3.1)\n", + "Collecting ipywidgets\n", + " Downloading ipywidgets-8.1.8-py3-none-any.whl.metadata (2.4 kB)\n", + "Requirement already satisfied: python-dotenv in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (1.2.1)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests) (3.4.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests) (2025.10.5)\n", + "Requirement already satisfied: numpy>=1.23.2 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas) (1.26.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from pandas) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from pandas) (2025.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (4.60.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (1.4.9)\n", + "Requirement already satisfied: packaging>=20.0 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from matplotlib) (25.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from matplotlib) (3.2.5)\n", + "Requirement already satisfied: narwhals>=1.15.1 in c:\\users\\el081\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from plotly) (2.10.0)\n", + "Requirement already satisfied: comm>=0.1.3 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipywidgets) (0.2.3)\n", + "Requirement already satisfied: ipython>=6.1.0 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipywidgets) (9.5.0)\n", + "Requirement already satisfied: traitlets>=4.3.1 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipywidgets) (5.14.3)\n", + "Collecting widgetsnbextension~=4.0.14 (from ipywidgets)\n", + " Downloading widgetsnbextension-4.0.15-py3-none-any.whl.metadata (1.6 kB)\n", + "Collecting jupyterlab_widgets~=3.0.15 (from ipywidgets)\n", + " Downloading jupyterlab_widgets-3.0.16-py3-none-any.whl.metadata (20 kB)\n", + "Requirement already satisfied: colorama in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (0.4.6)\n", + "Requirement already satisfied: decorator in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (5.2.1)\n", + "Requirement already satisfied: ipython-pygments-lexers in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (1.1.1)\n", + "Requirement already satisfied: jedi>=0.16 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (0.19.2)\n", + "Requirement already satisfied: matplotlib-inline in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (0.1.7)\n", + "Requirement already satisfied: prompt_toolkit<3.1.0,>=3.0.41 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (3.0.52)\n", + "Requirement already satisfied: pygments>=2.4.0 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (2.19.2)\n", + "Requirement already satisfied: stack_data in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (0.6.3)\n", + "Requirement already satisfied: typing_extensions>=4.6 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from ipython>=6.1.0->ipywidgets) (4.15.0)\n", + "Requirement already satisfied: wcwidth in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from prompt_toolkit<3.1.0,>=3.0.41->ipython>=6.1.0->ipywidgets) (0.2.13)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.4 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from jedi>=0.16->ipython>=6.1.0->ipywidgets) (0.8.5)\n", + "Requirement already satisfied: six>=1.5 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n", + "Requirement already satisfied: executing>=1.2.0 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from stack_data->ipython>=6.1.0->ipywidgets) (2.2.1)\n", + "Requirement already satisfied: asttokens>=2.1.0 in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from stack_data->ipython>=6.1.0->ipywidgets) (3.0.0)\n", + "Requirement already satisfied: pure-eval in c:\\users\\el081\\appdata\\roaming\\python\\python311\\site-packages (from stack_data->ipython>=6.1.0->ipywidgets) (0.2.3)\n", + "Downloading ipywidgets-8.1.8-py3-none-any.whl (139 kB)\n", + "Downloading jupyterlab_widgets-3.0.16-py3-none-any.whl (914 kB)\n", + " ---------------------------------------- 0.0/914.9 kB ? eta -:--:--\n", + " ---------------------------------------- 914.9/914.9 kB 40.8 MB/s 0:00:00\n", + "Downloading widgetsnbextension-4.0.15-py3-none-any.whl (2.2 MB)\n", + " ---------------------------------------- 0.0/2.2 MB ? eta -:--:--\n", + " ---------------------------------------- 2.2/2.2 MB 30.7 MB/s 0:00:00\n", + "Installing collected packages: widgetsnbextension, jupyterlab_widgets, ipywidgets\n", + "\n", + " ------------- -------------------------- 1/3 [jupyterlab_widgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " -------------------------- ------------- 2/3 [ipywidgets]\n", + " ---------------------------------------- 3/3 [ipywidgets]\n", + "\n", + "Successfully installed ipywidgets-8.1.8 jupyterlab_widgets-3.0.16 widgetsnbextension-4.0.15\n" + ] + } + ], + "source": [ + "# 필수 패키지 설치\n", + "!pip install requests pillow pandas matplotlib seaborn plotly ipywidgets python-dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31b49e0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ 모든 라이브러리가 성공적으로 로드되었습니다!\n", + "📁 이미지 저장 폴더: c:\\Users\\EL081\\Desktop\\apitest\\unsplash_images\n" + ] + } + ], + "source": [ + "# 필요한 라이브러리 import\n", + "import requests\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from PIL import Image\n", + "import io\n", + "import os\n", + "from datetime import datetime\n", + "import warnings\n", + "from pathlib import Path\n", + "\n", + "# 경고 메시지 숨기기\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# 시각화 스타일 설정\n", + "plt.style.use('seaborn-v0_8')\n", + "sns.set_palette(\"husl\")\n", + "\n", + "# 결과 디렉토리 생성\n", + "os.makedirs('unsplash_images', exist_ok=True)\n", + "\n", + "print(\"✅ 모든 라이브러리가 성공적으로 로드되었습니다!\")\n", + "print(f\"📁 이미지 저장 폴더: {os.path.abspath('unsplash_images')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7659b7fe", + "metadata": {}, + "source": [ + "## 2. API 키 설정 및 인증 \n", + "\n", + "Unsplash API를 사용하기 위해 API 키를 설정합니다.\n", + "\n", + "### 🔑 API 키 발급 방법:\n", + "1. [Unsplash 개발자 페이지](https://unsplash.com/oauth/applications)에서 계정 생성\n", + "2. \"New Application\" 클릭하여 새 앱 등록\n", + "3. 필요한 정보 입력 후 Access Key 획득\n", + "4. 아래 셀에서 YOUR_ACCESS_KEY를 실제 키로 교체" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f4ab177c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ API 연결 성공!\n", + "📊 남은 요청 수: 49/50\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Unsplash API 설정\n", + "ACCESS_KEY = \"lvjBXnPmNTRiBbZv21wQlibHSSBwzeNicqVYsKiSRks\" # 실제 Access Key로 변경하세요\n", + "BASE_URL = \"https://api.unsplash.com\"\n", + "\n", + "# API 헤더 설정\n", + "headers = {\n", + " \"Authorization\": f\"Client-ID {ACCESS_KEY}\"\n", + "}\n", + "\n", + "# Unsplash API 클래스\n", + "class UnsplashAPI:\n", + " def __init__(self, access_key):\n", + " self.access_key = access_key\n", + " self.base_url = \"https://api.unsplash.com\"\n", + " self.headers = {\"Authorization\": f\"Client-ID {access_key}\"}\n", + " \n", + " def get_request(self, endpoint, params=None):\n", + " \"\"\"API 요청을 보내고 응답을 반환\"\"\"\n", + " url = f\"{self.base_url}{endpoint}\"\n", + " try:\n", + " response = requests.get(url, headers=self.headers, params=params)\n", + " response.raise_for_status()\n", + " return response.json()\n", + " except requests.exceptions.RequestException as e:\n", + " print(f\"❌ API 요청 오류: {e}\")\n", + " return None\n", + " \n", + " def check_rate_limit(self, response):\n", + " \"\"\"남은 요청 수 확인\"\"\"\n", + " if hasattr(response, 'headers'):\n", + " remaining = response.headers.get('X-Ratelimit-Remaining')\n", + " limit = response.headers.get('X-Ratelimit-Limit')\n", + " if remaining and limit:\n", + " print(f\"⚡ API 사용량: {limit - int(remaining)}/{limit}\")\n", + "\n", + "# API 인스턴스 생성\n", + "api = UnsplashAPI(ACCESS_KEY)\n", + "\n", + "# API 연결 테스트\n", + "def test_api_connection():\n", + " \"\"\"API 연결 상태 테스트\"\"\"\n", + " if ACCESS_KEY == \"YOUR_ACCESS_KEY_HERE\":\n", + " print(\"⚠️ API 키를 설정해주세요!\")\n", + " return False\n", + " \n", + " response = requests.get(f\"{BASE_URL}/photos\", headers=headers, params={'per_page': 1})\n", + " if response.status_code == 200:\n", + " remaining = response.headers.get('X-Ratelimit-Remaining', 'Unknown')\n", + " limit = response.headers.get('X-Ratelimit-Limit', 'Unknown')\n", + " print(\"✅ API 연결 성공!\")\n", + " print(f\"📊 남은 요청 수: {remaining}/{limit}\")\n", + " return True\n", + " else:\n", + " print(f\"❌ API 연결 실패: {response.status_code}\")\n", + " return False\n", + "\n", + "# API 연결 테스트 실행\n", + "test_api_connection()" + ] + }, + { + "cell_type": "markdown", + "id": "cbe13fe4", + "metadata": {}, + "source": [ + "## 3. 기본 사진 검색 \n", + "\n", + "키워드를 사용하여 Unsplash에서 사진을 검색하는 방법을 알아봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c8d56c78", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔍 'soft' 검색 결과: 8661개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "\n", + "📊 검색 결과 요약:\n", + " photographer description likes \\\n", + "0 Evie S. Macro shot of White Feather 3960 \n", + "1 Nico Frey None 2048 \n", + "2 Matt Palmer A nice gentle sky for use as an element or bac... 801 \n", + "3 Vai Da None 2228 \n", + "4 Rue S Satin 3099 \n", + "\n", + " width height \n", + "0 6016 4016 \n", + "1 8192 5461 \n", + "2 2592 3888 \n", + "3 2666 4000 \n", + "4 3024 4032 \n" + ] + } + ], + "source": [ + "def search_photos(query, per_page=10, page=1, orientation=None, color=None, order_by=\"relevant\"):\n", + " \"\"\"\n", + " 키워드로 사진 검색\n", + " \n", + " Parameters:\n", + " - query: 검색 키워드\n", + " - per_page: 페이지당 결과 수 (최대 30)\n", + " - page: 페이지 번호\n", + " - orientation: 'landscape', 'portrait', 'squarish' 중 선택\n", + " - color: 'black_and_white', 'black', 'white', 'yellow', 'orange', 'red', 'purple', 'magenta', 'green', 'teal', 'blue'\n", + " - order_by: 'relevant' 또는 'latest'\n", + " \"\"\"\n", + " params = {\n", + " \"query\": query,\n", + " \"per_page\": per_page,\n", + " \"page\": page,\n", + " \"order_by\": order_by\n", + " }\n", + " \n", + " if orientation:\n", + " params[\"orientation\"] = orientation\n", + " if color:\n", + " params[\"color\"] = color\n", + " \n", + " data = api.get_request(\"/search/photos\", params)\n", + " \n", + " if data and \"results\" in data:\n", + " print(f\"🔍 '{query}' 검색 결과: {data['total']}개 사진 발견\")\n", + " print(f\"📄 현재 페이지: {page}, 결과 수: {len(data['results'])}\")\n", + " \n", + " # 검색 결과를 DataFrame으로 변환\n", + " photos_data = []\n", + " for photo in data[\"results\"]:\n", + " photos_data.append({\n", + " \"id\": photo[\"id\"],\n", + " \"description\": photo.get(\"description\", \"설명 없음\"),\n", + " \"alt_description\": photo.get(\"alt_description\", \"대체 설명 없음\"),\n", + " \"width\": photo[\"width\"],\n", + " \"height\": photo[\"height\"],\n", + " \"color\": photo[\"color\"],\n", + " \"likes\": photo[\"likes\"],\n", + " \"photographer\": photo[\"user\"][\"name\"],\n", + " \"photographer_username\": photo[\"user\"][\"username\"],\n", + " \"download_url\": photo[\"links\"][\"download\"],\n", + " \"regular_url\": photo[\"urls\"][\"regular\"],\n", + " \"small_url\": photo[\"urls\"][\"small\"],\n", + " \"thumb_url\": photo[\"urls\"][\"thumb\"]\n", + " })\n", + " \n", + " df = pd.DataFrame(photos_data)\n", + " return df, data\n", + " else:\n", + " print(\"❌ 검색 결과를 가져올 수 없습니다.\")\n", + " return None, None\n", + "\n", + "# 예시: 자연 사진 검색\n", + "search_query = \"soft\"\n", + "df_results, raw_data = search_photos(search_query, per_page=5)\n", + "\n", + "if df_results is not None:\n", + " print(\"\\n📊 검색 결과 요약:\")\n", + " print(df_results[[\"photographer\", \"description\", \"likes\", \"width\", \"height\"]].head())" + ] + }, + { + "cell_type": "markdown", + "id": "e8c812c4", + "metadata": {}, + "source": [ + "## 4. 랜덤 사진 가져오기 \n", + "\n", + "Unsplash에서 랜덤 사진을 가져오는 방법을 알아봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "92f56087", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🎲 랜덤 사진 3개를 가져왔습니다!\n", + "\n", + "📸 사진 1:\n", + " ID: Bkci_8qcdvQ\n", + " 작가: Kalen Emsley (@kalenemsley)\n", + " 크기: 5760 x 3840\n", + " 좋아요: 7862\n", + " 설명: travelyukon, Wet mountain valley...\n", + " 다운로드 URL: https://images.unsplash.com/photo-1464822759023-fed622ff2c3b?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w4MzAwMjl8MHwxfHJhbmRvbXx8fHx8fHx8fDE3NjI5OTcwMjV8&ixlib=rb-4.1.0&q=80&w=1080\n", + "\n", + "📸 사진 2:\n", + " ID: U8FEzONZCsg\n", + " 작가: Etienne Delorieux (@etiennedelorieux)\n", + " 크기: 3872 x 2592\n", + " 좋아요: 283\n", + " 설명: Green mountains...\n", + " 다운로드 URL: https://images.unsplash.com/photo-1495710388177-22c73fa5f84e?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w4MzAwMjl8MHwxfHJhbmRvbXx8fHx8fHx8fDE3NjI5OTcwMjV8&ixlib=rb-4.1.0&q=80&w=1080\n", + "\n", + "📸 사진 3:\n", + " ID: 2Hzmz15wGik\n", + " 작가: pine watt (@pinewatt)\n", + " 크기: 5184 x 3456\n", + " 좋아요: 3847\n", + " 설명: Nov in Sierra...\n", + " 다운로드 URL: https://images.unsplash.com/photo-1511884642898-4c92249e20b6?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w4MzAwMjl8MHwxfHJhbmRvbXx8fHx8fHx8fDE3NjI5OTcwMjV8&ixlib=rb-4.1.0&q=80&w=1080\n", + "\n", + "==================================================\n", + "🎲 랜덤 사진 1개를 가져왔습니다!\n", + "\n", + "📸 사진 1:\n", + " ID: h_p4BbwgEQM\n", + " 작가: Julio Lopez (@juliolopez)\n", + " 크기: 4335 x 6503\n", + " 좋아요: 47\n", + " 다운로드 URL: https://images.unsplash.com/photo-1760625525477-f725e48f5a13?crop=entropy&cs=tinysrgb&fit=max&fm=jpg&ixid=M3w4MzAwMjl8MHwxfHJhbmRvbXx8fHx8fHx8fDE3NjI5OTcwMjV8&ixlib=rb-4.1.0&q=80&w=1080\n" + ] + } + ], + "source": [ + "def get_random_photos(count=1, query=None, orientation=None, collections=None):\n", + " \"\"\"\n", + " 랜덤 사진 가져오기\n", + " \n", + " Parameters:\n", + " - count: 가져올 사진 수 (최대 30)\n", + " - query: 특정 키워드로 필터링\n", + " - orientation: 'landscape', 'portrait', 'squarish'\n", + " - collections: 컬렉션 ID로 필터링\n", + " \"\"\"\n", + " params = {}\n", + " \n", + " if count > 1:\n", + " params[\"count\"] = count\n", + " if query:\n", + " params[\"query\"] = query\n", + " if orientation:\n", + " params[\"orientation\"] = orientation\n", + " if collections:\n", + " params[\"collections\"] = collections\n", + " \n", + " data = api.get_request(\"/photos/random\", params)\n", + " \n", + " if data:\n", + " # count > 1이면 리스트, 아니면 단일 객체\n", + " photos = data if isinstance(data, list) else [data]\n", + " \n", + " print(f\"🎲 랜덤 사진 {len(photos)}개를 가져왔습니다!\")\n", + " \n", + " # 사진 정보 출력\n", + " for i, photo in enumerate(photos, 1):\n", + " print(f\"\\n📸 사진 {i}:\")\n", + " print(f\" ID: {photo['id']}\")\n", + " print(f\" 작가: {photo['user']['name']} (@{photo['user']['username']})\")\n", + " print(f\" 크기: {photo['width']} x {photo['height']}\")\n", + " print(f\" 좋아요: {photo['likes']}\")\n", + " if photo.get('description'):\n", + " print(f\" 설명: {photo['description'][:100]}...\")\n", + " print(f\" 다운로드 URL: {photo['urls']['regular']}\")\n", + " \n", + " return photos\n", + " else:\n", + " print(\"❌ 랜덤 사진을 가져올 수 없습니다.\")\n", + " return None\n", + "\n", + "# 예시: 자연 관련 랜덤 사진 3개 가져오기\n", + "random_photos = get_random_photos(count=3, query=\"landscape\")\n", + "\n", + "# 예시: 세로 방향 랜덤 사진 1개 가져오기\n", + "print(\"\\n\" + \"=\"*50)\n", + "portrait_photo = get_random_photos(count=1, orientation=\"portrait\")" + ] + }, + { + "cell_type": "markdown", + "id": "bd865f8f", + "metadata": {}, + "source": [ + "## 5. 특정 사진 정보 조회 \n", + "\n", + "특정 사진의 상세 정보를 조회하고 통계를 확인해봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb7e49d3", + "metadata": {}, + "outputs": [], + "source": [ + "def get_photo_details(photo_id):\n", + " \"\"\"특정 사진의 상세 정보 가져오기\"\"\"\n", + " data = api.get_request(f\"/photos/{photo_id}\")\n", + " \n", + " if data:\n", + " print(f\"📸 사진 상세 정보 (ID: {photo_id})\")\n", + " print(\"=\"*50)\n", + " print(f\"작가: {data['user']['name']} (@{data['user']['username']})\")\n", + " print(f\"크기: {data['width']} x {data['height']} px\")\n", + " print(f\"좋아요: {data['likes']}\")\n", + " print(f\"다운로드 수: {data.get('downloads', 'N/A')}\")\n", + " print(f\"색상: {data['color']}\")\n", + " print(f\"생성일: {data['created_at']}\")\n", + " \n", + " if data.get('description'):\n", + " print(f\"설명: {data['description']}\")\n", + " \n", + " if data.get('location') and data['location'].get('name'):\n", + " print(f\"촬영 장소: {data['location']['name']}\")\n", + " \n", + " if data.get('exif'):\n", + " exif = data['exif']\n", + " print(\"\\n📷 카메라 정보:\")\n", + " if exif.get('make'): print(f\" 브랜드: {exif['make']}\")\n", + " if exif.get('model'): print(f\" 모델: {exif['model']}\")\n", + " if exif.get('iso'): print(f\" ISO: {exif['iso']}\")\n", + " if exif.get('aperture'): print(f\" 조리개: f/{exif['aperture']}\")\n", + " if exif.get('focal_length'): print(f\" 초점거리: {exif['focal_length']}mm\")\n", + " \n", + " return data\n", + " else:\n", + " print(\"❌ 사진 정보를 가져올 수 없습니다.\")\n", + " return None\n", + "\n", + "def get_photo_statistics(photo_id):\n", + " \"\"\"사진 통계 정보 가져오기\"\"\"\n", + " data = api.get_request(f\"/photos/{photo_id}/statistics\")\n", + " \n", + " if data:\n", + " print(f\"\\n📊 사진 통계 (ID: {photo_id})\")\n", + " print(\"=\"*50)\n", + " \n", + " downloads = data.get('downloads', {})\n", + " views = data.get('views', {})\n", + " likes = data.get('likes', {})\n", + " \n", + " print(f\"총 다운로드: {downloads.get('total', 'N/A')}\")\n", + " print(f\"총 조회수: {views.get('total', 'N/A')}\")\n", + " print(f\"총 좋아요: {likes.get('total', 'N/A')}\")\n", + " \n", + " # 최근 30일 통계\n", + " if downloads.get('historical'):\n", + " recent_downloads = downloads['historical'].get('change', 0)\n", + " print(f\"최근 30일 다운로드: {recent_downloads}\")\n", + " \n", + " return data\n", + " else:\n", + " print(\"❌ 통계 정보를 가져올 수 없습니다.\")\n", + " return None\n", + "\n", + "# 예시: 임의의 사진 ID로 정보 조회 (실제 사용 시 유효한 사진 ID 필요)\n", + "sample_photo_id = \"tAKXap853rY\" # 예시 ID\n", + "\n", + "photo_details = get_photo_details(sample_photo_id)\n", + "photo_stats = get_photo_statistics(sample_photo_id)" + ] + }, + { + "cell_type": "markdown", + "id": "e5db525f", + "metadata": {}, + "source": [ + "## 6. 사진 다운로드 및 저장 \n", + "\n", + "Unsplash에서 사진을 다운로드하고 로컬에 저장하는 방법을 알아봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b6113b8f", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'raw_data' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 75\u001b[39m\n\u001b[32m 72\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 74\u001b[39m \u001b[38;5;66;03m# 예시: 검색 결과에서 첫 번째 사진 다운로드\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m75\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[43mraw_data\u001b[49m \u001b[38;5;129;01mand\u001b[39;00m raw_data.get(\u001b[33m'\u001b[39m\u001b[33mresults\u001b[39m\u001b[33m'\u001b[39m):\n\u001b[32m 76\u001b[39m first_photo = raw_data[\u001b[33m'\u001b[39m\u001b[33mresults\u001b[39m\u001b[33m'\u001b[39m][\u001b[32m0\u001b[39m]\n\u001b[32m 77\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33m🖼️ 첫 번째 검색 결과 사진을 다운로드합니다...\u001b[39m\u001b[33m\"\u001b[39m)\n", + "\u001b[31mNameError\u001b[39m: name 'raw_data' is not defined" + ] + } + ], + "source": [ + "def download_photo(photo_url, filename, folder=\"unsplash_images\"):\n", + " \"\"\"\n", + " 사진을 다운로드하고 저장\n", + " \n", + " Parameters:\n", + " - photo_url: 다운로드할 사진의 URL\n", + " - filename: 저장할 파일명\n", + " - folder: 저장할 폴더명\n", + " \"\"\"\n", + " try:\n", + " response = requests.get(photo_url)\n", + " response.raise_for_status()\n", + " \n", + " # 폴더 생성\n", + " os.makedirs(folder, exist_ok=True)\n", + " \n", + " # 파일 저장\n", + " filepath = os.path.join(folder, filename)\n", + " with open(filepath, 'wb') as f:\n", + " f.write(response.content)\n", + " \n", + " print(f\"✅ 사진이 저장되었습니다: {filepath}\")\n", + " return filepath\n", + " \n", + " except Exception as e:\n", + " print(f\"❌ 다운로드 실패: {e}\")\n", + " return None\n", + "\n", + "def download_and_display_photo(photo_data, size=\"regular\", display=True):\n", + " \"\"\"\n", + " 사진을 다운로드하고 화면에 표시\n", + " \n", + " Parameters:\n", + " - photo_data: API에서 받은 사진 데이터\n", + " - size: 'raw', 'full', 'regular', 'small', 'thumb' 중 선택\n", + " - display: 이미지를 화면에 표시할지 여부\n", + " \"\"\"\n", + " try:\n", + " # URL 가져오기\n", + " photo_url = photo_data['urls'][size]\n", + " \n", + " # 파일명 생성\n", + " photographer = photo_data['user']['username']\n", + " photo_id = photo_data['id']\n", + " filename = f\"{photographer}_{photo_id}_{size}.jpg\"\n", + " \n", + " # 다운로드\n", + " filepath = download_photo(photo_url, filename)\n", + " \n", + " if filepath and display:\n", + " # 이미지 로드 및 표시\n", + " img = Image.open(filepath)\n", + " \n", + " plt.figure(figsize=(10, 8))\n", + " plt.imshow(img)\n", + " plt.axis('off')\n", + " plt.title(f\"작가: {photo_data['user']['name']} | 좋아요: {photo_data['likes']}\")\n", + " \n", + " if photo_data.get('description'):\n", + " plt.suptitle(photo_data['description'][:50] + \"...\", fontsize=10)\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + " \n", + " print(f\"📏 이미지 크기: {img.size}\")\n", + " print(f\"👤 작가: {photo_data['user']['name']} (@{photographer})\")\n", + " \n", + " return filepath\n", + " \n", + " except Exception as e:\n", + " print(f\"❌ 처리 실패: {e}\")\n", + " return None\n", + "\n", + "# 예시: 검색 결과에서 첫 번째 사진 다운로드\n", + "if raw_data and raw_data.get('results'):\n", + " first_photo = raw_data['results'][0]\n", + " print(\"🖼️ 첫 번째 검색 결과 사진을 다운로드합니다...\")\n", + " downloaded_file = download_and_display_photo(first_photo, size=\"small\", display=True)\n", + "else:\n", + " print(\"⚠️ 먼저 사진 검색을 실행해주세요!\")" + ] + }, + { + "cell_type": "markdown", + "id": "e1cf34a6", + "metadata": {}, + "source": [ + "## 8. 토픽별 사진 검색 \n", + "\n", + "Unsplash의 토픽을 활용해서 테마별 사진을 찾아봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ad60e94", + "metadata": {}, + "outputs": [], + "source": [ + "def get_topics(per_page=10):\n", + " \"\"\"토픽 목록 가져오기\"\"\"\n", + " params = {\"per_page\": per_page, \"order_by\": \"featured\"}\n", + " data = api.get_request(\"/topics\", params)\n", + " \n", + " if data:\n", + " print(f\"🏷️ {len(data)}개의 토픽을 찾았습니다!\")\n", + " \n", + " topics_data = []\n", + " for topic in data:\n", + " topics_data.append({\n", + " \"id\": topic[\"id\"],\n", + " \"slug\": topic[\"slug\"],\n", + " \"title\": topic[\"title\"],\n", + " \"description\": topic.get(\"description\", \"설명 없음\")[:100] + \"...\",\n", + " \"total_photos\": topic[\"total_photos\"],\n", + " \"featured\": topic.get(\"featured\", False)\n", + " })\n", + " \n", + " df = pd.DataFrame(topics_data)\n", + " return df, data\n", + " else:\n", + " print(\"❌ 토픽을 가져올 수 없습니다.\")\n", + " return None, None\n", + "\n", + "def get_topic_photos(topic_slug, per_page=10, order_by=\"latest\"):\n", + " \"\"\"특정 토픽의 사진들 가져오기\"\"\"\n", + " params = {\"per_page\": per_page, \"order_by\": order_by}\n", + " data = api.get_request(f\"/topics/{topic_slug}/photos\", params)\n", + " \n", + " if data:\n", + " print(f\"📸 '{topic_slug}' 토픽에서 {len(data)}개의 사진을 찾았습니다!\")\n", + " return data\n", + " else:\n", + " print(f\"❌ '{topic_slug}' 토픽의 사진을 가져올 수 없습니다.\")\n", + " return None\n", + "\n", + "# 인기 토픽 가져오기\n", + "print(\"🏷️ 인기 토픽 목록:\")\n", + "df_topics, topics_data = get_topics(per_page=8)\n", + "\n", + "if df_topics is not None:\n", + " print(\"\\n📋 토픽 정보:\")\n", + " print(df_topics[[\"title\", \"total_photos\", \"featured\"]].to_string(index=False))\n", + " \n", + " # 첫 번째 토픽의 사진들 가져오기\n", + " if len(topics_data) > 0:\n", + " first_topic = topics_data[0]\n", + " topic_slug = first_topic['slug']\n", + " print(f\"\\n🔍 '{first_topic['title']}' 토픽의 최신 사진들:\")\n", + " \n", + " topic_photos = get_topic_photos(topic_slug, per_page=3, order_by=\"latest\")\n", + " \n", + " if topic_photos:\n", + " for i, photo in enumerate(topic_photos, 1):\n", + " print(f\" {i}. {photo['user']['name']} - {photo.get('alt_description', '설명 없음')[:50]}\")\n", + " print(f\" 좋아요: {photo['likes']}, 크기: {photo['width']}x{photo['height']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "59dd69e2", + "metadata": {}, + "source": [ + "## 🏷️ 태그별 사진 대량 다운로드 \n", + "\n", + "특정 태그의 사진들을 검색하고 태그별 폴더에 자동으로 다운로드하는 기능입니다." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "434fc7c6", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import re\n", + "from pathlib import Path\n", + "\n", + "def create_safe_folder_name(tags):\n", + " \"\"\"\n", + " 태그명(들)을 안전한 폴더명으로 변환\n", + " 태그가 여러 개인 경우 _로 연결\n", + " 특수문자 제거 및 공백을 언더스코어로 변경\n", + " \n", + " Parameters:\n", + " - tags: 문자열 또는 리스트 (예: \"nature\" 또는 [\"nature\", \"landscape\"])\n", + " \"\"\"\n", + " # 태그가 문자열인 경우 리스트로 변환\n", + " if isinstance(tags, str):\n", + " # 쉼표나 공백으로 구분된 태그들을 분리\n", + " tag_list = [tag.strip() for tag in re.split(r'[,\\s]+', tags) if tag.strip()]\n", + " else:\n", + " tag_list = tags if isinstance(tags, list) else [str(tags)]\n", + " \n", + " # 각 태그를 안전한 형태로 변환\n", + " safe_tags = []\n", + " for tag in tag_list:\n", + " # 특수문자 제거 및 공백을 언더스코어로 변경\n", + " safe_tag = re.sub(r'[^\\w\\s-]', '', str(tag))\n", + " safe_tag = re.sub(r'[-\\s]+', '_', safe_tag)\n", + " safe_tag = safe_tag.lower().strip('_')\n", + " \n", + " if safe_tag: # 빈 문자열이 아닌 경우만 추가\n", + " safe_tags.append(safe_tag)\n", + " \n", + " # 태그들을 _로 연결\n", + " if len(safe_tags) == 0:\n", + " return \"default\"\n", + " elif len(safe_tags) == 1:\n", + " return safe_tags[0]\n", + " else:\n", + " return \"_\".join(safe_tags)\n", + "\n", + "def download_photos_by_tag(tag, num_photos=10, image_size=\"regular\", base_folder=\"C:/Users/EL081/Desktop/apitest/unsplash_images\"):\n", + " \"\"\"\n", + " 특정 태그의 사진들을 검색하고 태그별 폴더에 다운로드\n", + " \n", + " Parameters:\n", + " - tag: 검색할 태그/키워드 (문자열 또는 리스트)\n", + " - num_photos: 다운로드할 사진 수 (최대 30개씩)\n", + " - image_size: 'thumb', 'small', 'regular', 'full' 중 선택\n", + " - base_folder: 기본 저장 폴더 경로\n", + " \"\"\"\n", + " \n", + " # 태그가 리스트인 경우 검색용 문자열 생성 (AND 검색을 위해 공백으로 연결)\n", + " if isinstance(tag, list):\n", + " # 여러 태그를 AND 조건으로 검색하기 위해 공백으로 연결\n", + " search_query = \" \".join(tag)\n", + " display_tag = \" AND \".join(tag)\n", + " elif isinstance(tag, str) and (',' in tag):\n", + " # 쉼표로 구분된 문자열이면 여러 태그로 처리\n", + " tag_list = [t.strip() for t in tag.split(',') if t.strip()]\n", + " search_query = \" \".join(tag_list)\n", + " display_tag = \" AND \".join(tag_list)\n", + " else:\n", + " search_query = tag\n", + " display_tag = tag\n", + " \n", + " print(f\"🏷️ '{display_tag}' 태그 사진 다운로드 시작...\")\n", + " \n", + " # 안전한 폴더명 생성\n", + " safe_tag_name = create_safe_folder_name(tag)\n", + " tag_folder = os.path.join(base_folder, safe_tag_name)\n", + " \n", + " # 태그별 폴더 생성\n", + " os.makedirs(tag_folder, exist_ok=True)\n", + " print(f\"📁 폴더 생성: {tag_folder}\")\n", + " \n", + " # 사진 검색\n", + " photos_downloaded = 0\n", + " page = 1\n", + " per_page = min(30, num_photos) # API 제한: 최대 30개씩\n", + " \n", + " downloaded_files = []\n", + " failed_downloads = []\n", + " \n", + " while photos_downloaded < num_photos:\n", + " remaining_photos = num_photos - photos_downloaded\n", + " current_per_page = min(per_page, remaining_photos)\n", + " \n", + " print(f\"\\n📄 페이지 {page} 검색 중... (목표: {current_per_page}개)\")\n", + " \n", + " # 사진 검색\n", + " df_results, raw_data = search_photos(search_query, per_page=current_per_page, page=page)\n", + " \n", + " if not raw_data or not raw_data.get('results'):\n", + " print(f\"❌ 더 이상 '{display_tag}' 태그의 사진을 찾을 수 없습니다.\")\n", + " break\n", + " \n", + " photos = raw_data['results']\n", + " \n", + " # 각 사진 다운로드\n", + " for i, photo in enumerate(photos):\n", + " if photos_downloaded >= num_photos:\n", + " break\n", + " \n", + " try:\n", + " # 파일명 생성 (작가명_사진ID_크기.jpg)\n", + " photographer = photo['user']['username']\n", + " photo_id = photo['id']\n", + " filename = f\"{photographer}_{photo_id}_{image_size}.jpg\"\n", + " filepath = os.path.join(tag_folder, filename)\n", + " \n", + " # 이미 존재하는 파일 건너뛰기\n", + " if os.path.exists(filepath):\n", + " print(f\"⏭️ 건너뛰기 (이미 존재): {filename}\")\n", + " photos_downloaded += 1\n", + " continue\n", + " \n", + " # 사진 다운로드\n", + " photo_url = photo['urls'][image_size]\n", + " response = requests.get(photo_url)\n", + " response.raise_for_status()\n", + " \n", + " # 파일 저장\n", + " with open(filepath, 'wb') as f:\n", + " f.write(response.content)\n", + " \n", + " downloaded_files.append({\n", + " 'filename': filename,\n", + " 'photographer': photo['user']['name'],\n", + " 'photographer_username': photographer,\n", + " 'photo_id': photo_id,\n", + " 'likes': photo['likes'],\n", + " 'description': photo.get('description', '설명 없음'),\n", + " 'filepath': filepath\n", + " })\n", + " \n", + " photos_downloaded += 1\n", + " print(f\"✅ [{photos_downloaded}/{num_photos}] {filename}\")\n", + " \n", + " # API 부하 방지를 위한 짧은 대기\n", + " time.sleep(0.5)\n", + " \n", + " except Exception as e:\n", + " error_info = {\n", + " 'photo_id': photo.get('id', 'Unknown'),\n", + " 'photographer': photo.get('user', {}).get('username', 'Unknown'),\n", + " 'error': str(e)\n", + " }\n", + " failed_downloads.append(error_info)\n", + " print(f\"❌ 다운로드 실패: {error_info['photo_id']} - {str(e)[:50]}\")\n", + " \n", + " page += 1\n", + " \n", + " # 더 이상 결과가 없으면 중단\n", + " if len(photos) < current_per_page:\n", + " break\n", + " \n", + " # 결과 요약\n", + " print(f\"\\n{'='*60}\")\n", + " print(f\"🎯 '{display_tag}' 태그 다운로드 완료!\")\n", + " print(f\"📁 저장 위치: {tag_folder}\")\n", + " print(f\"✅ 성공: {len(downloaded_files)}개\")\n", + " print(f\"❌ 실패: {len(failed_downloads)}개\")\n", + " \n", + " if downloaded_files:\n", + " print(f\"\\n📊 다운로드된 사진 정보:\")\n", + " df_downloaded = pd.DataFrame(downloaded_files)\n", + " print(df_downloaded[['photographer', 'likes', 'description']].head(10).to_string(index=False))\n", + " \n", + " if failed_downloads:\n", + " print(f\"\\n⚠️ 실패한 다운로드:\")\n", + " for fail in failed_downloads[:5]: # 최대 5개만 표시\n", + " print(f\" - {fail['photo_id']} ({fail['photographer']}): {fail['error'][:50]}\")\n", + " \n", + " return {\n", + " 'tag': display_tag,\n", + " 'folder_path': tag_folder,\n", + " 'downloaded': downloaded_files,\n", + " 'failed': failed_downloads,\n", + " 'total_downloaded': len(downloaded_files)\n", + " }\n", + "\n", + "def batch_download_multiple_tags(tags_list, photos_per_tag=10, image_size=\"regular\"):\n", + " \"\"\"\n", + " 여러 태그의 사진들을 일괄 다운로드\n", + " \n", + " Parameters:\n", + " - tags_list: 태그 리스트 ['nature', 'city', 'food'] 또는 [['nature', 'landscape'], ['city', 'night']]\n", + " - photos_per_tag: 태그당 다운로드할 사진 수\n", + " - image_size: 이미지 크기\n", + " \"\"\"\n", + " print(f\"🚀 {len(tags_list)}개 태그 일괄 다운로드 시작!\")\n", + " \n", + " # 태그 목록 표시\n", + " display_tags = []\n", + " for tag in tags_list:\n", + " if isinstance(tag, list):\n", + " display_tags.append(\" + \".join(tag))\n", + " else:\n", + " display_tags.append(str(tag))\n", + " \n", + " print(f\"📝 태그 목록: {', '.join(display_tags)}\")\n", + " print(f\"📊 태그당 사진 수: {photos_per_tag}개\")\n", + " print(f\"📐 이미지 크기: {image_size}\")\n", + " print(\"=\"*60)\n", + " \n", + " results = []\n", + " \n", + " for i, tag in enumerate(tags_list, 1):\n", + " display_tag = \" + \".join(tag) if isinstance(tag, list) else str(tag)\n", + " print(f\"\\n🏷️ [{i}/{len(tags_list)}] '{display_tag}' 태그 처리 중...\")\n", + " \n", + " try:\n", + " result = download_photos_by_tag(tag, photos_per_tag, image_size)\n", + " results.append(result)\n", + " \n", + " # 태그 간 대기 (API 부하 방지)\n", + " if i < len(tags_list):\n", + " print(\"⏳ 다음 태그 처리를 위해 3초 대기...\")\n", + " time.sleep(3)\n", + " \n", + " except Exception as e:\n", + " print(f\"❌ '{display_tag}' 태그 처리 실패: {e}\")\n", + " results.append({\n", + " 'tag': display_tag,\n", + " 'folder_path': None,\n", + " 'downloaded': [],\n", + " 'failed': [],\n", + " 'total_downloaded': 0,\n", + " 'error': str(e)\n", + " })\n", + " \n", + " # 전체 결과 요약\n", + " print(f\"\\n{'='*80}\")\n", + " print(\"🎉 전체 다운로드 완료!\")\n", + " print(\"=\"*80)\n", + " \n", + " total_downloaded = sum(r['total_downloaded'] for r in results)\n", + " successful_tags = sum(1 for r in results if r['total_downloaded'] > 0)\n", + " \n", + " print(f\"📊 전체 통계:\")\n", + " print(f\" - 처리된 태그: {len(tags_list)}개\")\n", + " print(f\" - 성공한 태그: {successful_tags}개\")\n", + " print(f\" - 총 다운로드: {total_downloaded}개 사진\")\n", + " \n", + " print(f\"\\n📁 태그별 결과:\")\n", + " for result in results:\n", + " status = \"✅\" if result['total_downloaded'] > 0 else \"❌\"\n", + " print(f\" {status} {result['tag']}: {result['total_downloaded']}개\")\n", + " \n", + " return results" + ] + }, + { + "cell_type": "markdown", + "id": "513a83a5", + "metadata": {}, + "source": [ + "### 사용 예제 - 단일 태그 다운로드\n", + "\n", + "하나의 태그로 사진을 다운로드해보겠습니다." + ] + }, + { + "cell_type": "markdown", + "id": "441eb5f2", + "metadata": {}, + "source": [ + "### 🧪 폴더명 생성 테스트\n", + "\n", + "태그별 폴더명이 어떻게 생성되는지 확인해봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "235e0264", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧪 폴더명 생성 테스트\n", + "========================================\n", + " 1. 입력: nature\n", + " 폴더명: 'nature'\n", + "\n", + " 2. 입력: ['nature', 'landscape']\n", + " 폴더명: 'nature_landscape'\n", + "\n", + " 3. 입력: nature, landscape\n", + " 폴더명: 'nature_landscape'\n", + "\n", + " 4. 입력: nature landscape\n", + " 폴더명: 'nature_landscape'\n", + "\n", + " 5. 입력: ['soft', 'minimalist', 'clean']\n", + " 폴더명: 'soft_minimalist_clean'\n", + "\n", + " 6. 입력: city & night\n", + " 폴더명: 'city_night'\n", + "\n", + " 7. 입력: ['modern-design', 'black white']\n", + " 폴더명: 'modern_design_black_white'\n", + "\n", + " 8. 입력: \n", + " 폴더명: 'default'\n", + "\n", + " 9. 입력: nature , landscape \n", + " 폴더명: 'nature_landscape'\n", + "\n" + ] + } + ], + "source": [ + "# 폴더명 생성 테스트\n", + "print(\"🧪 폴더명 생성 테스트\")\n", + "print(\"=\"*40)\n", + "\n", + "# 테스트 케이스들\n", + "test_cases = [\n", + " \"nature\", # 단일 태그\n", + " [\"nature\", \"landscape\"], # 두 개 태그 (리스트)\n", + " \"nature, landscape\", # 두 개 태그 (쉼표로 구분된 문자열)\n", + " \"nature landscape\", # 두 개 태그 (공백으로 구분된 문자열)\n", + " [\"soft\", \"minimalist\", \"clean\"], # 세 개 태그\n", + " \"city & night\", # 특수문자 포함\n", + " [\"modern-design\", \"black white\"], # 하이픈과 공백 포함\n", + " \"\", # 빈 문자열\n", + " \" nature , landscape \" # 공백이 많은 경우\n", + "]\n", + "\n", + "for i, test_case in enumerate(test_cases, 1):\n", + " folder_name = create_safe_folder_name(test_case)\n", + " print(f\"{i:2d}. 입력: {test_case}\")\n", + " print(f\" 폴더명: '{folder_name}'\")\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "95265ffd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🎯 'soft' 태그로 5개 사진 다운로드를 시작합니다...\n", + "🏷️ 'soft' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft\n", + "\n", + "📄 페이지 1 검색 중... (목표: 5개)\n", + "🔍 'soft' 검색 결과: 8661개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "🔍 'soft' 검색 결과: 8661개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "✅ [1/5] evieshaffer_Sw7f58YJbc0_small.jpg\n", + "✅ [1/5] evieshaffer_Sw7f58YJbc0_small.jpg\n", + "✅ [2/5] nico_frey_JfknhSgANFQ_small.jpg\n", + "✅ [2/5] nico_frey_JfknhSgANFQ_small.jpg\n", + "✅ [3/5] mattpalmer_WHJ1VaQpPsg_small.jpg\n", + "✅ [3/5] mattpalmer_WHJ1VaQpPsg_small.jpg\n", + "✅ [4/5] fotkes_Kff2wSaqeMA_small.jpg\n", + "✅ [4/5] fotkes_Kff2wSaqeMA_small.jpg\n", + "✅ [5/5] rues_XivbqAPEoJg_small.jpg\n", + "✅ [5/5] rues_XivbqAPEoJg_small.jpg\n", + "\n", + "============================================================\n", + "🎯 'soft' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + "photographer likes description\n", + " Evie S. 3960 Macro shot of White Feather\n", + " Nico Frey 2048 None\n", + " Matt Palmer 801 A nice gentle sky for use as an element or background.\n", + " Vai Da 2228 None\n", + " Rue S 3099 Satin\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft\n", + "\n", + "🎯 'nature + landscape' 태그로 5개 사진 다운로드를 시작합니다...\n", + "🏷️ 'nature AND landscape' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "\n", + "📄 페이지 1 검색 중... (목표: 5개)\n", + "\n", + "============================================================\n", + "🎯 'soft' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + "photographer likes description\n", + " Evie S. 3960 Macro shot of White Feather\n", + " Nico Frey 2048 None\n", + " Matt Palmer 801 A nice gentle sky for use as an element or background.\n", + " Vai Da 2228 None\n", + " Rue S 3099 Satin\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft\n", + "\n", + "🎯 'nature + landscape' 태그로 5개 사진 다운로드를 시작합니다...\n", + "🏷️ 'nature AND landscape' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "\n", + "📄 페이지 1 검색 중... (목표: 5개)\n", + "🔍 'nature landscape' 검색 결과: 10000개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "🔍 'nature landscape' 검색 결과: 10000개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "✅ [1/5] danangele_Joo3UBw789Q_small.jpg\n", + "✅ [1/5] danangele_Joo3UBw789Q_small.jpg\n", + "✅ [2/5] daymnous_m_uSWBJWr0s_small.jpg\n", + "✅ [2/5] daymnous_m_uSWBJWr0s_small.jpg\n", + "✅ [3/5] marcst84_WKKG5oYx3qA_small.jpg\n", + "✅ [3/5] marcst84_WKKG5oYx3qA_small.jpg\n", + "✅ [4/5] nickwest_4M-5WBrG5-c_small.jpg\n", + "✅ [4/5] nickwest_4M-5WBrG5-c_small.jpg\n", + "✅ [5/5] puregeorgia_UiKWDzkMV_o_small.jpg\n", + "✅ [5/5] puregeorgia_UiKWDzkMV_o_small.jpg\n", + "\n", + "============================================================\n", + "🎯 'nature AND landscape' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Daniel Angele 1126 Way to Braunarlspitze\n", + "Allyson Beaucourt 216 None\n", + " Marc St 169 At first light of day on the way to Oudtshoorn from Stellenbosch, we almost drove our car in the ditch seeing this incredible mountain range. We barely managed to stop on the roadside to take some quick snaps, risking our lives with trucks speeding by in the downhill part of the pass.\n", + " Nick West 1323 Mountains on the opposite shore\n", + " Alfred Schrock 29 None\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "\n", + "🎯 'soft, minimalist' 태그로 5개 사진 다운로드를 시작합니다...\n", + "🏷️ 'soft AND minimalist' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n", + "\n", + "📄 페이지 1 검색 중... (목표: 5개)\n", + "\n", + "============================================================\n", + "🎯 'nature AND landscape' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Daniel Angele 1126 Way to Braunarlspitze\n", + "Allyson Beaucourt 216 None\n", + " Marc St 169 At first light of day on the way to Oudtshoorn from Stellenbosch, we almost drove our car in the ditch seeing this incredible mountain range. We barely managed to stop on the roadside to take some quick snaps, risking our lives with trucks speeding by in the downhill part of the pass.\n", + " Nick West 1323 Mountains on the opposite shore\n", + " Alfred Schrock 29 None\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\nature_landscape\n", + "\n", + "🎯 'soft, minimalist' 태그로 5개 사진 다운로드를 시작합니다...\n", + "🏷️ 'soft AND minimalist' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n", + "\n", + "📄 페이지 1 검색 중... (목표: 5개)\n", + "🔍 'soft minimalist' 검색 결과: 1222개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "🔍 'soft minimalist' 검색 결과: 1222개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 5\n", + "✅ [1/5] cha29_mRgOW8xyKNY_small.jpg\n", + "✅ [1/5] cha29_mRgOW8xyKNY_small.jpg\n", + "✅ [2/5] noellerebekah_p1wnkwC8S6g_small.jpg\n", + "✅ [2/5] noellerebekah_p1wnkwC8S6g_small.jpg\n", + "✅ [3/5] julissasantana_LjtRupsxmhg_small.jpg\n", + "✅ [3/5] julissasantana_LjtRupsxmhg_small.jpg\n", + "✅ [4/5] stuffinabox_8ZdFpGNAMhk_small.jpg\n", + "✅ [4/5] stuffinabox_8ZdFpGNAMhk_small.jpg\n", + "✅ [5/5] raulmermans_dMtpQm2TrM4_small.jpg\n", + "✅ [5/5] raulmermans_dMtpQm2TrM4_small.jpg\n", + "\n", + "============================================================\n", + "🎯 'soft AND minimalist' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Charleen Vesin 7 Minimal soft interior \n", + " Noelle Rebekah 136 None\n", + " Julissa Santana 51 Fabric #4\n", + " Janan 6 None\n", + "Raúl Mermans García 1 A minimalist interior scene showcasing the warm glow of a lamp casting soft, dramatic shadows on the wall. The subtle decor, including flamingo ornaments and a delicate hanging charm, enhances the cozy and intimate ambiance of the space.\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n", + "\n", + "============================================================\n", + "🎯 'soft AND minimalist' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n", + "✅ 성공: 5개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Charleen Vesin 7 Minimal soft interior \n", + " Noelle Rebekah 136 None\n", + " Julissa Santana 51 Fabric #4\n", + " Janan 6 None\n", + "Raúl Mermans García 1 A minimalist interior scene showcasing the warm glow of a lamp casting soft, dramatic shadows on the wall. The subtle decor, including flamingo ornaments and a delicate hanging charm, enhances the cozy and intimate ambiance of the space.\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\soft_minimalist\n" + ] + } + ], + "source": [ + "# 예제 1: 단일 태그로 사진 다운로드\n", + "tag = \"soft\" # 원하는 태그로 변경하세요\n", + "num_photos = 5 # 다운로드할 사진 수\n", + "image_size = \"small\" # 'thumb', 'small', 'regular', 'full' 중 선택\n", + "\n", + "print(f\"🎯 '{tag}' 태그로 {num_photos}개 사진 다운로드를 시작합니다...\")\n", + "result = download_photos_by_tag(tag, num_photos, image_size)\n", + "\n", + "print(f\"\\n📂 다운로드 완료! 폴더 위치: {result['folder_path']}\")\n", + "\n", + "# 예제 1-2: 두 개 태그를 리스트로 전달\n", + "multi_tags = [\"nature\", \"landscape\"]\n", + "num_photos = 5\n", + "image_size = \"small\"\n", + "\n", + "print(f\"\\n🎯 '{' + '.join(multi_tags)}' 태그로 {num_photos}개 사진 다운로드를 시작합니다...\")\n", + "result_multi = download_photos_by_tag(multi_tags, num_photos, image_size)\n", + "\n", + "print(f\"\\n📂 다운로드 완료! 폴더 위치: {result_multi['folder_path']}\")\n", + "\n", + "# 예제 1-3: 두 개 태그를 문자열로 전달 (쉼표로 구분)\n", + "tag_string = \"soft, minimalist\"\n", + "num_photos = 5\n", + "image_size = \"small\"\n", + "\n", + "print(f\"\\n🎯 '{tag_string}' 태그로 {num_photos}개 사진 다운로드를 시작합니다...\")\n", + "result_string = download_photos_by_tag(tag_string, num_photos, image_size)\n", + "\n", + "print(f\"\\n📂 다운로드 완료! 폴더 위치: {result_string['folder_path']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b37b17f0", + "metadata": {}, + "source": [ + "### 사용 예제 - 여러 태그 일괄 다운로드\n", + "\n", + "여러 태그의 사진을 한 번에 다운로드해보겠습니다." + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "97c184c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🎯 'warm AND happy' 태그가 모두 포함된 사진을 다운로드합니다...\n", + "🏷️ 'warm AND happy' 태그 사진 다운로드 시작...\n", + "📁 폴더 생성: C:/Users/EL081/Desktop/apitest/unsplash_images\\warm_happy\n", + "\n", + "📄 페이지 1 검색 중... (목표: 30개)\n", + "🔍 'warm happy' 검색 결과: 599개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 30\n", + "🔍 'warm happy' 검색 결과: 599개 사진 발견\n", + "📄 현재 페이지: 1, 결과 수: 30\n", + "✅ [1/60] arturrekstad_qVw6_hINmLI_small.jpg\n", + "✅ [1/60] arturrekstad_qVw6_hINmLI_small.jpg\n", + "✅ [2/60] isabeladrasovean_nMNMPAs4fI8_small.jpg\n", + "✅ [2/60] isabeladrasovean_nMNMPAs4fI8_small.jpg\n", + "✅ [3/60] yohoney_YT2LIPuBoC8_small.jpg\n", + "✅ [3/60] yohoney_YT2LIPuBoC8_small.jpg\n", + "✅ [4/60] luke_helgeson_PcHQAH4IZb8_small.jpg\n", + "✅ [4/60] luke_helgeson_PcHQAH4IZb8_small.jpg\n", + "✅ [5/60] jellybear_studio_lXN7aUttGTg_small.jpg\n", + "✅ [5/60] jellybear_studio_lXN7aUttGTg_small.jpg\n", + "✅ [6/60] jellybear_studio_tH0G0RbI-kw_small.jpg\n", + "✅ [6/60] jellybear_studio_tH0G0RbI-kw_small.jpg\n", + "✅ [7/60] blakecheekk_tpvSmb_EfXU_small.jpg\n", + "✅ [7/60] blakecheekk_tpvSmb_EfXU_small.jpg\n", + "✅ [8/60] amyjoyhumphries_kACs144foYM_small.jpg\n", + "✅ [8/60] amyjoyhumphries_kACs144foYM_small.jpg\n", + "✅ [9/60] jensmueller35_SBxIXdXqmt8_small.jpg\n", + "✅ [9/60] jensmueller35_SBxIXdXqmt8_small.jpg\n", + "✅ [10/60] cthemaker_S9DEW9KafCI_small.jpg\n", + "✅ [10/60] cthemaker_S9DEW9KafCI_small.jpg\n", + "✅ [11/60] sophiaarichards_zC9B-cFigMM_small.jpg\n", + "✅ [11/60] sophiaarichards_zC9B-cFigMM_small.jpg\n", + "✅ [12/60] monnysim_wNe7SegpQXI_small.jpg\n", + "✅ [12/60] monnysim_wNe7SegpQXI_small.jpg\n", + "✅ [13/60] kat_von_wood_UivC-7zsFmA_small.jpg\n", + "✅ [13/60] kat_von_wood_UivC-7zsFmA_small.jpg\n", + "✅ [14/60] iam_aspencer__fEZvhwc6jI_small.jpg\n", + "✅ [14/60] iam_aspencer__fEZvhwc6jI_small.jpg\n", + "✅ [15/60] shammmm_7KyO_vpHtoM_small.jpg\n", + "✅ [15/60] shammmm_7KyO_vpHtoM_small.jpg\n", + "✅ [16/60] samuel_hagger_8-iDkHpTZTs_small.jpg\n", + "✅ [16/60] samuel_hagger_8-iDkHpTZTs_small.jpg\n", + "✅ [17/60] relentlessjpg__m-vmfUV-4g_small.jpg\n", + "✅ [17/60] relentlessjpg__m-vmfUV-4g_small.jpg\n", + "✅ [18/60] jan_huber_SKMrqZQ5vA0_small.jpg\n", + "✅ [18/60] jan_huber_SKMrqZQ5vA0_small.jpg\n", + "✅ [19/60] kat_von_wood_9LtEK5L2xSw_small.jpg\n", + "✅ [19/60] kat_von_wood_9LtEK5L2xSw_small.jpg\n", + "✅ [20/60] relentlessjpg_mSMtDEY2sd4_small.jpg\n", + "✅ [20/60] relentlessjpg_mSMtDEY2sd4_small.jpg\n", + "✅ [21/60] spensersembrat_DV4irRka_P8_small.jpg\n", + "✅ [21/60] spensersembrat_DV4irRka_P8_small.jpg\n", + "✅ [22/60] arturrekstad_18NWHwnbdFc_small.jpg\n", + "✅ [22/60] arturrekstad_18NWHwnbdFc_small.jpg\n", + "✅ [23/60] spensersembrat_pS224BG-3t0_small.jpg\n", + "✅ [23/60] spensersembrat_pS224BG-3t0_small.jpg\n", + "✅ [24/60] jordanmadrid_US6nYhwscfE_small.jpg\n", + "✅ [24/60] jordanmadrid_US6nYhwscfE_small.jpg\n", + "✅ [25/60] arturrekstad_lXj_yMeMe6A_small.jpg\n", + "✅ [25/60] arturrekstad_lXj_yMeMe6A_small.jpg\n", + "✅ [26/60] arturrekstad_X5GuUbjCJ_4_small.jpg\n", + "✅ [26/60] arturrekstad_X5GuUbjCJ_4_small.jpg\n", + "✅ [27/60] danilkinkin_RAh3QiMYEp4_small.jpg\n", + "✅ [27/60] danilkinkin_RAh3QiMYEp4_small.jpg\n", + "✅ [28/60] colinwatts_Y4frddc-jJY_small.jpg\n", + "✅ [28/60] colinwatts_Y4frddc-jJY_small.jpg\n", + "✅ [29/60] mareko_B-rAPNPntQA_small.jpg\n", + "✅ [29/60] mareko_B-rAPNPntQA_small.jpg\n", + "✅ [30/60] monnysim_7rWJ0Dvq46s_small.jpg\n", + "✅ [30/60] monnysim_7rWJ0Dvq46s_small.jpg\n", + "\n", + "📄 페이지 2 검색 중... (목표: 30개)\n", + "\n", + "📄 페이지 2 검색 중... (목표: 30개)\n", + "🔍 'warm happy' 검색 결과: 476개 사진 발견\n", + "📄 현재 페이지: 2, 결과 수: 30\n", + "⏭️ 건너뛰기 (이미 존재): colinwatts_Y4frddc-jJY_small.jpg\n", + "⏭️ 건너뛰기 (이미 존재): mareko_B-rAPNPntQA_small.jpg\n", + "🔍 'warm happy' 검색 결과: 476개 사진 발견\n", + "📄 현재 페이지: 2, 결과 수: 30\n", + "⏭️ 건너뛰기 (이미 존재): colinwatts_Y4frddc-jJY_small.jpg\n", + "⏭️ 건너뛰기 (이미 존재): mareko_B-rAPNPntQA_small.jpg\n", + "✅ [33/60] mareko_dczDI9mMttc_small.jpg\n", + "✅ [33/60] mareko_dczDI9mMttc_small.jpg\n", + "✅ [34/60] mareko_Em8p2w4tJrw_small.jpg\n", + "✅ [34/60] mareko_Em8p2w4tJrw_small.jpg\n", + "✅ [35/60] monnysim_VRbX3bjh5PE_small.jpg\n", + "✅ [35/60] monnysim_VRbX3bjh5PE_small.jpg\n", + "✅ [36/60] alejandrosoti_Rt_crrxICYU_small.jpg\n", + "✅ [36/60] alejandrosoti_Rt_crrxICYU_small.jpg\n", + "✅ [37/60] wildemeijer_T2gTb27DVIs_small.jpg\n", + "✅ [37/60] wildemeijer_T2gTb27DVIs_small.jpg\n", + "✅ [38/60] monnysim_NSW4nuXpbng_small.jpg\n", + "✅ [38/60] monnysim_NSW4nuXpbng_small.jpg\n", + "✅ [39/60] giorgiotrovato_oaRxJ7WN3lE_small.jpg\n", + "✅ [39/60] giorgiotrovato_oaRxJ7WN3lE_small.jpg\n", + "✅ [40/60] tom607_TPc21VJB3nk_small.jpg\n", + "✅ [40/60] tom607_TPc21VJB3nk_small.jpg\n", + "✅ [41/60] colinwatts_4lDKHJUZFm0_small.jpg\n", + "✅ [41/60] colinwatts_4lDKHJUZFm0_small.jpg\n", + "✅ [42/60] lil_bear_photo_gHQRKQLD3Ck_small.jpg\n", + "✅ [42/60] lil_bear_photo_gHQRKQLD3Ck_small.jpg\n", + "✅ [43/60] tonyeightmedia_lkDHpbk1iNA_small.jpg\n", + "✅ [43/60] tonyeightmedia_lkDHpbk1iNA_small.jpg\n", + "✅ [44/60] jakobowens1_dlq1n1L1XnA_small.jpg\n", + "✅ [44/60] jakobowens1_dlq1n1L1XnA_small.jpg\n", + "✅ [45/60] dansenior_3ecodBxP3uk_small.jpg\n", + "✅ [45/60] dansenior_3ecodBxP3uk_small.jpg\n", + "✅ [46/60] alisayedl_ifMRR7qkySQ_small.jpg\n", + "✅ [46/60] alisayedl_ifMRR7qkySQ_small.jpg\n", + "✅ [47/60] colinwatts_98EhmxyOuXo_small.jpg\n", + "✅ [47/60] colinwatts_98EhmxyOuXo_small.jpg\n", + "✅ [48/60] felicewoelke_PxyV-uLTmug_small.jpg\n", + "✅ [48/60] felicewoelke_PxyV-uLTmug_small.jpg\n", + "✅ [49/60] prachipalwe_ZlSIjc_sPQ4_small.jpg\n", + "✅ [49/60] prachipalwe_ZlSIjc_sPQ4_small.jpg\n", + "✅ [50/60] salmonc_y23DAAOBRQc_small.jpg\n", + "✅ [50/60] salmonc_y23DAAOBRQc_small.jpg\n", + "✅ [51/60] mproctor_R8ngOAZUglw_small.jpg\n", + "✅ [51/60] mproctor_R8ngOAZUglw_small.jpg\n", + "✅ [52/60] bencollins_pGHdsWuo_hg_small.jpg\n", + "✅ [52/60] bencollins_pGHdsWuo_hg_small.jpg\n", + "✅ [53/60] mproctor_E5Bvu0YWgiI_small.jpg\n", + "✅ [53/60] mproctor_E5Bvu0YWgiI_small.jpg\n", + "✅ [54/60] yonancito_gYo607K2f0o_small.jpg\n", + "✅ [54/60] yonancito_gYo607K2f0o_small.jpg\n", + "✅ [55/60] arstyy_Ui2SOBevHl4_small.jpg\n", + "✅ [55/60] arstyy_Ui2SOBevHl4_small.jpg\n", + "✅ [56/60] mproctor_ho8SPZLNhwA_small.jpg\n", + "✅ [56/60] mproctor_ho8SPZLNhwA_small.jpg\n", + "✅ [57/60] eugenezhyvchik_duJg3gGlYm8_small.jpg\n", + "✅ [57/60] eugenezhyvchik_duJg3gGlYm8_small.jpg\n", + "✅ [58/60] alexbracken_vmajJ0oMhVY_small.jpg\n", + "✅ [58/60] alexbracken_vmajJ0oMhVY_small.jpg\n", + "✅ [59/60] blue_jean_8hBY-30cEqI_small.jpg\n", + "✅ [59/60] blue_jean_8hBY-30cEqI_small.jpg\n", + "✅ [60/60] quynhlmph14759_IwHsHrETG_M_small.jpg\n", + "✅ [60/60] quynhlmph14759_IwHsHrETG_M_small.jpg\n", + "\n", + "============================================================\n", + "🎯 'warm AND happy' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\warm_happy\n", + "✅ 성공: 58개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Artur Rekstad 11 None\n", + "Isabela Drasovean 4 His name is Lăbuș 🥰\n", + " Yohan Cho 43 None\n", + " Luke Helgeson 2 Excited for dinner while camping in the North Cascades\n", + " DOYEOP KOO 4 None\n", + " DOYEOP KOO 3 None\n", + " Blake Cheek 115 None\n", + " Amy Humphries 91 dog playing in the tall grass\n", + " Jens Müller 2 beatiful flower\n", + " Chris Nemeth 176 Welcome the Morning\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\warm_happy\n", + "\n", + "============================================================\n", + "🎯 'warm AND happy' 태그 다운로드 완료!\n", + "📁 저장 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\warm_happy\n", + "✅ 성공: 58개\n", + "❌ 실패: 0개\n", + "\n", + "📊 다운로드된 사진 정보:\n", + " photographer likes description\n", + " Artur Rekstad 11 None\n", + "Isabela Drasovean 4 His name is Lăbuș 🥰\n", + " Yohan Cho 43 None\n", + " Luke Helgeson 2 Excited for dinner while camping in the North Cascades\n", + " DOYEOP KOO 4 None\n", + " DOYEOP KOO 3 None\n", + " Blake Cheek 115 None\n", + " Amy Humphries 91 dog playing in the tall grass\n", + " Jens Müller 2 beatiful flower\n", + " Chris Nemeth 176 Welcome the Morning\n", + "\n", + "📂 다운로드 완료! 폴더 위치: C:/Users/EL081/Desktop/apitest/unsplash_images\\warm_happy\n" + ] + } + ], + "source": [ + "tag_string = \"warm, happy\" # 'soft'와 'cozy' 두 태그 모두 포함된 사진\n", + "photos_per_tag = 60\n", + "\n", + "print(f\"\\n🎯 '{tag_string.replace(',', ' AND')}' 태그가 모두 포함된 사진을 다운로드합니다...\")\n", + "result2 = download_photos_by_tag(tag_string, photos_per_tag, image_size)\n", + "\n", + "print(f\"\\n📂 다운로드 완료! 폴더 위치: {result2['folder_path']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a214bebc", + "metadata": {}, + "source": [ + "### 🔍 검색 방식 설명\n", + "\n", + "**중요**: 이 코드는 다음과 같이 작동합니다:\n", + "\n", + "1. **단일 태그**: `\"nature\"` → `nature` 태그가 포함된 사진 검색\n", + "2. **두 태그 (리스트)**: `[\"nature\", \"landscape\"]` → `nature`와 `landscape` **둘 다 포함된** 사진 검색 \n", + "3. **두 태그 (문자열)**: `\"nature, landscape\"` → `nature`와 `landscape` **둘 다 포함된** 사진 검색\n", + "4. **폴더명**: 두 태그의 경우 `nature_landscape` 폴더에 저장\n", + "\n", + "이는 각 태그를 따로 검색하는 것이 아니라, **모든 태그가 동시에 포함된 사진만** 찾는 AND 검색입니다." + ] + }, + { + "cell_type": "markdown", + "id": "9f691167", + "metadata": {}, + "source": [ + "### 다운로드된 폴더 구조 확인\n", + "\n", + "다운로드 완료 후 폴더 구조를 확인해봅시다." + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "b4ee1199", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📁 폴더 구조: C:\\Users\\EL081\\Desktop\\apitest\\unsplash_images\n", + "============================================================\n", + "\n", + "📂 cold_chaotic/ (20개 파일)\n", + " 📄 aaronburden_5p_hbvdcEvo_small.jpg (23.2KB)\n", + " 📄 artificialphotography_HTyvOy1rN0w_small.jpg (22.4KB)\n", + " 📄 bitter_fruitt_dadIRm2I68A_small.jpg (7.4KB)\n", + " ... 외 17개 파일\n", + "\n", + "📂 cold_cozy/ (40개 파일)\n", + " 📄 adaliabotha_2klT37FVv2w_small.jpg (15.1KB)\n", + " 📄 adaliabotha_gXl-75-8kzI_small.jpg (43.8KB)\n", + " 📄 adasein_0-qpTNlh68A_small.jpg (32.1KB)\n", + " ... 외 37개 파일\n", + "\n", + "📂 cold_dull/ (48개 파일)\n", + " 📄 aloragriffiths_HlnFco4i624_small.jpg (37.8KB)\n", + " 📄 andyvult_gITzcWzM-Y4_small.jpg (25.5KB)\n", + " 📄 aureaphoto_aGUQRhvGN_k_small.jpg (40.9KB)\n", + " ... 외 45개 파일\n", + "\n", + "📂 cold_energetic/ (42개 파일)\n", + " 📄 aoiihoshi_XJVs6mjsn3A_small.jpg (7.0KB)\n", + " 📄 bensow_dSZnxGNlP30_small.jpg (39.3KB)\n", + " 📄 christianw_6kvd4OGr_eM_small.jpg (11.3KB)\n", + " ... 외 39개 파일\n", + "\n", + "📂 cold_harmonic/ (54개 파일)\n", + " 📄 aaronburden_5p_hbvdcEvo_small.jpg (23.2KB)\n", + " 📄 animakss_mWe74Rjl7Ac_small.jpg (71.0KB)\n", + " 📄 anitaaustvika_4MiGSpSsAbo_small.jpg (39.7KB)\n", + " ... 외 51개 파일\n", + "\n", + "📂 cold_harmony/ (0개 파일)\n", + "\n", + "📂 cold_mess/ (0개 파일)\n", + "\n", + "📂 cold_messy/ (2개 파일)\n", + " 📄 kellysikkema_Mw55efS-Ws0_small.jpg (24.5KB)\n", + " 📄 rinckad_FgGgajpfP8I_small.jpg (33.8KB)\n", + "\n", + "📂 cold_pleasant/ (56개 파일)\n", + " 📄 abbat_DTAiNHOsjTU_small.jpg (24.5KB)\n", + " 📄 abbat_jYAHNQ8GXYc_small.jpg (31.9KB)\n", + " 📄 andri_wyss_z4S6mJRB_T8_small.jpg (13.4KB)\n", + " ... 외 53개 파일\n", + "\n", + "📂 cold_risky/ (65개 파일)\n", + " 📄 59l5_P2TzJD0WAJM_small.jpg (29.8KB)\n", + " 📄 alexgruber_OtSdhwaG8nY_small.jpg (53.0KB)\n", + " 📄 alingavriliuc_DrRuSMBJSx0_small.jpg (23.5KB)\n", + " ... 외 62개 파일\n", + "\n", + "📂 cold_unpleasant/ (24개 파일)\n", + " 📄 andriyko_-uyARb4OKxA_small.jpg (12.9KB)\n", + " 📄 apafios__1jIkgZ_Kl4_small.jpg (58.1KB)\n", + " 📄 enginakyurt_b5DPzLPHaNQ_small.jpg (20.3KB)\n", + " ... 외 21개 파일\n", + "\n", + "📂 hard_chaotic/ (3개 파일)\n", + " 📄 loganvoss_L5EwVeusews_small.jpg (160.7KB)\n", + " 📄 loganvoss_vVlAu5VYGls_small.jpg (124.4KB)\n", + " 📄 nuarharuha_pcvP9ohu-CM_small.jpg (23.6KB)\n", + "\n", + "📂 hard_cozy/ (39개 파일)\n", + " 📄 alexandrmamedov_ajn8aKQWT2k_small.jpg (33.7KB)\n", + " 📄 anistongrace_CyDE3uFgLc4_small.jpg (19.7KB)\n", + " 📄 benhersheyloves_7vYn0kIq4Kw_small.jpg (25.5KB)\n", + " ... 외 36개 파일\n", + "\n", + "📂 hard_dull/ (3개 파일)\n", + " 📄 curtissberry_jkj3__wfDAk_small.jpg (17.2KB)\n", + " 📄 curtissberry_JP_u2EsWbjY_small.jpg (26.5KB)\n", + " 📄 kellitungay_2LJ4rqK2qfU_small.jpg (11.6KB)\n", + "\n", + "📂 hard_energy/ (74개 파일)\n", + " 📄 acharki95_kW-8a6Y-vEA_small.jpg (19.5KB)\n", + " 📄 alevtakil_pLymeaPcZv4_small.jpg (22.0KB)\n", + " 📄 alexkixa_3AQaX8bfQl0_small.jpg (45.8KB)\n", + " ... 외 71개 파일\n", + "\n", + "📂 hard_harmonic/ (10개 파일)\n", + " 📄 344digital_0JHAvi0oEpA_small.jpg (45.1KB)\n", + " 📄 abject_JwE9M2J8Wi4_small.jpg (37.7KB)\n", + " 📄 avasol_FO-OyDogAvo_small.jpg (30.5KB)\n", + " ... 외 7개 파일\n", + "\n", + "📂 hard_pleasant/ (1개 파일)\n", + " 📄 guillealvarez_IcI3FizU9Cw_small.jpg (19.7KB)\n", + "\n", + "📂 hard_risky/ (5개 파일)\n", + " 📄 abject_yfqkXV6mgb8_small.jpg (39.6KB)\n", + " 📄 chaneljones_OVKmcoviT5c_small.jpg (14.6KB)\n", + " 📄 meric_3KJpF86nR4c_small.jpg (57.7KB)\n", + " ... 외 2개 파일\n", + "\n", + "📂 hard_unpleasant/ (0개 파일)\n", + "\n", + "📂 soft_chaotic/ (9개 파일)\n", + " 📄 mlapergolaphoto_6j4XdVdDkMo_small.jpg (21.5KB)\n", + " 📄 mlapergolaphoto_JyRZ9Zii9Hs_small.jpg (29.8KB)\n", + " 📄 mlapergolaphoto_oNPIlTbJG3w_small.jpg (30.9KB)\n", + " ... 외 6개 파일\n", + "\n", + "📂 soft_cozy/ (38개 파일)\n", + " 📄 anya_h_wPCb3fGYFv8_small.jpg (13.0KB)\n", + " 📄 caleb_woods_1Sg2fZbQoAw_small.jpg (24.6KB)\n", + " 📄 caleb_woods_55JYT5c_NOM_small.jpg (23.8KB)\n", + " ... 외 35개 파일\n", + "\n", + "📂 soft_dull/ (33개 파일)\n", + " 📄 anoopvlenspoetry_hvzyw4bZ9PI_small.jpg (18.2KB)\n", + " 📄 beratorer_JtUoXYoSexA_small.jpg (35.2KB)\n", + " 📄 chezzeche_L2KXJsBe-mk_small.jpg (7.6KB)\n", + " ... 외 30개 파일\n", + "\n", + "📂 soft_energetic/ (39개 파일)\n", + " 📄 americanaez225_NuZ8amFmQcQ_small.jpg (34.4KB)\n", + " 📄 artem_kniaz_aY0C2WqxNB4_small.jpg (24.8KB)\n", + " 📄 bielej_XLbQ6zRb7gM_small.jpg (28.9KB)\n", + " ... 외 36개 파일\n", + "\n", + "📂 soft_harmonic/ (40개 파일)\n", + " 📄 aks_by_aamir_w7E562N0t6o_small.jpg (44.3KB)\n", + " 📄 benceboros_kF-3bgOMgyY_small.jpg (20.6KB)\n", + " 📄 christianbuehner_dyl7uw5ePKY_small.jpg (24.2KB)\n", + " ... 외 37개 파일\n", + "\n", + "📂 soft_miserable/ (0개 파일)\n", + "\n", + "📂 soft_pleasant/ (0개 파일)\n", + "\n", + "📂 soft_pleasure/ (55개 파일)\n", + " 📄 ahmetyuksek_oPNZyJeXjxo_small.jpg (33.7KB)\n", + " 📄 alexcrphoto_C0Tt7BxT-2U_small.jpg (15.7KB)\n", + " 📄 alexdinaut_dSkhj6Llhd0_small.jpg (19.2KB)\n", + " ... 외 52개 파일\n", + "\n", + "📂 soft_risky/ (0개 파일)\n", + "\n", + "📂 soft_unpleasant/ (54개 파일)\n", + " 📄 aldyrkhanov_YGV0MvcmtZI_small.jpg (28.6KB)\n", + " 📄 allisonsaeng_vP1uxYV5kgE_small.jpg (5.3KB)\n", + " 📄 arishojaei_yysdzh1CuR0_small.jpg (34.3KB)\n", + " ... 외 51개 파일\n", + "\n", + "📂 warm_cozy/ (78개 파일)\n", + " 📄 ahmetyuksek_jj5_AYJBC38_small.jpg (41.8KB)\n", + " 📄 alin_luna_9EfuA4qW8cs_small.jpg (28.8KB)\n", + " 📄 alin_luna_Q9PVfi054kQ_small.jpg (34.1KB)\n", + " ... 외 75개 파일\n", + "\n", + "📂 warm_dull/ (30개 파일)\n", + " 📄 anniespratt_SyMWmDWnLOs_small.jpg (25.6KB)\n", + " 📄 anniespratt_xvwATuAthDk_small.jpg (8.3KB)\n", + " 📄 anniespratt_xz485Eku8O4_small.jpg (9.6KB)\n", + " ... 외 27개 파일\n", + "\n", + "📂 warm_energetic/ (49개 파일)\n", + " 📄 americanaez225_NuZ8amFmQcQ_small.jpg (34.4KB)\n", + " 📄 arstyy_Ui2SOBevHl4_small.jpg (35.4KB)\n", + " 📄 a_d_s_w_uTAzl9JSRro_small.jpg (13.3KB)\n", + " ... 외 46개 파일\n", + "\n", + "📊 전체 요약:\n", + " - 총 폴더: 32개\n", + " - 총 파일: 911개\n", + " - 전체 크기: 25.76MB\n" + ] + } + ], + "source": [ + "def show_folder_structure(base_path=\"C:/Users/EL081/Desktop/apitest/unsplash_images\"):\n", + " \"\"\"다운로드된 폴더 구조와 파일 정보 표시\"\"\"\n", + " \n", + " base_path = Path(base_path)\n", + " \n", + " if not base_path.exists():\n", + " print(f\"❌ 폴더가 존재하지 않습니다: {base_path}\")\n", + " return\n", + " \n", + " print(f\"📁 폴더 구조: {base_path}\")\n", + " print(\"=\"*60)\n", + " \n", + " total_folders = 0\n", + " total_files = 0\n", + " \n", + " # 하위 폴더들 확인\n", + " folders = [f for f in base_path.iterdir() if f.is_dir()]\n", + " \n", + " if not folders:\n", + " print(\"📂 태그 폴더가 없습니다. 먼저 사진을 다운로드해주세요.\")\n", + " return\n", + " \n", + " for folder in sorted(folders):\n", + " folder_name = folder.name\n", + " images = list(folder.glob(\"*.jpg\")) + list(folder.glob(\"*.jpeg\")) + list(folder.glob(\"*.png\"))\n", + " \n", + " total_folders += 1\n", + " total_files += len(images)\n", + " \n", + " print(f\"\\n📂 {folder_name}/ ({len(images)}개 파일)\")\n", + " \n", + " # 각 폴더의 처음 3개 파일만 표시\n", + " for i, img_file in enumerate(images[:3]):\n", + " file_size = img_file.stat().st_size / 1024 # KB 단위\n", + " print(f\" 📄 {img_file.name} ({file_size:.1f}KB)\")\n", + " \n", + " if len(images) > 3:\n", + " print(f\" ... 외 {len(images) - 3}개 파일\")\n", + " \n", + " print(f\"\\n📊 전체 요약:\")\n", + " print(f\" - 총 폴더: {total_folders}개\")\n", + " print(f\" - 총 파일: {total_files}개\")\n", + " \n", + " # 전체 폴더 크기 계산\n", + " total_size = 0\n", + " for folder in folders:\n", + " for file in folder.glob(\"*.*\"):\n", + " if file.is_file():\n", + " total_size += file.stat().st_size\n", + " \n", + " total_size_mb = total_size / (1024 * 1024)\n", + " print(f\" - 전체 크기: {total_size_mb:.2f}MB\")\n", + "\n", + "# 폴더 구조 확인\n", + "show_folder_structure()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/upload.py b/upload.py new file mode 100644 index 0000000000000000000000000000000000000000..a44ec6be94b5436336924da8884cfadbde65b96c --- /dev/null +++ b/upload.py @@ -0,0 +1,9 @@ +from huggingface_hub import HfApi +import os + +api = HfApi(token=os.getenv("HF_TOKEN")) +HfApi().upload_large_folder( + folder_path="C:/Users/EL081/Desktop/local_backup/image", + repo_id="Smilesjs/HAPTIX_dataset_team", + repo_type="dataset", +)