linkmerce 0.1.0__tar.gz

linkmerce-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: linkmerce
+Version: 0.1.0
+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: lxml>=6.0.0
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: requests>=2.32.4
+Requires-Dist: xlrd>=2.0.2
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# LinkMerce
+- E-commerce API integration management

linkmerce-0.1.0/README.md

@@ -0,0 +1,2 @@
+# LinkMerce
+- E-commerce API integration management

linkmerce-0.1.0/collect/__init__.py

@@ -0,0 +1,3 @@
+from collect.base import Collector
+from collect.base import JsonObject
+from collect.base import GET, POST, OPTIONS, HEAD, PUT, PATCH, DELETE

linkmerce-0.1.0/collect/base.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+from abc import ABCMeta, abstractmethod
+import functools
+
+from typing import Dict, List, Union, TYPE_CHECKING
+JsonObject = Union[Dict, List]
+
+if TYPE_CHECKING:
+    from typing import Any, IO, Literal, Sequence, Tuple
+    from requests import Session, Response
+    from requests.cookies import RequestsCookieJar
+    from aiohttp.client import ClientSession, ClientResponse
+    from aiohttp.typedefs import LooseCookies
+    from bs4 import BeautifulSoup
+    from pandas import DataFrame
+    JsonSerialize = Union[Dict, List, bytes, IO]
+
+
+GET = "GET"
+POST = "POST"
+OPTIONS = "OPTIONS"
+HEAD = "HEAD"
+PUT = "PUT"
+PATCH = "PATCH"
+DELETE = "DELETE"
+
+
+class BaseSessionClient(metaclass=ABCMeta):
+    method = GET
+    url = str()
+
+    def __init__(self, session: Session | ClientSession | None = None, **kwargs):
+        self.init_session(session)
+        self.init_constant(**kwargs)
+
+    def init_session(self, session: Session | ClientSession | None = None):
+        self.session = session
+
+    def init_constant(self, **kwargs):
+        self.set_request_headers(**kwargs)
+
+    @abstractmethod
+    def request(self, **kwargs):
+        raise NotImplementedError("The request method must be implemented.")
+
+    def set_request_headers(self,
+            authority: str = str(),
+            accept: str = "*/*",
+            encoding: str = "gzip, deflate, br",
+            language: Literal["ko","en"] | str = "ko",
+            connection: str = "keep-alive",
+            contents: Literal["form", "javascript", "json", "text", "multipart"] | str | Dict = str(),
+            cookies: str = str(),
+            host: str = str(),
+            origin: str = str(),
+            priority: str = "u=0, i",
+            referer: str = str(),
+            client: str = str(),
+            mobile: bool = False,
+            platform: str = str(),
+            metadata: Literal["cors", "navigate"] | Dict[str,str] = "navigate",
+            https: bool = False,
+            user_agent: str = str(),
+            ajax: bool = False,
+        **kwargs):
+        from utils.headers import make_headers
+        kwargs = {key: value for key, value in locals().items() if key not in ("self","kwargs","make_headers")}
+        self.headers = make_headers(**kwargs)
+
+    def get_request_headers(self, **kwargs) -> Dict[str,str]:
+        return dict(self.headers, **kwargs) if kwargs else self.headers
+
+
+class RequestsSessionClient(BaseSessionClient):
+    def request(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,
+        **kwargs) -> Response:
+        return self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
+
+    def request_status(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,
+        **kwargs) -> int:
+        with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.status_code
+
+    def request_content(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,
+        **kwargs) -> bytes:
+        with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.content
+
+    def request_text(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,
+        **kwargs) -> str:
+        with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.text
+
+    def request_json(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,
+        **kwargs) -> JsonObject:
+        with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.json()
+
+    def request_headers(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,
+        **kwargs) -> Dict[str,str]:
+        with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.headers
+
+    def request_html(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,
+            features: str | Sequence[str] | None = "html.parser",
+        **kwargs) -> BeautifulSoup:
+        from bs4 import BeautifulSoup
+        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) -> DataFrame:
+        from utils.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)
+
+
+class AiohttpSessionClient(BaseSessionClient):
+    def request(self, *args, **kwargs):
+        raise NotImplementedError("This feature does not support synchronous requests. Please use the request_async method instead.")
+
+    async def request_async(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,
+        **kwargs) -> ClientResponse:
+        return await self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs)
+
+    async def request_async_status(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,
+        **kwargs) -> int:
+        async with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.status
+
+    async def request_async_content(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,
+        **kwargs) -> bytes:
+        async with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.content
+
+    async def request_async_text(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,
+        **kwargs) -> str:
+        async with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return await response.text()
+
+    async def request_async_json(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,
+        **kwargs) -> JsonObject:
+        async with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return await response.json()
+
+    async def request_async_headers(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,
+        **kwargs) -> Dict[str,str]:
+        async with self.session.request(method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, **kwargs) as response:
+            return response.headers
+
+    async def request_async_html(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,
+            features: str | Sequence[str] | None = "html.parser",
+        **kwargs) -> BeautifulSoup:
+        from bs4 import BeautifulSoup
+        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) -> DataFrame:
+        from utils.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)
+
+
+class Collector(RequestsSessionClient, AiohttpSessionClient, metaclass=ABCMeta):
+    @abstractmethod
+    def collect(self, *args, **kwargs) -> Any:
+        raise NotImplementedError("This feature does not support synchronous requests. Please use the collect_async method instead.")
+
+    def with_session(func):
+        @functools.wraps(func)
+        def wrapper(self: Collector, *args, init_session=False, **context):
+            if init_session and (self.session is None):
+                import requests
+                with requests.Session() as session:
+                    self.init_session(session)
+                    return func(self, *args, **context)
+            else:
+                return func(self, *args, **context)
+        return wrapper
+
+    async def collect_async(self, *args, **kwargs):
+        raise NotImplementedError("This feature does not support asynchronous requests. Please use the collect method instead.")
+
+    def with_client_session(func):
+        @functools.wraps(func)
+        async def wrapper(self: Collector, *args, init_session=False, **context):
+            if init_session and (self.session is None):
+                import aiohttp
+                async with aiohttp.ClientSession() as session:
+                    self.init_session(session)
+                    return await func(self, *args, **context)
+            else:
+                return await func(self, *args, **context)
+        return wrapper
+
+    def get_request_message(self, *args, **kwargs) -> Dict:
+        raise NotImplementedError("The get_request_message is not implemented.")
+
+    def parse(self, response: Any, *args, **kwargs) -> Any:
+        raise NotImplementedError("The parse method is not implemented.")

linkmerce-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "linkmerce"
+version = "0.1.0"
+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",
+    "lxml>=6.0.0",
+    "openpyxl>=3.1.5",
+    "pandas>=2.3.1",
+    "requests>=2.32.4",
+    "xlrd>=2.0.2",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.0,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = ["auth", "collect", "object", "utils"]
+module-root = ""

linkmerce-0.1.0/utils/headers.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+from typing import Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+
+CHROME_VERSION = 138
+
+
+def make_headers(
+        authority: str = str(),
+        accept: str = "*/*",
+        encoding: str = "gzip, deflate, br",
+        language: Literal["ko","en"] | str = "ko",
+        connection: str = "keep-alive",
+        contents: Literal["form", "javascript", "json", "text", "multipart"] | str | Dict = str(),
+        cookies: str = str(),
+        host: str = str(),
+        origin: str = str(),
+        priority: str = "u=0, i",
+        referer: str = str(),
+        client: str = str(),
+        mobile: bool = False,
+        platform: str = str(),
+        metadata: Literal["cors", "navigate"] | Dict[str,str] = "cors",
+        https: bool = False,
+        user_agent: str = str(),
+        ajax: bool = False,
+        version: int = CHROME_VERSION
+    ) -> Dict[str,str]:
+    from urllib.parse import urlparse
+    return {
+        **({"authority": authority} if authority else dict()),
+        **({"accept": accept} if accept else dict()),
+        **({"accept-encoding": encoding} if encoding else dict()),
+        **({"accept-language": _get_default_language(language)} if language else dict()),
+        **({"connection": connection} if connection else dict()),
+        **({"content-type": _get_content_type(contents)} if contents else dict()),
+        **({"cookie": cookies} if cookies else dict()),
+        **({"host": urlparse(host).hostname} if host else dict()),
+        **({"origin": origin} if origin else dict()),
+        **({"priority": priority} if priority else dict()),
+        **({"referer": referer} if referer else dict()),
+        "sec-ch-ua": (client or _get_default_client(version)),
+        "sec-ch-ua-mobile": f"?{int(mobile)}",
+        "sec-ch-ua-platform": (platform or _get_current_platform()),
+        **_get_fetch_metadata(metadata),
+        **({"upgrade-insecure-requests": "1"} if https else dict()),
+        "user-agent": (user_agent or _get_user_agent(version)),
+        **({"X-Requested-With": "XMLHttpRequest"} if ajax else dict())
+    }
+
+
+def _get_default_language(value: Literal["ko","en"] | str = "ko") -> str:
+    if value == "ko":
+        return "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7"
+    elif value == "en":
+        return "en-US,en;q=0.9"
+    else:
+        return value
+
+
+def _get_content_type(contents: Literal["form", "javascript", "json", "text", "multipart"] | str | Dict):
+    if isinstance(contents, str):
+        if contents == "form":
+            return "application/x-www-form-urlencoded"
+        elif contents == "javascript":
+            return "javascript"
+        elif contents == "json":
+            return "application/json"
+        elif contents == "text":
+            return "text/plain"
+        elif contents == "multipart":
+            return "multipart/form-data"
+        else:
+            return contents
+    elif isinstance(contents, Dict):
+        content_type = _get_content_type(contents["type"])
+        for key, value in contents.items(): # boundary, charset, ...
+            if key != "type":
+                content_type += f"; {key}={value}"
+        return content_type
+    else:
+        raise TypeError("Invalid type for contents. A string or dictionary type is allowed.")
+
+
+def _get_default_client(version: int = CHROME_VERSION) -> str:
+    return f'"Not)A;Brand";v="8", "Chromium";v="{version}", "Google Chrome";v="{version}"'
+
+
+def _get_current_platform() -> str:
+    import platform
+    os_name = platform.system()
+    return "macOS" if os_name == "Darwin" else os_name
+
+
+def _get_fetch_metadata(metadata: Literal["cors", "navigate"] | Dict[str,str] = "navigate") -> Dict[str,str]:
+    if isinstance(metadata, str):
+        if metadata == "cors":
+            return {"sec-fetch-dest": "empty", "sec-fetch-mode": "cors", "sec-fetch-site": "same-origin", "sec-fetch-user": "?1"}
+        elif metadata == "navigate":
+            return {"sec-fetch-dest": "document", "sec-fetch-mode": "navigate", "sec-fetch-site": "none", "sec-fetch-user": "?1"}
+        else:
+            return dict()
+    elif isinstance(metadata, Dict):
+        return metadata
+    else:
+        return dict()
+
+
+def _get_user_agent(version: int = CHROME_VERSION) -> str:
+    return f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{version}.0.0.0 Safari/537.36"

linkmerce-0.1.0/utils/pandas.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+import os
+
+from typing import Iterable, Sequence, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Callable, Dict, Hashable, List, Literal, Union
+    from io import BytesIO, StringIO
+    from pandas import DataFrame
+    from pandas._typing import DtypeArg
+    IndexLabel = Union[Sequence[Hashable], Hashable]
+
+
+TABLE_FORMAT = {".xlsx", ".xls", ".xlsm", ".xlsb", ".csv", ".html", ".xml"}
+
+
+def select_table(data: DataFrame, cols: IndexLabel, dropna: bool=False, reorder: bool=True) -> DataFrame:
+    from_cols, to_cols = (data.columns, _to_sequence(cols)) if reorder else (_to_sequence(cols), data.columns)
+    if dropna:
+        to_cols = [col for col in to_cols if col in from_cols]
+    else:
+        for col in cols:
+            if col not in data:
+                data[col] = None
+    return data[to_cols]
+
+
+###################################################################
+############################ Read Table ###########################
+###################################################################
+
+def read_table(
+        io: bytes | str,
+        table_format: Literal["excel", "csv", "html", "xml"] | Sequence = "xlsx",
+        sheet_name: str | int | List | None = 0,
+        header: int | Sequence[int] | None = 0,
+        dtype: DtypeArg | None = None,
+        engine: Literal["xlrd", "openpyxl", "odf", "pyxlsb", "calamine"] | None = None,
+        parse_dates: bool | Sequence[int] | Sequence[Sequence[str] | Sequence[int]] | Dict[str, Sequence[int] | list[str]] = None,
+        file_pattern: Dict | None = None,
+        **kwargs
+    ) -> DataFrame:
+    import pandas as pd
+
+    def read_io(io: BytesIO | StringIO, format: Literal["excel", "csv", "html", "xml"]) -> DataFrame:
+        if format == "excel":
+            if engine == "xlrd":
+                from xlrd import open_workbook
+                with open_workbook(file_contents=io.getvalue(), logfile=open(os.devnull, 'w')) as wb:
+                    return pd.read_excel(wb, engine="xlrd", **kwargs)
+            else:
+                return pd.read_excel(io, header=header, dtype=dtype, engine=engine, parse_dates=parse_dates, **kwargs)
+        elif format == "csv":
+            return pd.read_csv(io, header=header, dtype=dtype, parse_dates=parse_dates, **kwargs)
+        elif format == "html":
+            index = sheet_name if isinstance(sheet_name, int) else 0
+            return pd.read_html(io, header=header, parse_dates=parse_dates, **kwargs)[index]
+        elif format == "xml":
+            return pd.read_xml(io, parse_dates=parse_dates, **kwargs)
+        else:
+            raise ValueError("Invalid value for table_format. Supported formats are: excel, csv, html, xml.")
+
+    if isinstance(table_format, str):
+        return read_io(_read_bytes(io, file_pattern), table_format)
+    elif isinstance(table_format, Sequence):
+        return _try_sequence(read_io,
+            kwargs = dict(format=_to_sequence(table_format)),
+            persist = dict(io=_read_bytes(io, file_pattern)))
+    else:
+        raise TypeError("Invalid type for table_format. A string or sequence type is allowed.")
+
+
+def _read_bytes(io: bytes | str, file_pattern: Dict | None=None) -> BytesIO | StringIO:
+    from io import BytesIO, StringIO
+    if isinstance(io, str):
+        if (os.path.splitext(io)[1] in TABLE_FORMAT):
+            with open(_get_file_path(io, **(file_pattern or dict())), 'rb') as file:
+                return BytesIO(file.read())
+        else:
+            return StringIO(io)
+    else:
+        return BytesIO(io)
+
+
+def _get_file_path(io: str, regex: bool=False, index: int=0, **kwargs) -> str:
+    if regex:
+        import re
+        root, pattern = os.path.split(io)
+        def search(file_name: str) -> bool:
+            return bool(re.search(pattern, file_name))
+        filtered = list(filter(search, os.listdir(root or '.')))
+        io = os.path.join(root, filtered[index]) if -len(filtered) <= index < len(filtered) else str()
+    if os.path.exists(io):
+        return io
+    else:
+        raise ValueError("File path does not exist: {}".format(f"'{io}'" if isinstance(io, str) else "None"))
+
+
+###################################################################
+############################# General #############################
+###################################################################
+
+def _to_sequence(cols: IndexLabel) -> Iterable[Hashable]:
+    return [cols] if isinstance(cols, str) or not isinstance(cols, Iterable) else cols
+
+
+def _try_sequence(func: Callable, kwargs: Dict[str,Sequence]=dict(), persist: Dict=dict()) -> Any:
+    from itertools import product
+    args = list(map(lambda values: dict(zip(kwargs.keys(), values)),list(product(*kwargs.values()))))
+    for __m in args[:-1]:
+        try:
+            return func(**__m, **persist)
+        except:
+            pass
+    return func(**args[-1], **persist)