linkmerce 0.3.0__tar.gz → 0.3.2__tar.gz

{linkmerce-0.3.0 → linkmerce-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: linkmerce
-Version: 0.3.0
+Version: 0.3.2
 Summary: E-commerce API integration management
 Requires-Dist: aiohttp>=3.12.15
 Requires-Dist: bs4>=0.0.2

{linkmerce-0.3.0 → linkmerce-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linkmerce"
-version = "0.3.0"
+version = "0.3.2"
 description = "E-commerce API integration management"
 readme = "README.md"
 requires-python = ">=3.10"

{linkmerce-0.3.0 → linkmerce-0.3.2}/src/linkmerce/api/naver/openapi.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Iterable, Literal
     from linkmerce.common.extract import JsonObject
+    from linkmerce.common.load import DuckDBConnection
 
 
 def get_module(name: str) -> str:
@@ -21,8 +22,9 @@ def search_blog(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -30,7 +32,7 @@ def search_blog(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "BlogSearch", "BlogSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "BlogSearch", "BlogSearch", connection, how, table, return_type, args, **options)
 
 
 def search_news(
@@ -40,8 +42,9 @@ def search_news(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -49,7 +52,7 @@ def search_news(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "NewsSearch", "NewsSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "NewsSearch", "NewsSearch", connection, how, table, return_type, args, **options)
 
 
 def search_book(
@@ -59,8 +62,9 @@ def search_book(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -68,7 +72,7 @@ def search_book(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "BookSearch", "BookSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "BookSearch", "BookSearch", connection, how, table, return_type, args, **options)
 
 
 def search_cafe(
@@ -78,8 +82,9 @@ def search_cafe(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -87,7 +92,7 @@ def search_cafe(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "CafeSearch", "CafeSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "CafeSearch", "CafeSearch", connection, how, table, return_type, args, **options)
 
 
 def search_kin(
@@ -97,8 +102,9 @@ def search_kin(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date","point"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -106,7 +112,7 @@ def search_kin(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "KiNSearch", "KiNSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "KiNSearch", "KiNSearch", connection, how, table, return_type, args, **options)
 
 
 def search_image(
@@ -117,8 +123,9 @@ def search_image(
         display: int = 100,
         sort: Literal["sim","date"] = "sim",
         filter: Literal["all","large","medium","small"] = "all",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -126,7 +133,7 @@ def search_image(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "ImageSearch", "ImageSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "ImageSearch", "ImageSearch", connection, how, table, return_type, args, **options)
 
 
 def search_shop(
@@ -136,8 +143,9 @@ def search_shop(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date","asc","dsc"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -145,7 +153,7 @@ def search_shop(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "ShoppingSearch", "ShoppingSearch", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "ShoppingSearch", "ShoppingSearch", connection, how, table, return_type, args, **options)
 
 
 def rank_shop(
@@ -155,8 +163,9 @@ def rank_shop(
         start: int | Iterable[int] = 1,
         display: int = 100,
         sort: Literal["sim","date","asc","dsc"] = "sim",
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> dict[str,JsonObject]:
@@ -164,4 +173,4 @@ def rank_shop(
     table = [get_table(transform_options, "rank_table"), get_table(transform_options, "product_table", "product")]
     extract_options = dict(extract_options or dict(), variables=dict(client_id=client_id, client_secret=client_secret))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".search"), "ShoppingRank", "ShoppingRank", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".search"), "ShoppingRank", "ShoppingRank", connection, how, table, return_type, args, **options)

{linkmerce-0.3.0 → linkmerce-0.3.2}/src/linkmerce/api/searchad/manage.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Iterable, Literal
     from linkmerce.common.extract import JsonObject
+    from linkmerce.common.load import DuckDBConnection
 
 
 def get_module(name: str) -> str:
@@ -21,7 +22,8 @@ def exposure_diagnosis(
         domain: Literal["search","shopping"] = "search",
         mobile: bool = True,
         is_own: bool | None = None,
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        connection: DuckDBConnection | None = None,
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -29,7 +31,7 @@ def exposure_diagnosis(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies), variables=dict(customer_id=customer_id))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".exposure"), "ExposureDiagnosis", "ExposureDiagnosis", "sync", table, return_type, args, **options)
+    return run_with_duckdb(get_module(".exposure"), "ExposureDiagnosis", "ExposureDiagnosis", connection, "sync", table, return_type, args, **options)
 
 
 def exposure_rank(
@@ -39,7 +41,8 @@ def exposure_rank(
         domain: Literal["search","shopping"] = "search",
         mobile: bool = True,
         is_own: bool | None = None,
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        connection: DuckDBConnection | None = None,
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -47,4 +50,4 @@ def exposure_rank(
     table = [get_table(transform_options, "rank_table"), get_table(transform_options, "product_table", "product")]
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies), variables=dict(customer_id=customer_id))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".exposure"), "ExposureRank", "ExposureRank", "sync", table, return_type, args, **options)
+    return run_with_duckdb(get_module(".exposure"), "ExposureRank", "ExposureRank", connection, "sync", table, return_type, args, **options)

{linkmerce-0.3.0 → linkmerce-0.3.2}/src/linkmerce/api/smartstore/brand.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Iterable, Literal
     from linkmerce.common.extract import JsonObject
+    from linkmerce.common.load import DuckDBConnection
     import datetime as dt
 
 
@@ -22,8 +23,9 @@ def brand_catalog(
         is_brand_catalog: bool | None = None,
         page: int | list[int] | None = 0,
         page_size: int = 100,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -31,7 +33,7 @@ def brand_catalog(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".catalog"), "BrandCatalog", "BrandCatalog", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".catalog"), "BrandCatalog", "BrandCatalog", connection, how, table, return_type, args, **options)
 
 
 def brand_product(
@@ -42,8 +44,9 @@ def brand_product(
         is_brand_catalog: bool | None = None,
         page: int | list[int] | None = 0,
         page_size: int = 100,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -51,7 +54,7 @@ def brand_product(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".catalog"), "BrandProduct", "BrandProduct", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".catalog"), "BrandProduct", "BrandProduct", connection, how, table, return_type, args, **options)
 
 
 def brand_price(
@@ -62,8 +65,9 @@ def brand_price(
         is_brand_catalog: bool | None = None,
         page: int | list[int] | None = 0,
         page_size: int = 100,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -71,7 +75,28 @@ def brand_price(
     table = [get_table(transform_options, "price_table"), get_table(transform_options, "product_table", "product")]
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".catalog"), "BrandPrice", "BrandPrice", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".catalog"), "BrandPrice", "BrandPrice", connection, how, table, return_type, args, **options)
+
+
+def match_catalog(
+        cookies: str,
+        brand_ids: str | Iterable[str],
+        mall_seq: int | str | Iterable[int | str],
+        sort_type: Literal["popular","recent","price"] = "recent",
+        is_brand_catalog: bool | None = None,
+        page: int | list[int] | None = 0,
+        page_size: int = 100,
+        connection: DuckDBConnection | None = None,
+        how: Literal["sync","async","async_loop"] = "sync",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (brand_ids, mall_seq, sort_type, is_brand_catalog, page, page_size)
+    table = get_table(transform_options, "table")
+    extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
+    options = dict(extract_options=extract_options, transform_options=transform_options)
+    return run_with_duckdb(get_module(".catalog"), "MatchCatalog", "MatchCatalog", connection, how, table, return_type, args, **options)
 
 
 def store_sales(
@@ -82,8 +107,9 @@ def store_sales(
         date_type: Literal["daily","weekly","monthly"] = "daily",
         page: int | Iterable[int] = 1,
         page_size: int = 1000,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -91,7 +117,7 @@ def store_sales(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".sales"), "StoreSales", "StoreSales", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".sales"), "StoreSales", "StoreSales", connection, how, table, return_type, args, **options)
 
 
 def category_sales(
@@ -102,8 +128,9 @@ def category_sales(
         date_type: Literal["daily","weekly","monthly"] = "daily",
         page: int | Iterable[int] = 1,
         page_size: int = 1000,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -111,7 +138,7 @@ def category_sales(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".sales"), "CategorySales", "CategorySales", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".sales"), "CategorySales", "CategorySales", connection, how, table, return_type, args, **options)
 
 
 def product_sales(
@@ -122,8 +149,9 @@ def product_sales(
         date_type: Literal["daily","weekly","monthly"] = "daily",
         page: int | Iterable[int] = 1,
         page_size: int = 1000,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -131,7 +159,7 @@ def product_sales(
     table = get_table(transform_options, "table")
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".sales"), "ProductSales", "ProductSales", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".sales"), "ProductSales", "ProductSales", connection, how, table, return_type, args, **options)
 
 
 def aggregated_sales(
@@ -142,8 +170,9 @@ def aggregated_sales(
         date_type: Literal["daily","weekly","monthly"] = "daily",
         page: int | Iterable[int] = 1,
         page_size: int = 1000,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
-        return_type: Literal["csv","json","parquet","raw"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> JsonObject:
@@ -151,4 +180,4 @@ def aggregated_sales(
     table = [get_table(transform_options, "sales_table"), get_table(transform_options, "product_table", "product")]
     extract_options = dict(extract_options or dict(), headers=dict(cookies=cookies))
     options = dict(extract_options=extract_options, transform_options=transform_options)
-    return run_with_duckdb(get_module(".sales"), "AggregatedSales", "AggregatedSales", how, table, return_type, args, **options)
+    return run_with_duckdb(get_module(".sales"), "AggregatedSales", "AggregatedSales", connection, how, table, return_type, args, **options)

{linkmerce-0.3.0 → linkmerce-0.3.2}/src/linkmerce/common/api.py

@@ -6,6 +6,7 @@ if TYPE_CHECKING:
     from typing import Any, Literal, Type
     from linkmerce.common.extract import Extractor, JsonObject
     from linkmerce.common.transform import Transformer, DBTransformer, DuckDBTransformer
+    from linkmerce.common.load import DuckDBConnection
 
 
 ###################################################################
@@ -109,14 +110,18 @@ def run_with_duckdb(
         module: str,
         extractor: str,
         transformer: str | None = None,
+        connection: DuckDBConnection | None = None,
         how: Literal["sync","async","async_loop"] = "sync",
         table: str | Sequence[str] = ":default:",
-        return_type: Literal["raw","csv","json","parquet"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
         args: tuple = tuple(),
         kwargs: dict = dict(),
         extract_options: dict | None = None,
         transform_options: dict | None = None,
     ) -> Any | dict[str,Any]:
+    if connection is not None:
+        return run_with_duckdb_connection(
+            module, connection, extractor, transformer, how, table, return_type, args, kwargs, extract_options, transform_options)
     extract_options = extract_options.copy() if isinstance(extract_options, dict) else dict()
     has_parser = not ((return_type == "raw") or ("parser" in extract_options))
     with import_dbt(module if has_parser else None, transformer)(**(transform_options or dict())) as transformer_:
@@ -127,6 +132,30 @@ def run_with_duckdb(
         return _fetch_all_from_table(transformer_, results, table, return_type)
 
 
+def run_with_duckdb_connection(
+        module: str,
+        connection: DuckDBConnection,
+        extractor: str,
+        transformer: str | None = None,
+        how: Literal["sync","async","async_loop"] = "sync",
+        table: str | Sequence[str] = ":default:",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
+        args: tuple = tuple(),
+        kwargs: dict = dict(),
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> Any | dict[str,Any]:
+    extract_options = extract_options.copy() if isinstance(extract_options, dict) else dict()
+    transform_options = dict(transform_options or dict(), db_info=dict(conn=connection))
+    has_parser = not ((return_type == "raw") or ("parser" in extract_options))
+    transformer_ = import_dbt(module, transformer)(**transform_options)
+    if transformer and has_parser:
+        extract_options["parser"] = transformer_.transform
+    extractor_ = import_extractor(module, extractor)(**extract_options)
+    results = _extract(extractor_, how, args, kwargs)
+    return _fetch_all_from_table(transformer_, results, table, return_type)
+
+
 def get_table_from_options(transform_options: dict | None = None, key: str = "table", default: str = ":default:") -> str:
     if isinstance(transform_options, dict):
         create_options = transform_options.get("create_options")
@@ -143,14 +172,15 @@ def _fetch_all_from_table(
         transformer: DuckDBTransformer,
         results: JsonObject,
         table: str | Sequence[str] = ":default:",
-        return_type: Literal["raw","csv","json","parquet"] = "json",
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
     ) -> Any | dict[str,Any]:
+    if return_type == "none":
+        return
     if (return_type == "raw") or (transformer.conn is None):
         return results
-    fetch_all = getattr(transformer, f"fetch_all_to_{return_type}")
-    if isinstance(table, str):
-        return fetch_all(_get_table(transformer, table))
+    elif isinstance(table, str):
+        return transformer.fetch_all(return_type, _get_table(transformer, table))
     elif isinstance(table, Sequence):
-        return {_get_table(transformer, table_): fetch_all(table_) for table_ in table}
+        return {_get_table(transformer, table_): transformer.fetch_all(return_type, table_) for table_ in table}
     else:
         raise TypeError("Invalid type for table. A string or sequence type is allowed.")

{linkmerce-0.3.0 → linkmerce-0.3.2}/src/linkmerce/common/extract.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, Hashable, IO, TypeVar, Union, overload, TYPE_C
 
 if TYPE_CHECKING:
     from typing import Coroutine, Literal, Sequence
+
     from linkmerce.common.tasks import TaskOption, TaskOptions
     from linkmerce.common.tasks import RequestLoop, RequestEach, RequestEachLoop
     from linkmerce.common.tasks import PaginateAll, RequestEachPages
@@ -18,9 +19,9 @@ if TYPE_CHECKING:
 
 _KT = TypeVar("_KT", bound=Hashable)
 _VT = TypeVar("_VT", bound=Any)
-
 Headers = dict[_KT,_VT]
 Variables = dict[_KT,_VT]
+
 JsonObject = Union[dict, list]
 JsonSerialize = Union[dict, list, bytes, IO]
 ResponseComponent = Union[int, bytes, str, JsonObject, dict[str,str]]