linkmerce 0.2.2__tar.gz → 0.3.1__tar.gz

{linkmerce-0.2.2 → linkmerce-0.3.1}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: linkmerce
-Version: 0.2.2
+Version: 0.3.1
 Summary: E-commerce API integration management
-Requires-Dist: aiohttp>=3.12.14
+Requires-Dist: aiohttp>=3.12.15
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: pyarrow>=21.0.0
 Requires-Dist: pytz>=2025.2
 Requires-Dist: requests>=2.32.4
 Requires-Dist: tqdm>=4.67.1

{linkmerce-0.2.2 → linkmerce-0.3.1}/pyproject.toml

@@ -1,15 +1,14 @@
 [project]
 name = "linkmerce"
-version = "0.2.2"
+version = "0.3.1"
 description = "E-commerce API integration management"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "aiohttp>=3.12.14",
+    "aiohttp>=3.12.15",
     "bs4>=0.0.2",
     "duckdb>=1.3.2",
     "jinja2>=3.1.6",
-    "pyarrow>=21.0.0",
     "pytz>=2025.2",
     "requests>=2.32.4",
     "tqdm>=4.67.1",

linkmerce-0.3.1/src/linkmerce/api/naver/openapi.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from linkmerce.common.api import run_with_duckdb
+from linkmerce.common.api import get_table_from_options as get_table
+
+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:
+    return (".naver.openapi" + name) if name.startswith('.') else name
+
+
+def search_blog(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_news(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_book(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_cafe(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_kin(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_image(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        start: int | Iterable[int] = 1,
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort, filter)
+    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", connection, how, table, return_type, args, **options)
+
+
+def search_shop(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)
+
+
+def rank_shop(
+        client_id: str,
+        client_secret: str,
+        query: str | Iterable[str],
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> dict[str,JsonObject]:
+    args = (query, start, display, sort)
+    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", connection, how, table, return_type, args, **options)

linkmerce-0.3.1/src/linkmerce/api/searchad/manage.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from linkmerce.common.api import run_with_duckdb
+from linkmerce.common.api import get_table_from_options as get_table
+
+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:
+    return (".searchad.manage" + name) if name.startswith('.') else name
+
+
+def exposure_diagnosis(
+        customer_id: str,
+        cookies: str,
+        keyword: str | Iterable[str],
+        domain: Literal["search","shopping"] = "search",
+        mobile: bool = True,
+        is_own: bool | None = None,
+        connection: DuckDBConnection | None = None,
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (keyword, domain, mobile, is_own)
+    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", connection, "sync", table, return_type, args, **options)
+
+
+def exposure_rank(
+        customer_id: str,
+        cookies: str,
+        keyword: str | Iterable[str],
+        domain: Literal["search","shopping"] = "search",
+        mobile: bool = True,
+        is_own: bool | None = None,
+        connection: DuckDBConnection | None = None,
+        return_type: Literal["csv","json","parquet","raw","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (keyword, domain, mobile, is_own)
+    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", connection, "sync", table, return_type, args, **options)

linkmerce-0.3.1/src/linkmerce/api/smartstore/brand.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from linkmerce.common.api import run_with_duckdb
+from linkmerce.common.api import get_table_from_options as get_table
+
+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
+
+
+def get_module(name: str) -> str:
+    return (".smartstore.brand" + name) if name.startswith('.') else name
+
+
+def brand_catalog(
+        cookies: str,
+        brand_ids: str | Iterable[str],
+        sort_type: Literal["popular","recent","price"] = "poular",
+        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, 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"), "BrandCatalog", "BrandCatalog", connection, how, table, return_type, args, **options)
+
+
+def brand_product(
+        cookies: str,
+        brand_ids: str | Iterable[str],
+        mall_seq: int | str | Iterable[int | str] | None = None,
+        sort_type: Literal["popular","recent","price"] = "poular",
+        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"), "BrandProduct", "BrandProduct", connection, how, table, return_type, args, **options)
+
+
+def brand_price(
+        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, "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", connection, how, table, return_type, args, **options)
+
+
+def store_sales(
+        cookies: str,
+        mall_seq: int | str | Iterable[int | str],
+        start_date: dt.date | str,
+        end_date: dt.date | str,
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (mall_seq, start_date, end_date, date_type, 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(".sales"), "StoreSales", "StoreSales", connection, how, table, return_type, args, **options)
+
+
+def category_sales(
+        cookies: str,
+        mall_seq: int | str | Iterable[int | str],
+        start_date: dt.date | str,
+        end_date: dt.date | str,
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (mall_seq, start_date, end_date, date_type, 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(".sales"), "CategorySales", "CategorySales", connection, how, table, return_type, args, **options)
+
+
+def product_sales(
+        cookies: str,
+        mall_seq: int | str | Iterable[int | str],
+        start_date: dt.date | str,
+        end_date: dt.date | str,
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (mall_seq, start_date, end_date, date_type, 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(".sales"), "ProductSales", "ProductSales", connection, how, table, return_type, args, **options)
+
+
+def aggregated_sales(
+        cookies: str,
+        mall_seq: int | str | Iterable[int | str],
+        start_date: dt.date | str,
+        end_date: dt.date | str,
+        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","none"] = "json",
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> JsonObject:
+    args = (mall_seq, start_date, end_date, date_type, page, page_size)
+    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", connection, how, table, return_type, args, **options)

linkmerce-0.3.1/src/linkmerce/common/api.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
+
+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
+
+
+###################################################################
+############################## Import #############################
+###################################################################
+
+def import_extractor(module: str, attr: str) -> Type[Extractor]:
+    from importlib import import_module
+    obj = import_module(_join(module, "extract"))
+    return getattr(obj, attr)
+
+
+def import_transformer(module: str, attr: str) -> Type[Transformer]:
+    from importlib import import_module
+    obj = import_module(_join(module, "transform"))
+    return getattr(obj, attr)
+
+
+def import_dbt(module: str | None = None, attr: str | None = None) -> Type[DBTransformer]:
+    if module and attr:
+        return import_transformer(module, attr)
+    else:
+        from importlib import import_module
+        module = import_module("linkmerce.common.transform")
+        return getattr(module, "DummyDBTransformer")
+
+
+def _join(path: str, name: str) -> str:
+    if path.startswith('.'):
+        path = "linkmerce.core" + path
+    return path + '.' + name
+
+
+###################################################################
+############################### Run ###############################
+###################################################################
+
+def run(
+        module: str,
+        extractor: str,
+        transformer: str | None = None,
+        how: Literal["sync","async","async_loop"] = "sync",
+        args: tuple = tuple(),
+        kwargs: dict = dict(),
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> Any:
+    extract_options = extract_options.copy() if isinstance(extract_options, dict) else dict()
+    if transformer and ("parser" not in extract_options):
+        transformer_ = import_transformer(module, transformer)(**(transform_options or dict()))
+        extract_options["parser"] = transformer_.transform
+    extractor_ = import_extractor(module, extractor)(**extract_options)
+    return _extract(extractor_, how, args, kwargs)
+
+
+def run_with_connection(
+        module: str,
+        extractor: str,
+        transformer: str | None = None,
+        how: Literal["sync","async","async_loop"] = "sync",
+        args: tuple = tuple(),
+        kwargs: dict = dict(),
+        extract_options: dict | None = None,
+        transform_options: dict | None = None,
+    ) -> Any:
+    extract_options = extract_options.copy() if isinstance(extract_options, dict) else dict()
+    has_parser = ("parser" not in extract_options)
+    with import_dbt(module if has_parser else None, transformer)(**(transform_options or dict())) as transformer_:
+        if transformer and has_parser:
+            extract_options["parser"] = transformer_.transform
+        extractor_ = import_extractor(module, extractor)(**extract_options)
+        return _extract(extractor_, how, args, kwargs)
+
+
+def _extract(
+        extractor: Extractor,
+        how: Literal["sync","async","async_loop"] = "sync",
+        args: tuple = tuple(),
+        kwargs: dict = dict(),
+    ) -> Any:
+    if how == "sync":
+        return extractor.extract(*args, **kwargs)
+    elif how == "async":
+        import asyncio
+        return asyncio.run(extractor.extract_async(*args, **kwargs))
+    elif how == "async_loop":
+        import asyncio, nest_asyncio
+        nest_asyncio.apply()
+        loop = asyncio.get_running_loop()
+        task = asyncio.create_task(extractor.extract_async(*args, **kwargs))
+        return loop.run_until_complete(task)
+    else:
+        raise ValueError("Invalid value for how to run. Supported values are: sync, async, async_loop.")
+
+
+###################################################################
+######################### Run with DuckDB #########################
+###################################################################
+
+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["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_:
+        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 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")
+        if isinstance(create_options, dict):
+            return create_options.get(key, default)
+    return default
+
+
+def _get_table(transformer: DuckDBTransformer, table: str = ":default:") -> str:
+    return transformer.default_table if table == ":default:" else table
+
+
+def _fetch_all_from_table(
+        transformer: DuckDBTransformer,
+        results: JsonObject,
+        table: str | Sequence[str] = ":default:",
+        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
+    elif isinstance(table, str):
+        return transformer.fetch_all(return_type, _get_table(transformer, table))
+    elif isinstance(table, Sequence):
+        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.1/src/linkmerce/common/exceptions.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+class AuthenticationError(RuntimeError):
+    ...
+
+
+class ParseError(ValueError):
+    ...
+
+
+class RequestError(RuntimeError):
+    ...
+
+
+class UnauthorizedError(RuntimeError):
+    ...