import requests
import json
import time
import logging
from typing import Optional, Dict, Any
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

# ログ設定
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# セッションの設定（接続プーリングとリトライ戦略）
def create_session_with_retry() -> requests.Session:
    """
    リトライ戦略とタイムアウト設定を含むセッションを作成
    """
    session = requests.Session()
    
    # リトライ戦略の設定
    retry_strategy = Retry(
        total=3,  # 最大リトライ回数
        backoff_factor=1,  # リトライ間の待機時間（指数バックオフ）
        status_forcelist=[429, 500, 502, 503, 504],  # リトライ対象のステータスコード
        method_whitelist=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"],
        raise_on_status=False
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

# 堅牢なAPIリクエスト関数
def make_api_request(
    method: str,
    url: str,
    data: Optional[Dict[str, Any]] = None,
    headers: Optional[Dict[str, str]] = None,
    timeout: int = 30,
    max_retries: int = 3
) -> Optional[requests.Response]:
    """
    エラーハンドリングとリトライ機能を持つAPIリクエスト関数
    """
    session = create_session_with_retry()
    
    # デフォルトヘッダーの設定
    default_headers = {
        'Content-Type': 'application/json',
        'User-Agent': 'InfraAutomation/1.0'
    }
    if headers:
        default_headers.update(headers)
    
    for attempt in range(max_retries):
        try:
            logger.info(f"APIリクエスト実行 (試行 {attempt + 1}/{max_retries}): {method} {url}")
            
            # リクエストの実行
            if method.upper() == 'GET':
                response = session.get(url, headers=default_headers, timeout=timeout)
            elif method.upper() == 'POST':
                response = session.post(url, json=data, headers=default_headers, timeout=timeout)
            elif method.upper() == 'PUT':
                response = session.put(url, json=data, headers=default_headers, timeout=timeout)
            elif method.upper() == 'DELETE':
                response = session.delete(url, headers=default_headers, timeout=timeout)
            else:
                raise ValueError(f"サポートされていないHTTPメソッド: {method}")
            
            # レスポンスの検証
            if response.status_code < 500:  # 5xxエラー以外はリトライしない
                return response
            else:
                logger.warning(f"サーバーエラー (試行 {attempt + 1}): {response.status_code}")
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt  # 指数バックオフ
                    logger.info(f"{wait_time}秒後にリトライします...")
                    time.sleep(wait_time)
                
        except requests.exceptions.Timeout:
            logger.error(f"タイムアウトエラー (試行 {attempt + 1}): {url}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
        except requests.exceptions.ConnectionError as e:
            logger.error(f"接続エラー (試行 {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
        except requests.exceptions.RequestException as e:
            logger.error(f"リクエストエラー: {e}")
            raise
    
    return None

# 使用例
if __name__ == "__main__":
    # --- GETリクエストの例 ---
    print("--- GET リクエスト ---")
    try:
        response_get = make_api_request('GET', "https://jsonplaceholder.typicode.com/posts/1")
        if response_get and response_get.status_code == 200:
            print(f"ステータスコード: {response_get.status_code}")
            print(f"レスポンスボディ:\n{json.dumps(response_get.json(), indent=2, ensure_ascii=False)}")
        else:
            print(f"エラー: {response_get.status_code if response_get else 'リクエスト失敗'}")
    except Exception as e:
        logger.error(f"GETリクエストでエラーが発生: {e}")
    
    # --- POSTリクエストの例 (新しい投稿を作成) ---
    print("\n--- POST リクエスト ---")
    post_data = {
        "title": "My New Infra Automation Post",
        "body": "This is a test post created via Python requests library for infra automation.",
        "userId": 101
    }
    
    try:
        response_post = make_api_request('POST', "https://jsonplaceholder.typicode.com/posts", data=post_data)
        if response_post and response_post.status_code == 201:
            print(f"ステータスコード: {response_post.status_code}")
            print(f"レスポンスボディ:\n{json.dumps(response_post.json(), indent=2, ensure_ascii=False)}")
        else:
            print(f"エラー: {response_post.status_code if response_post else 'リクエスト失敗'}")
    except Exception as e:
        logger.error(f"POSTリクエストでエラーが発生: {e}")
    
    # --- PUTリクエストの例 (既存の投稿を更新) ---
    print("\n--- PUT リクエスト ---")
    put_data = {
        "id": 1,
        "title": "Updated Infra Automation Title",
        "body": "This post has been updated.",
        "userId": 1
    }
    
    try:
        response_put = make_api_request('PUT', "https://jsonplaceholder.typicode.com/posts/1", data=put_data)
        if response_put and response_put.status_code == 200:
            print(f"ステータスコード: {response_put.status_code}")
            print(f"レスポンスボディ:\n{json.dumps(response_put.json(), indent=2, ensure_ascii=False)}")
        else:
            print(f"エラー: {response_put.status_code if response_put else 'リクエスト失敗'}")
    except Exception as e:
        logger.error(f"PUTリクエストでエラーが発生: {e}")
    
    # --- DELETEリクエストの例 (投稿を削除) ---
    print("\n--- DELETE リクエスト ---")
    try:
        response_delete = make_api_request('DELETE', "https://jsonplaceholder.typicode.com/posts/1")
        if response_delete and response_delete.status_code in [200, 204]:
            print(f"ステータスコード: {response_delete.status_code}")
            print("投稿が正常に削除されました。")
        else:
            print(f"エラー: {response_delete.status_code if response_delete else 'リクエスト失敗'}")
    except Exception as e:
        logger.error(f"DELETEリクエストでエラーが発生: {e}")

import requests
import time
import logging
from typing import Optional
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def robust_api_request(
    url: str,
    method: str = 'GET',
    data: Optional[dict] = None,
    timeout: int = 30,
    max_retries: int = 3,
    backoff_factor: float = 1.0
) -> Optional[requests.Response]:
    """
    堅牢なAPIリクエスト関数
    - 自動リトライ機能
    - 指数バックオフ
    - 包括的なエラーハンドリング
    - タイムアウト設定
    """
    
    # セッション設定
    session = requests.Session()
    
    # リトライ戦略の設定
    retry_strategy = Retry(
        total=max_retries,
        backoff_factor=backoff_factor,
        status_forcelist=[429, 500, 502, 503, 504, 522, 524],
        method_whitelist=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"],
        raise_on_status=False
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    # ヘッダー設定
    headers = {
        "User-Agent": "InfraAutomation/1.0",
        "Accept": "application/json",
        "Content-Type": "application/json"
    }
    
    for attempt in range(max_retries):
        try:
            logger.info(f"APIリクエスト開始 (試行 {attempt + 1}/{max_retries}): {method} {url}")
            
            # リクエスト実行
            if method.upper() == 'GET':
                response = session.get(url, headers=headers, timeout=timeout)
            elif method.upper() == 'POST':
                response = session.post(url, json=data, headers=headers, timeout=timeout)
            elif method.upper() == 'PUT':
                response = session.put(url, json=data, headers=headers, timeout=timeout)
            elif method.upper() == 'DELETE':
                response = session.delete(url, headers=headers, timeout=timeout)
            else:
                raise ValueError(f"サポートされていないHTTPメソッド: {method}")
            
            # レスポンス処理
            if response.status_code == 200:
                logger.info(f"リクエスト成功: {response.status_code}")
                return response
            elif response.status_code == 404:
                logger.warning(f"リソースが見つかりません: {url}")
                return response  # 404は通常リトライしない
            elif response.status_code == 429:
                # レート制限の場合、Retry-Afterヘッダーを確認
                retry_after = response.headers.get('Retry-After')
                if retry_after:
                    wait_time = int(retry_after)
                    logger.warning(f"レート制限に達しました。{wait_time}秒後にリトライします")
                    time.sleep(wait_time)
                else:
                    # 指数バックオフ
                    wait_time = backoff_factor * (2 ** attempt)
                    logger.warning(f"レート制限に達しました。{wait_time}秒後にリトライします")
                    time.sleep(wait_time)
            elif 500 <= response.status_code < 600:
                logger.error(f"サーバーエラー: {response.status_code}")
                if attempt < max_retries - 1:
                    wait_time = backoff_factor * (2 ** attempt)
                    logger.info(f"{wait_time}秒後にリトライします")
                    time.sleep(wait_time)
                else:
                    return response
            else:
                logger.error(f"予期しないステータスコード: {response.status_code}")
                return response
                
        except requests.exceptions.Timeout:
            logger.error(f"タイムアウトエラー (試行 {attempt + 1}): {url}")
            if attempt < max_retries - 1:
                wait_time = backoff_factor * (2 ** attempt)
                logger.info(f"タイムアウト後のリトライ: {wait_time}秒後")
                time.sleep(wait_time)
            else:
                logger.error("最大リトライ回数に達しました（タイムアウト）")
                raise
                
        except requests.exceptions.ConnectionError as e:
            logger.error(f"接続エラー (試行 {attempt + 1}): {e}")
            if attempt < max_retries - 1:
                wait_time = backoff_factor * (2 ** attempt)
                logger.info(f"接続エラー後のリトライ: {wait_time}秒後")
                time.sleep(wait_time)
            else:
                logger.error("最大リトライ回数に達しました（接続エラー）")
                raise
                
        except requests.exceptions.RequestException as e:
            logger.error(f"リクエスト例外: {e}")
            raise
            
        except Exception as e:
            logger.error(f"予期せぬエラー: {e}")
            raise
    
    logger.error("すべてのリトライが失敗しました")
    return None

# 使用例
if __name__ == "__main__":
    # 存在しないリソースへのアクセスを試みる
    try:
        response = robust_api_request(
            "https://jsonplaceholder.typicode.com/nonexistent-resource",
            timeout=10,
            max_retries=3
        )
        
        if response:
            if response.status_code == 200:
                print("リクエスト成功！")
                print(f"レスポンス: {response.json()}")
            elif response.status_code == 404:
                print("リソースが見つかりませんでした")
            else:
                print(f"エラーレスポンス: {response.status_code}")
                print(f"レスポンスボディ: {response.text}")
        else:
            print("リクエストが完全に失敗しました")
            
    except requests.exceptions.Timeout:
        print("リクエストがタイムアウトしました")
    except requests.exceptions.ConnectionError:
        print("接続エラーが発生しました")
    except Exception as e:
        print(f"予期せぬエラーが発生しました: {e}")

import requests
import time
from typing import Optional, Tuple
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

class APIClient:
    """
    タイムアウト設定とリトライ機能を持つAPIクライアント
    """
    
    def __init__(self, base_url: str, timeout: Tuple[int, int] = (10, 30)):
        """
        初期化
        Args:
            base_url: APIのベースURL
            timeout: (接続タイムアウト, 読み取りタイムアウト)
        """
        self.base_url = base_url.rstrip('/')
        self.timeout = timeout
        self.session = self._create_session()
    
    def _create_session(self) -> requests.Session:
        """
        セッションの作成とリトライ設定
        """
        session = requests.Session()
        
        # リトライ戦略の設定
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[408, 429, 500, 502, 503, 504],
            method_whitelist=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        return session
    
    def request(self, method: str, endpoint: str, **kwargs) -> Optional[requests.Response]:
        """
        APIリクエストの実行
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        
        # デフォルトのタイムアウト設定を適用
        kwargs.setdefault('timeout', self.timeout)
        
        try:
            response = self.session.request(method, url, **kwargs)
            return response
        except requests.exceptions.Timeout as e:
            print(f"タイムアウト発生: {url} - {e}")
            return None
        except requests.exceptions.RequestException as e:
            print(f"リクエストエラー: {e}")
            return None
    
    def get(self, endpoint: str, **kwargs) -> Optional[requests.Response]:
        """GETリクエスト"""
        return self.request('GET', endpoint, **kwargs)
    
    def post(self, endpoint: str, **kwargs) -> Optional[requests.Response]:
        """POSTリクエスト"""
        return self.request('POST', endpoint, **kwargs)

# 使用例
if __name__ == "__main__":
    # APIクライアントの作成（接続タイムアウト5秒、読み取りタイムアウト20秒）
    client = APIClient("https://jsonplaceholder.typicode.com", timeout=(5, 20))
    
    # タイムアウト設定でリクエスト実行
    response = client.get("/posts/1")
    if response:
        print(f"ステータス: {response.status_code}")
        print(f"データ: {response.json()}")
    else:
        print("リクエストが失敗しました")

import asyncio
import aiohttp
import time
from typing import List, Dict, Any

async def fetch_data(session: aiohttp.ClientSession, url: str) -> Dict[str, Any]:
    """
    非同期でデータを取得
    """
    try:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as response:
            if response.status == 200:
                return await response.json()
            else:
                return {"error": f"HTTP {response.status}"}
    except asyncio.TimeoutError:
        return {"error": "タイムアウト"}
    except Exception as e:
        return {"error": str(e)}

async def fetch_multiple_endpoints(urls: List[str]) -> List[Dict[str, Any]]:
    """
    複数のエンドポイントを並行して呼び出し
    """
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_data(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

# 使用例
if __name__ == "__main__":
    urls = [
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
        "https://jsonplaceholder.typicode.com/posts/3",
        "https://jsonplaceholder.typicode.com/users/1",
        "https://jsonplaceholder.typicode.com/users/2"
    ]
    
    # 同期処理の時間測定
    start_time = time.time()
    sync_results = []
    for url in urls:
        response = requests.get(url, timeout=30)
        sync_results.append(response.json() if response.status_code == 200 else {"error": response.status_code})
    sync_time = time.time() - start_time
    
    # 非同期処理の時間測定
    start_time = time.time()
    async_results = asyncio.run(fetch_multiple_endpoints(urls))
    async_time = time.time() - start_time
    
    print(f"同期処理時間: {sync_time:.2f}秒")
    print(f"非同期処理時間: {async_time:.2f}秒")
    print(f"効率化: {sync_time/async_time:.2f}倍高速")

import requests
import json
import logging
from typing import Optional, Dict, Any

logger = logging.getLogger(__name__)

def get_user_data_safely(user_id: int, timeout: int = 30) -> Optional[Dict[str, Any]]:
    """
    ユーザーデータを安全に取得する関数
    - タイムアウト設定
    - エラーハンドリング
    - JSONパースエラー対応
    """
    url = f"https://jsonplaceholder.typicode.com/users/{user_id}"
    
    try:
        response = requests.get(
            url,
            timeout=timeout,
            headers={
                "User-Agent": "InfraAutomation/1.0",
                "Accept": "application/json"
            }
        )
        
        # HTTP エラーチェック
        if response.status_code == 200:
            try:
                user_data = response.json()
                logger.info(f"ユーザー {user_id} のデータ取得成功")
                return user_data
            except json.JSONDecodeError as e:
                logger.error(f"JSONパースエラー: {e}")
                logger.error(f"レスポンス内容: {response.text[:200]}...")
                return None
        elif response.status_code == 404:
            logger.warning(f"ユーザー {user_id} が見つかりません")
            return None
        else:
            logger.error(f"HTTPエラー: {response.status_code}")
            logger.error(f"レスポンス: {response.text}")
            return None
            
    except requests.exceptions.Timeout:
        logger.error(f"タイムアウト: {url}")
        return None
    except requests.exceptions.ConnectionError:
        logger.error(f"接続エラー: {url}")
        return None
    except requests.exceptions.RequestException as e:
        logger.error(f"リクエストエラー: {e}")
        return None
    except Exception as e:
        logger.error(f"予期せぬエラー: {e}")
        return None

# 使用例
if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    
    user_data = get_user_data_safely(1)
    if user_data:
        print(f"\nユーザーデータ:\n{json.dumps(user_data, indent=2, ensure_ascii=False)}")
    else:
        print("ユーザーデータの取得に失敗しました")

import logging
from typing import Dict, Any, Optional

logger = logging.getLogger(__name__)

def extract_user_info(user_data: Dict[str, Any]) -> Optional[Dict[str, str]]:
    """
    ユーザーデータから必要な情報を安全に抽出する関数
    - None値チェック
    - デフォルト値の設定
    - エラーハンドリング
    """
    if not user_data or not isinstance(user_data, dict):
        logger.error("不正なユーザーデータです")
        return None
    
    try:
        # 基本情報の抽出
        name = user_data.get('name', 'N/A')
        email = user_data.get('email', 'N/A')
        
        # 住所情報の安全な抽出
        address = user_data.get('address', {})
        if isinstance(address, dict):
            street = address.get('street', '')
            suite = address.get('suite', '')
            city = address.get('city', '')
            zipcode = address.get('zipcode', '')
            
            # 空でない要素のみを結合
            address_parts = [part for part in [street, suite, city, zipcode] if part.strip()]
            full_address = ', '.join(address_parts) if address_parts else 'N/A'
        else:
            logger.warning("住所情報の形式が不正です")
            full_address = 'N/A'
        
        # 会社情報の安全な抽出
        company = user_data.get('company', {})
        if isinstance(company, dict):
            company_name = company.get('name', 'N/A')
            catch_phrase = company.get('catchPhrase', 'N/A')
        else:
            logger.warning("会社情報の形式が不正です")
            company_name = 'N/A'
            catch_phrase = 'N/A'
        
        extracted_info = {
            'name': name,
            'email': email,
            'address': full_address,
            'company_name': company_name,
            'catch_phrase': catch_phrase
        }
        
        logger.info("ユーザー情報の抽出が完了しました")
        return extracted_info
        
    except Exception as e:
        logger.error(f"ユーザー情報の抽出中にエラーが発生: {e}")
        return None

def validate_and_format_user_data(user_data: Dict[str, Any]) -> str:
    """
    ユーザーデータを検証し、フォーマットされた文字列として返す
    """
    try:
        extracted = extract_user_info(user_data)
        if not extracted:
            return "ユーザー情報の抽出に失敗しました"
        
        formatted_output = f"""
抽出した情報:
  名前: {extracted['name']}
  メール: {extracted['email']}
  住所: {extracted['address']}
  会社名: {extracted['company_name']}
  キャッチフレーズ: '{extracted['catch_phrase']}'
"""
        return formatted_output.strip()
        
    except Exception as e:
        logger.error(f"フォーマット処理中にエラーが発生: {e}")
        return "データのフォーマット中にエラーが発生しました"

# 使用例
if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    
    # 前のセクションで取得したuser_dataを使用
    user_data = get_user_data_safely(1)
    if user_data:
        formatted_info = validate_and_format_user_data(user_data)
        print(formatted_info)
    else:
        print("ユーザーデータの取得に失敗したため、情報を抽出できませんでした")