feat: update app structure and replace ujson5 with orjson

Author: pythonhubdev

frameworks/Python/litestar/__pycache__/app.cpython-312.pyc

@@ -7,36 +7,43 @@
 from socketify import ASGI
 
 
-app = Litestar()
-
 @get("/json")
 async def json_serialization():
-    return orjson.dumps({"message": "Hello, world!"})
+	return orjson.dumps({"message": "Hello, world!"})
+
 
 @get("/plaintext", media_type=MediaType.TEXT)
 async def plaintext():
-    return b"Hello, world!"
+	return b"Hello, world!"
 
 
-_is_travis = os.environ.get('TRAVIS') == 'true'
+app = Litestar(
+	route_handlers=[
+		json_serialization,
+		plaintext,
+	]
+)
+
+_is_travis = os.environ.get("TRAVIS") == "true"
 
 workers = int(multiprocessing.cpu_count())
 if _is_travis:
-    workers = 2
+	workers = 2
+
 
 def run_app():
-    ASGI(app).listen(8080, lambda config: logging.info(f"Listening on port http://localhost:{config.port} now\n")).run()
+	ASGI(app).listen(8080, lambda config: logging.info(f"Listening on port http://localhost:{config.port} now\n")).run()
 
 
 def create_fork():
-    n = os.fork()
-    # n greater than 0 means parent process
-    if not n > 0:
-        run_app()
+	n = os.fork()
+	# n greater than 0 means parent process
+	if not n > 0:
+		run_app()
 
 
 # fork limiting the cpu count - 1
 for i in range(1, workers):
-    create_fork()
+	create_fork()
 
-run_app()  # run app on the main process too :)
+run_app()  # run app on the main process too :)

frameworks/Python/litestar/__pycache__/app_orm.cpython-312.pyc

@@ -1,130 +1,136 @@
 import multiprocessing
+import os
 from contextlib import asynccontextmanager
 from pathlib import Path
+from random import randint, sample
+from typing import Any
 
 import asyncpg
-import os
-
 import orjson
-from litestar import Litestar, Request, get, MediaType
-
-from random import randint, sample
-
+from litestar import Litestar, MediaType, Request, get
 from litestar.contrib.jinja import JinjaTemplateEngine
 from litestar.response import Template
 from litestar.template import TemplateConfig
 
 READ_ROW_SQL = 'SELECT "id", "randomnumber" FROM "world" WHERE id = $1'
 WRITE_ROW_SQL = 'UPDATE "world" SET "randomnumber"=$1 WHERE id=$2'
 ADDITIONAL_ROW = [0, "Additional fortune added at request time."]
-MAX_POOL_SIZE = 1000//multiprocessing.cpu_count()
+MAX_POOL_SIZE = 1000 // multiprocessing.cpu_count()
 MIN_POOL_SIZE = max(int(MAX_POOL_SIZE / 2), 1)
 
 
 def get_num_queries(queries):
-    try:
-        query_count = int(queries)
-    except (ValueError, TypeError):
-        return 1
+	try:
+		query_count = int(queries)
+	except (ValueError, TypeError):
+		return 1
 
-    if query_count < 1:
-        return 1
-    if query_count > 500:
-        return 500
-    return query_count
+	if query_count < 1:
+		return 1
+	if query_count > 500:
+		return 500
+	return query_count
 
 
 connection_pool = None
 
 
-
 async def setup_database():
-    return await asyncpg.create_pool(
-        user=os.getenv("PGUSER", "benchmarkdbuser"),
-        password=os.getenv("PGPASS", "benchmarkdbpass"),
-        database="hello_world",
-        host="tfb-database",
-        port=5432,
-        min_size=MIN_POOL_SIZE,
-        max_size=MAX_POOL_SIZE,
-    )
+	return await asyncpg.create_pool(
+		user=os.getenv("PGUSER", "benchmarkdbuser"),
+		password=os.getenv("PGPASS", "benchmarkdbpass"),
+		database="hello_world",
+		host="tfb-database",
+		port=5432,
+		min_size=MIN_POOL_SIZE,
+		max_size=MAX_POOL_SIZE,
+	)
 
 
 @asynccontextmanager
 async def lifespan(app: Litestar):
-    # Set up the database connection pool
-    app.state.connection_pool = await setup_database()
-    yield
-    # Close the database connection pool
-    await app.state.connection_pool.close()
-
-
-app = Litestar(lifespan=[lifespan],   template_config=TemplateConfig(
-        directory=Path("templates"),
-        engine=JinjaTemplateEngine,
-    ),)
+	# Set up the database connection pool
+	app.state.connection_pool = await setup_database()
+	yield
+	# Close the database connection pool
+	await app.state.connection_pool.close()
 
 
 @get("/json")
-async def json_serialization():
-    return orjson.dumps({"message": "Hello, world!"})
+async def json_serialization() -> bytes:
+	return orjson.dumps({"message": "Hello, world!"})
 
 
 @get("/db")
-async def single_database_query():
-    row_id = randint(1, 10000)
-    async with app.state.connection_pool.acquire() as connection:
-        number = await connection.fetchval(READ_ROW_SQL, row_id)
+async def single_database_query() -> bytes:
+	row_id = randint(1, 10000)
+	async with app.state.connection_pool.acquire() as connection:
+		number = await connection.fetchval(READ_ROW_SQL, row_id)
 
-    return orjson.dumps({"id": row_id, "randomNumber": number})
+	return orjson.dumps({"id": row_id, "randomNumber": number})
 
 
 @get("/queries")
-async def multiple_database_queries(queries = None):
-    num_queries = get_num_queries(queries)
-    row_ids = sample(range(1, 10000), num_queries)
-    worlds = []
+async def multiple_database_queries(queries: Any = None) -> bytes:
+	num_queries = get_num_queries(queries)
+	row_ids = sample(range(1, 10000), num_queries)
+	worlds = []
 
-    async with app.state.connection_pool.acquire() as connection:
-        statement = await connection.prepare(READ_ROW_SQL)
-        for row_id in row_ids:
-            number = await statement.fetchval(row_id)
-            worlds.append({"id": row_id, "randomNumber": number})
+	async with app.state.connection_pool.acquire() as connection:
+		statement = await connection.prepare(READ_ROW_SQL)
+		for row_id in row_ids:
+			number = await statement.fetchval(row_id)
+			worlds.append({"id": row_id, "randomNumber": number})
 
-    return orjson.dumps(worlds)
+	return orjson.dumps(worlds)
 
 
 @get("/fortunes")
-async def fortunes(request: Request):
-    async with app.state.connection_pool.acquire() as connection:
-        fortunes = await connection.fetch("SELECT * FROM Fortune")
+async def fortunes(request: Request) -> Template:
+	async with app.state.connection_pool.acquire() as connection:
+		fortunes = await connection.fetch("SELECT * FROM Fortune")
 
-    fortunes.append(ADDITIONAL_ROW)
-    fortunes.sort(key=lambda row: row[1])
-    return Template("fortune.html", context={"fortunes": fortunes, "request": request})
+	fortunes.append(ADDITIONAL_ROW)
+	fortunes.sort(key=lambda row: row[1])
+	return Template("fortune.html", context={"fortunes": fortunes, "request": request})
 
 
 @get("/updates")
-async def database_updates(queries = None):
-    num_queries = get_num_queries(queries)
-    # To avoid deadlock
-    ids = sorted(sample(range(1, 10000 + 1), num_queries))
-    numbers = sorted(sample(range(1, 10000), num_queries))
-    updates = list(zip(ids, numbers))
+async def database_updates(queries: Any = None) -> bytes:
+	num_queries = get_num_queries(queries)
+	# To avoid deadlock
+	ids = sorted(sample(range(1, 10000 + 1), num_queries))
+	numbers = sorted(sample(range(1, 10000), num_queries))
+	updates = list(zip(ids, numbers, strict=False))
 
-    worlds = [
-        {"id": row_id, "randomNumber": number} for row_id, number in updates
-    ]
+	worlds = [{"id": row_id, "randomNumber": number} for row_id, number in updates]
 
-    async with app.state.connection_pool.acquire() as connection:
-        statement = await connection.prepare(READ_ROW_SQL)
-        for row_id, _ in updates:
-            await statement.fetchval(row_id)
-        await connection.executemany(WRITE_ROW_SQL, updates)
+	async with app.state.connection_pool.acquire() as connection:
+		statement = await connection.prepare(READ_ROW_SQL)
+		for row_id, _ in updates:
+			await statement.fetchval(row_id)
+		await connection.executemany(WRITE_ROW_SQL, updates)
 
-    return orjson.dumps(worlds)
+	return orjson.dumps(worlds)
 
 
 @get("/plaintext", media_type=MediaType.TEXT)
-async def plaintext():
-    return b"Hello, world!"
+async def plaintext() -> bytes:
+	return b"Hello, world!"
+
+
+app = Litestar(
+	lifespan=[lifespan],
+	template_config=TemplateConfig(
+		directory=Path("templates"),
+		engine=JinjaTemplateEngine,
+	),
+	route_handlers=[
+		json_serialization,
+		single_database_query,
+		multiple_database_queries,
+		fortunes,
+		database_updates,
+		plaintext,
+	],
+)