for _ in range(10):
    process() # 実行する処理

import asyncio

async def execute():
    task_list = [
        asyncio.create_task(async_process())
        for _ in range(10)
    ]
    for task in task_list:
        await task

def start():
    # スレッドの実行
    asyncio.run(execute())

import multiprocessing

proc_list = []
for _ in range(10):
    proc = multiprocessing.Process(target=process)
    proc.start()
    proc_list.append(proc)
for p in proc_list:
    p.join()

import threading

threads = []
for _ in range(10):
    thread = threading.Thread(target=process)
    thread.start()
    threads.append(thread)
for t in threads:
    t.join()

import _xxsubinterpreters as interpreters  # type: ignore
from inspect import getsource
from textwrap import dedent

# 関数を文字列に変換、インデントを除去する
process_str = dedent(getsource(process))
for _ in range(10):
    intp_id = interpreters.create()
    interpreters.run_string(intp_id, process_str)
    interpreters.destroy(intp_id)

import _xxsubinterpreters as interpreters  # type: ignore
from inspect import getsource
from textwrap import dedent

def call_subinterpreter():
    # 関数を文字列に変換、インデントを除去する
    process_str = dedent(getsource(process))
    intp_id = interpreters.create()
    interpreters.run_string(intp_id, process_str)
    interpreters.destroy(intp_id)

# threadingを使って実行する
threads = []
for _ in range(10):
    thread = threading.Thread(target=call_subinterpreter)
    thread.start()
    threads.append(thread)
for t in threads:
    t.join()

import _xxsubinterpreters as interpreters  # type: ignore
from inspect import getsource
from textwrap import dedent

def call_subinterpreter():
    # 関数を文字列に変換、インデントを除去する
    process_str = dedent(getsource(process))
    intp_id = interpreters.create()
    interpreters.run_string(intp_id, process_str)
    interpreters.destroy(intp_id)

# subprocessを使って実行する
proc_list = []
for _ in range(10):
    proc = multiprocessing.Process(target=call_subinterpreter)
    proc.start()
    proc_list.append(proc)
for p in proc_list:
    p.join()

def fib_r(seq):
    if seq <= 1:
        return seq
    return fib_r(seq - 1) + fib_r(seq - 2)

res = fib_r(process_count)

import matplotlib.pyplot as plt

# ウォーターフォールチャートのデータを用意する（開始秒、終了秒のタプル）
span_data = [
    (0.0, 1.0),
    (1.0, 2.0),
    (2.0, 3.0),
]

# ボックスプロットを描画する
plt.boxplot(
    # 2と3の間が箱、それ以外はひげになるため、箱だけを書く
    # データは若いものが上になるように逆順にする
    x=[[s[0], s[0], s[1], s[1]] for s in span_data.__reversed__()],
    labels=[f"{i}" for i in range(len(span_data), 0, -1)],
    # デザインを設定する
    vert=False,  # 横向きにする
    patch_artist=True,  # 色を設定
    boxprops=dict(  # 箱の色を設定
        facecolor="#0972d3",
        color="#0972d3",
    ),
    medianprops=dict(color="black", linewidth=0),  # 箱の上の線は消す
)

# 描画する
plt.show()

sleep(1.0)

await asyncio.sleep(1.0)

bucket = boto3.resource("s3").Bucket(BUCKET_NAME)
content = bucket.Object(FILES[index]).get()["Body"].read()

s3 = boto3.client("s3")
my_config = Config(region_name="ap-northeast-1", signature_version="s3v4")
s3 = boto3.client("s3", config=my_config)
presigned_url = s3.generate_presigned_url(
    ClientMethod="get_object",
    Params={
        "Bucket": BUCKET_NAME,
        "Key": FILES[index],
    },
    ExpiresIn=3600,
)

import urllib3

response = urllib3.PoolManager().request(method="get", url=presigned_url)
res = response.data

import aiohttp
from aiohttp.client import URL

async with aiohttp.ClientSession() as session:
    async with session.request(
        method="get",
        url=URL(presigned_url, encoded=True),
    ) as response:
        res = await response.read()

import boto3
from botocore.auth import SigV4Auth
from botocore.credentials import create_credential_resolver
from botocore.awsrequest import prepare_request_dict, create_request_object
from botocore.model import OperationModel


class Boto3LowLevelClient:
    _service_name: str
    _credential_scope: str
    _boto3_session = None
    _client = None

    def __init__(
        self,
        service_name: str,
        credential_scope: str = None,
        region_name: str = None,
        profile_name: str = None,
    ) -> None:
        # サービス名を確保する
        # 権限スコープは基本的にサービス名に同じ、異なるなら個別に設定する
        self._service_name = service_name
        if credential_scope is None:
            self._credential_scope = service_name
        else:
            self._credential_scope = credential_scope
        # boto3のセッションを確保する
        self._boto3_session = boto3.Session(
            region_name=region_name, profile_name=profile_name
        )
        # boto3のクライアントを作成する
        self._client = self._boto3_session.client(service_name)

    def create_request_parameter(self, method_name: str, method_parameter: dict):
        """
        boto3への要求情報を作成する
        """

        # クライアントから関数の定義情報を参照する
        operation_model: OperationModel = self._client._service_model.operation_model(
            method_name
        )
        request_dict = self._client._serializer.serialize_to_request(
            method_parameter, operation_model
        )

        # 今の環境に設定されている認証情報を取得する
        resolver = create_credential_resolver(self._boto3_session._session)
        credentials = resolver.load_credentials()
        # リージョン名を取得する
        region_name = self._boto3_session.region_name
        # エンドポイントのurlを取得する
        endpoint_url = f"https://{self._service_name}.{region_name}.amazonaws.com"

        # 要求情報にコンテキストとエンドポイントを書き込む
        prepare_request_dict(
            request_dict,
            endpoint_url,
            {
                "client_region": region_name,
                "client_config": self._client.meta.config,
                "has_streaming_input": operation_model.has_streaming_input,
                "auth_type": operation_model.auth_type,
            },
            user_agent=self._client._user_agent_creator.to_string(),
        )

        # リクエストに対して署名する
        request = create_request_object(request_dict)
        SigV4Auth(
            credentials=credentials,
            service_name=self._credential_scope,
            region_name=region_name,
        ).add_auth(request)

        # ヘッダを辞書型に詰め直す
        headers = {}
        for kv in request.headers.__dict__["_headers"]:
            headers[kv[0]] = kv[1]

        return {
            "method": request.method,
            "url": request.url,
            "body": request.body.decode("utf-8"),
            "headers": headers,
        }

import urllib3
import json

# 署名をboto3から抜き取る
sts = Boto3LowLevelClient("sts")
# stsのget_caller_identityを作成する
get_caller_identity = sts.create_request_parameter("GetCallerIdentity", {})

# urllib3やaiohttpで実行する
# ここからはboto3ではないので、並列化やサブインタープリター内での実行ができる
res = urllib3.PoolManager().request(**get_caller_identity)
print(res.data.decode("utf-8"))

import urllib3
import json

# Bedrockは署名スコープがbedrockになるので、そこだけ指定する
bedrock_runtime = Boto3LowLevelClient(
    "bedrock-runtime", credential_scope="bedrock", region_name="us-east-1"
)
# BedrockRuntimeのinvoke_modelを作成する
invoke_model = bedrock_runtime.create_request_parameter(
    "InvokeModel",
    {
        "body": json.dumps(
            {
                "anthropic_version": "bedrock-2023-05-31",
                "max_tokens": 100,
                "messages": [
                    {
                        "role": "user",
                        "content": "こんにちは、Claude",
                    }
                ],
            }
        ),
        "modelId": "anthropic.claude-3-haiku-20240307-v1:0",
        "accept": "application/json",
        "contentType": "application/json",
    },
)

# urllib3やaiohttpで実行する
# ここからはboto3ではないので、並列化やサブインタープリター内での実行ができる
res = urllib3.PoolManager().request(**invoke_model)
print(res.data.decode("utf-8"))

import aiohttp
from aiohttp.client import URL

async with aiohttp.ClientSession() as session:
    async with session.request(
        method=invoke_model["method"],
        url=URL(invoke_model["url"], encoded=True), # encoded=Trueを指定
        data=invoke_model["body"], # 引数の変数名が違うので、dataにする
        headers=invoke_model["headers"],
    ) as response:
        res = await response.text()