linkmerce 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.3
 Name: linkmerce
-Version: 0.2.0
+Version: 0.2.2
 Summary: E-commerce API integration management
 Requires-Dist: aiohttp>=3.12.14
-Requires-Dist: asyncio>=3.4.3
 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
 Requires-Python: >=3.10

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

@@ -1,15 +1,16 @@
 [project]
 name = "linkmerce"
-version = "0.2.0"
+version = "0.2.2"
 description = "E-commerce API integration management"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "aiohttp>=3.12.14",
-    "asyncio>=3.4.3",
     "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.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/base.py

@@ -9,8 +9,8 @@ if TYPE_CHECKING:
     from typing import Any, Coroutine, Hashable, IO, Literal, TypeVar
     from linkmerce.collect.tasks import RequestLoop, RequestEach
     from linkmerce.collect.tasks import PaginateAll, RequestEachPages
-    from linkmerce.types import JsonObject, JsonSerialize, ResponseComponent
-    from linkmerce.types import TaskOption, TaskOptions
+    from linkmerce.common import JsonObject, JsonSerialize, ResponseComponent
+    from linkmerce.common import TaskOption, TaskOptions
     _KT = TypeVar("_KT", Hashable)
     _VT = TypeVar("_VT", Any)
 
@@ -221,23 +221,6 @@ class RequestSessionClient(BaseSessionClient):
         response = self.request_text(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
         return BeautifulSoup(response, features)
 
-    def request_table(
-            self,
-            method: str,
-            url: str,
-            params: dict | list[tuple] | bytes | None = None,
-            data: dict | list[tuple] | bytes | IO | None = None,
-            json: JsonSerialize | None = None,
-            headers: dict[str,str] = None,
-            cookies: dict | RequestsCookieJar = None,
-            content_type: Literal["excel", "csv", "html", "xml"] | Sequence = "xlsx",
-            table_options: dict = dict(),
-            **kwargs
-        ):
-        from linkmerce.extensions.pandas import read_table
-        response = self.request_content(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
-        return read_table(response, table_format=content_type, **table_options)
-
     def with_session(func):
         @functools.wraps(func)
         def wrapper(self: RequestSessionClient, *args, init_session: bool = False, **kwargs):
@@ -365,23 +348,6 @@ class AiohttpSessionClient(BaseSessionClient):
         response = await self.request_async_text(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
         return BeautifulSoup(response, features)
 
-    async def request_async_table(
-            self,
-            method: str,
-            url: str,
-            params: dict | list[tuple] | bytes | None = None,
-            data: dict | list[tuple] | bytes | IO | None = None,
-            json: JsonSerialize | None = None,
-            headers: dict[str,str] = None,
-            cookies: dict | LooseCookies = None,
-            content_type: Literal["excel", "csv", "html", "xml"] | Sequence = "xlsx",
-            table_options: dict = dict(),
-            **kwargs
-        ):
-        from linkmerce.extensions.pandas import read_table
-        response = await self.request_async_content(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
-        return read_table(response, table_format=content_type, **table_options)
-
     def async_with_session(func):
         @functools.wraps(func)
         async def wrapper(self: AiohttpSessionClient, *args, init_session: bool = False, **kwargs):
@@ -561,13 +527,14 @@ class Collector(SessionClient, ParserClient, TaskClient, metaclass=ABCMeta):
                 message[key] = getattr(self, f"get_request_{attr}")(**kwargs)
         return message
 
-    def generate_date_pairs(
+    def generate_date_context(
             self,
-            start: dt.date | str,
-            end: dt.date | str,
+            start_date: dt.date | str,
+            end_date: dt.date | str,
             freq: Literal["D","W","M"] = "D",
             format: str = "%Y-%m-%d",
-        ) -> tuple[dt.date,dt.date] | list[tuple[dt.date,dt.date]]:
+        ) -> list[dict[str,dt.date]] | dict[str,dt.date]:
         from linkmerce.utils.datetime import date_pairs
-        pairs = date_pairs(start, end, freq, format)
-        return pairs[0] if len(pairs) == 1 else pairs
+        pairs = date_pairs(start_date, end_date, freq, format)
+        context = list(map(lambda values: dict(zip(["start_date","end_date"], values)), pairs))
+        return context[0] if len(context) == 1 else context

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/naver/api/__init__.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Hashable, IO, Literal, TypeVar
-    from linkmerce.types import JsonSerialize
+    from linkmerce.common import JsonSerialize
     _KT = TypeVar("_KT", Hashable)
     _VT = TypeVar("_VT", Any)
 

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/naver/api/search.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Iterable, Literal
-    from linkmerce.types import JsonObject, TaskOptions
+    from linkmerce.common import JsonObject, TaskOptions
 
 
 class _SearchCollector(NaverOpenAPI):

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/searchad/manage/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Hashable, IO, Literal, TypeVar
-    from linkmerce.types import JsonSerialize
+    from linkmerce.common import JsonSerialize
     _KT = TypeVar("_KT", Hashable)
     _VT = TypeVar("_VT", Any)
 
@@ -62,7 +62,7 @@ class SearchAdManager(Collector):
         headers = super().get_request_headers(referer=redirect_url, origin=self.origin)
         response = self.request_text("GET", url, headers=headers)
         if response.strip() != "true":
-            from linkmerce.exceptions import AuthenticationError
+            from linkmerce.common import AuthenticationError
             raise AuthenticationError("Authentication failed: cookies are invalid.")
 
     def authorize(self):

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/searchad/manage/exposure.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Iterable, Literal
-    from linkmerce.types import JsonObject, TaskOptions
+    from linkmerce.common import JsonObject, TaskOptions
 
 
 class ExposureDiagnosis(SearchAdManager):

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/smartstore/hcenter/catalog.py

@@ -6,7 +6,7 @@ from typing import Iterable, TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Callable, Coroutine, Literal, Sequence
     from linkmerce.collect.tasks import RequestEachPages
-    from linkmerce.types import JsonObject, TaskOptions
+    from linkmerce.common import JsonObject, TaskOptions
 
 
 class _CatalogCollector(PartnerCenter):
@@ -278,3 +278,26 @@ class BrandProduct(_CatalogCollector):
                 "categoryShapeType", "categoryLeafYn", "productStatusCode", "saleMethodTypeCode"
             ]
         }, "totalCount"]
+
+
+class ProductPrice(BrandProduct):
+    object_type = "products"
+    products: list[dict] = list()
+
+    def _build_and_request(self, **json) -> JsonObject:
+        message = self.build_request(json=json)
+        response = self.request_json(**message)
+        self._update_products(response, **json)
+        return response
+
+    async def _build_and_request_async(self, **json) -> JsonObject:
+        message = self.build_request(json=json)
+        response = await self.request_async_json(**message)
+        self._update_products(response, **json)
+        return response
+
+    def _update_products(self, response: JsonObject, **kwargs):
+        try:
+            self.products += self.parse(response, parser="ProductList", **kwargs)
+        except:
+            pass

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/collect/smartstore/hcenter/sales.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Iterable, Literal
-    from linkmerce.types import JsonObject, TaskOptions
+    from linkmerce.common import JsonObject, TaskOptions
     import datetime as dt
 
 
@@ -31,15 +31,15 @@ class _SalesCollector(PartnerCenter):
             page_size: int = 1000,
             **kwargs
         ) -> JsonObject:
-        date_pairs = self.generate_date_pairs(start_date, end_date, freq=date_type[0], format=self.date_format)
-        return (self.request_each(self._build_and_request)
-                .partial(date_type=date_type, page_size=page_size).expand(mall_seq=mall_seq, date_pairs=date_pairs, page=page)
+        context = self.generate_date_context(start_date, end_date, freq=date_type[0].upper(), format=self.date_format)
+        return (self.request_each(self._build_and_request, context=context)
+                .partial(date_type=date_type, page_size=page_size).expand(mall_seq=mall_seq, page=page)
                 .parse(**self.update_parser(**kwargs)).concat("auto").run())
 
     @PartnerCenter.async_with_session
     async def collect_async(
             self,
-            mall_seq: int | 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",
@@ -47,9 +47,9 @@ class _SalesCollector(PartnerCenter):
             page_size: int = 1000,
             **kwargs
         ) -> JsonObject:
-        date_pairs = self.generate_date_pairs(start_date, end_date, freq=date_type[0], format=self.date_format)
-        return await (self.request_each(self._build_and_request_async)
-                .partial(date_type=date_type, page_size=page_size).expand(mall_seq=mall_seq, date_pairs=date_pairs, page=page)
+        context = self.generate_date_context(start_date, end_date, freq=date_type[0].upper(), format=self.date_format)
+        return await (self.request_each(self._build_and_request_async, context=context)
+                .partial(date_type=date_type, page_size=page_size).expand(mall_seq=mall_seq, page=page)
                 .parse(**self.update_parser(**kwargs)).concat("auto").run_async())
 
     def _build_and_request(self, **json) -> JsonObject:
@@ -63,7 +63,8 @@ class _SalesCollector(PartnerCenter):
     def get_request_body(
             self,
             mall_seq: int | str,
-            date_pairs: tuple[dt.date,dt.date],
+            start_date: dt.date,
+            end_date: dt.date,
             date_type: Literal["daily","weekly","monthly"] = "daily",
             page: int = 1,
             page_size: int = 1000,
@@ -74,8 +75,8 @@ class _SalesCollector(PartnerCenter):
                 "queryRequest": {
                     "mallSequence": str(mall_seq),
                     "dateType": date_type.capitalize(),
-                    "startDate": str(date_pairs[0]),
-                    "endDate": str(date_pairs[1]),
+                    "startDate": str(start_date),
+                    "endDate": str(end_date),
                     **({"sortBy": "PaymentAmount"} if self.sales_type != "store" else dict()),
                     **({"pageable": {"page":int(page), "size":int(page_size)}} if self.sales_type != "store" else dict()),
                 }
@@ -141,3 +142,26 @@ class ProductSales(_SalesCollector):
             {"visit": ["click"]},
             {"rest": [{"comparePreWeek": ["isNewlyAdded"]}]},
         ]
+
+
+class AggregatedSales(ProductSales):
+    sales_type = "product"
+    products: list[dict] = list()
+
+    def _build_and_request(self, **json) -> JsonObject:
+        message = self.build_request(json=json)
+        response = self.request_json(**message)
+        self._update_products(response, **json)
+        return response
+
+    async def _build_and_request_async(self, **json) -> JsonObject:
+        message = self.build_request(json=json)
+        response = await self.request_async_json(**message)
+        self._update_products(response, **json)
+        return response
+
+    def _update_products(self, response: JsonObject, **kwargs):
+        try:
+            self.products += self.parse(response, parser="ProductList", **kwargs)
+        except:
+            pass

linkmerce-0.2.0/src/linkmerce/types.py → linkmerce-0.2.2/src/linkmerce/common.py

@@ -12,3 +12,19 @@ ResponseComponent = Union[int, bytes, str, JsonObject, dict[str,str]]
 
 TaskOption = Dict[_KT,_VT]
 TaskOptions = Dict[_KT,TaskOption]
+
+
+class AuthenticationError(RuntimeError):
+    ...
+
+
+class ParseError(ValueError):
+    ...
+
+
+class RequestError(RuntimeError):
+    ...
+
+
+class UnauthorizedError(RuntimeError):
+    ...

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/parse/base.py

@@ -21,7 +21,7 @@ class Parser(metaclass=ABCMeta):
         raise NotImplementedError("The 'parse' method must be implemented.")
 
     def raise_parse_error(self, msg: str):
-        from linkmerce.exceptions import ParseError
+        from linkmerce.common import ParseError
         raise ParseError(msg)
 
 
@@ -118,15 +118,17 @@ class QueryParser(RecordsParser, metaclass=ABCMeta):
             self,
             type: Literal["DATE","STRING"] = "DATE",
             format: str | None = "%Y-%m-%d",
+            interval: str | int | None = None,
         ) -> str:
         from linkmerce.utils.duckdb import curret_date
-        return curret_date(type, format)
+        return curret_date(type, format, interval)
 
     def curret_datetime(
             self,
             type: Literal["DATETIME","STRING"] = "DATETIME",
             format: str | None = "%Y-%m-%d %H:%M:%S",
+            interval: str | int | None = None,
             tzinfo: str | None = None,
         ) -> str:
         from linkmerce.utils.duckdb import curret_datetime
-        return curret_datetime(type, format, tzinfo)
+        return curret_datetime(type, format, interval, tzinfo)

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/parse/naver/api/search.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Literal
-    from linkmerce.types import JsonObject
+    from linkmerce.common import JsonObject
 
 
 class _SearchParser(QueryParser):
@@ -27,7 +27,7 @@ class _SearchParser(QueryParser):
         return wrapper
 
     def raise_request_error(self, response: dict):
-        from linkmerce.exceptions import RequestError
+        from linkmerce.common import RequestError
         raise RequestError(response.get("errorMessage") or str())
 
     @check_errors
@@ -194,3 +194,22 @@ class ShoppingRank(_SearchParser):
         """
         created_at = self.curret_datetime()
         return self.render_query(query, keyword=keyword, start=start, created_at=created_at)
+
+
+class ShoppingProduct(_SearchParser):
+    content_type = "shop"
+
+    def make_query(self, keyword: str, start: int, **kwargs) -> str:
+        query = """
+        SELECT
+            productId AS nvMid,
+            TRY_CAST(REGEXP_EXTRACT(link, '/products/(\\d+)$', 1) AS INT64) AS mallPid,
+            '{{ keyword }}' AS keyword,
+            ((TRY_CAST(productType AS INT1) + 2) % 3) AS productType,
+            (ROW_NUMBER() OVER () + {{ start }}) AS displayRank,
+            {{ created_at }} AS createdAt
+        FROM {{ table }}
+        WHERE productId IS NOT NULL
+        """
+        created_at = self.curret_datetime()
+        return self.render_query(query, keyword=keyword, start=start, created_at=created_at)

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/parse/searchad/manage/exposure.py

@@ -6,7 +6,7 @@ import functools
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from linkmerce.types import JsonObject
+    from linkmerce.common import JsonObject
 
 
 class ExposureDiagnosis(QueryParser):
@@ -23,7 +23,7 @@ class ExposureDiagnosis(QueryParser):
         return wrapper
 
     def raise_request_error(self, response: dict):
-        from linkmerce.exceptions import RequestError, UnauthorizedError
+        from linkmerce.common import RequestError, UnauthorizedError
         msg = response.get("title") or response.get("message") or str()
         if (msg == "Forbidden") or ("권한이 없습니다." in msg) or ("인증이 만료됐습니다." in msg):
             raise UnauthorizedError(msg)
@@ -47,7 +47,7 @@ class ExposureDiagnosis(QueryParser):
             NULLIF(fmpBrand, '') AS mallName,
             NULLIF(fmpMaker, '') AS makerName,
             imageUrl,
-            CAST(COALESCE(lowPrice, mobileLowPrice, NULL) AS INT64) AS salesPrice,
+            -- CAST(COALESCE(lowPrice, mobileLowPrice, NULL) AS INT64) AS salesPrice,
             {{ created_at }} AS createdAt
         FROM {{ table }}
         {{ where }}

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/parse/smartstore/hcenter/catalog.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Literal
-    from linkmerce.types import JsonObject
+    from linkmerce.common import JsonObject
 
 
 class _CatalogParser(QueryParser):
@@ -27,7 +27,7 @@ class _CatalogParser(QueryParser):
 
     def raise_request_error(self, response: dict):
         from linkmerce.utils.map import hier_get
-        from linkmerce.exceptions import RequestError
+        from linkmerce.common import RequestError
         msg = hier_get(response, ["errors",0,"message"]) or "null"
         raise RequestError(f"An error occurred during the request: {msg}")
 
@@ -77,13 +77,14 @@ class BrandProduct(_CatalogParser):
         query = """
         SELECT
             TRY_CAST(id AS INT64) AS nvMid,
-            {{ mall_seq }} AS mallPid,
+            {{ product_id }} AS mallPid,
             TRY_CAST(catalogId AS INT64) AS catalogId,
             name AS productName,
             TRY_CAST(NULLIF(makerSeq, '0') AS INT64) AS makerId,
             makerName,
             TRY_CAST(brandSeq AS INT64) AS brandId,
             brandName,
+            TRY_CAST({{ mall_seq }} AS INT64) AS mallSeq,
             mallName,
             TRY_CAST(categoryId AS INT32) AS categoryId,
             categoryName,
@@ -101,5 +102,52 @@ class BrandProduct(_CatalogParser):
             DATE_TRUNC('SECOND', TRY_CAST(registerDate AS TIMESTAMP)) AS registerDate
         FROM {{ table }};
         """
-        mall_seq = "mallProductId" if mall_seq is None else "TRY_CAST(mallProductId AS INT64)"
-        return self.render_query(query, mall_seq=mall_seq)
+        product_id = "mallProductId" if mall_seq is None else "TRY_CAST(mallProductId AS INT64)"
+        return self.render_query(query, mall_seq=mall_seq, product_id=product_id)
+
+
+class ProductPrice(BrandProduct):
+    object_type = "products"
+
+    def make_query(self, mall_seq: int | str | None = None, **kwargs) -> str:
+        query = """
+        SELECT * EXCLUDE (seq)
+        FROM (
+            SELECT
+                {{ product_id }} AS mallPid,
+                TRY_CAST({{ mall_seq }} AS INT64) AS mallSeq,
+                TRY_CAST(categoryId AS INT32) AS categoryId,
+                TRY_CAST(lowestPrice AS INT64) AS salesPrice,
+                {{ yesterday }} AS updateDate,
+                ROW_NUMBER() OVER (PARTITION BY mallPid) AS seq
+            FROM {{ table }}
+        ) WHERE (mallPid IS NOT NULL) AND (seq = 1);
+        """
+        product_id = "mallProductId" if mall_seq is None else "TRY_CAST(mallProductId AS INT64)"
+        yesterday = self.curret_date(interval=-1)
+        return self.render_query(query, mall_seq=mall_seq, product_id=product_id, yesterday=yesterday)
+
+
+class ProductList(BrandProduct):
+    object_type = "products"
+
+    def make_query(self, mall_seq: int | str | None = None, **kwargs) -> str:
+        query = """
+        SELECT * EXCLUDE (seq)
+        FROM (
+            SELECT
+                {{ product_id }} AS mallPid,
+                TRY_CAST({{ mall_seq }} AS INT64) AS mallSeq,
+                TRY_CAST(categoryId AS INT32) AS categoryId,
+                TRY_CAST(SPLIT_PART(fullCategoryId, '>', 3) AS INT32) AS categoryId3,
+                name AS productName,
+                TRY_CAST(lowestPrice AS INT64) AS salesPrice,
+                TRY_CAST(registerDate AS DATE) AS registerDate,
+                {{ today }} AS updateDate,
+                ROW_NUMBER() OVER (PARTITION BY mallPid) AS seq
+            FROM {{ table }}
+        ) WHERE (mallPid IS NOT NULL) AND (seq = 1);
+        """
+        product_id = "mallProductId" if mall_seq is None else "TRY_CAST(mallProductId AS INT64)"
+        today = self.curret_date()
+        return self.render_query(query, mall_seq=mall_seq, product_id=product_id, today=today)

{linkmerce-0.2.0 → linkmerce-0.2.2}/src/linkmerce/parse/smartstore/hcenter/sales.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Literal
-    from linkmerce.types import JsonObject
+    from linkmerce.common import JsonObject
     import datetime as dt
 
 
@@ -30,10 +30,10 @@ class _SalesParser(QueryParser):
         from linkmerce.utils.map import hier_get
         msg = hier_get(response, ["error","error"]) or "null"
         if msg == "Unauthorized":
-            from linkmerce.exceptions import UnauthorizedError
+            from linkmerce.common import UnauthorizedError
             raise UnauthorizedError("Unauthorized request")
         else:
-            from linkmerce.exceptions import RequestError
+            from linkmerce.common import RequestError
             raise RequestError(f"An error occurred during the request: {msg}")
 
     @check_errors
@@ -41,14 +41,16 @@ class _SalesParser(QueryParser):
             self,
             response: JsonObject,
             mall_seq: int | str | None = None,
-            date_pairs: tuple[dt.date,dt.date] = tuple(),
+            start_date: dt.date | None = None,
+            end_date: dt.date | None = None,
             date_type: Literal["daily","weekly","monthly"] = "daily",
             **kwargs
         ) -> list[dict]:
         data = response["data"][f"{self.sales_type}Sales"]
         mall_seq = string if (string := str(mall_seq)).isdigit() else "NULL"
-        date_part = self.build_date_part(*date_pairs, date_type=date_type)
-        return self.select(data, self.make_query(mall_seq, date_part)) if data else list()
+        date_part = self.build_date_part(start_date, end_date, date_type)
+        kwargs = dict(mall_seq=mall_seq, date_part=date_part, start_date=start_date, end_date=end_date)
+        return self.select(data, self.make_query(**kwargs)) if data else list()
 
     def build_date_part(self, start_date = None, end_date = None, date_type = "daily") -> str:
         if date_type == "daily":
@@ -110,3 +112,61 @@ class ProductSales(_SalesParser):
         FROM {{ table }};
         """
         return self.render_query(query, mall_seq=mall_seq, date_part=date_part)
+
+
+class AggregatedSales(ProductSales):
+    object_type = "products"
+
+    def make_query(self, mall_seq: str, date_part: str, **kwargs) -> str:
+        query = """
+        WITH product_sales AS (
+            SELECT
+                TRY_CAST(product.identifier AS INT64) AS mallPid,
+                {{ mall_seq }} AS mallSeq,
+                TRY_CAST(product.category.identifier AS INT32) AS categoryId3,
+                visit.click AS clickCount,
+                sales.paymentCount AS paymentCount,
+                sales.paymentAmount AS paymentAmount,
+                {{ date_part }}
+            FROM {{ table }}
+        )
+
+        SELECT
+            mallPid,
+            MAX(mallSeq) AS mallSeq,
+            MAX(categoryId3) AS categoryId3,
+            SUM(clickCount) AS clickCount,
+            SUM(paymentCount) AS paymentCount,
+            SUM(paymentAmount) AS paymentAmount,
+            {{ date_group }}
+        FROM product_sales
+        WHERE mallPid IS NOT NULL
+        GROUP BY mallPid, {{ date_group }};
+        """
+        date_group = "paymentDate" if "paymentDate" in date_part else "startDate, endDate"
+        return self.render_query(query, mall_seq=mall_seq, date_part=date_part, date_group=date_group)
+
+
+class ProductList(ProductSales):
+    object_type = "products"
+
+    def make_query(self, mall_seq: str, start_date: dt.date | None = None, **kwargs) -> str:
+        query = """
+        SELECT * EXCLUDE (seq)
+        FROM (
+            SELECT
+                TRY_CAST(product.identifier AS INT64) AS mallPid,
+                {{ mall_seq }} AS mallSeq,
+                NULL AS categoryId,
+                TRY_CAST(product.category.identifier AS INT32) AS categoryId3,
+                product.name AS productName,
+                NULL AS salesPrice,
+                {{ start_date }} AS registerDate,
+                {{ today }} AS updateDate,
+                ROW_NUMBER() OVER (PARTITION BY mallPid) AS seq
+            FROM {{ table }}
+        ) WHERE (mallPid IS NOT NULL) AND (seq = 1);
+        """
+        start_date = f"DATE '{start_date}'" if start_date is not None else "NULL"
+        today = self.curret_date()
+        return self.render_query(query, mall_seq=mall_seq, start_date=start_date, today=today)