datamarket 0.6.0__py3-none-any.whl → 0.10.3__py3-none-any.whl

datamarket/utils/strings/normalization.py

@@ -0,0 +1,217 @@
+########################################################################################################################
+# IMPORTS
+import unicodedata
+from enum import Enum, auto
+from typing import Any, Optional, Set, Union
+
+import numpy as np
+from inflection import camelize, parameterize, titleize, underscore
+from string_utils import prettify, strip_html
+from unidecode import unidecode
+
+########################################################################################################################
+# CLASSES
+
+
+class NormalizationMode(Enum):
+    NONE = auto()
+    BASIC = auto()  # removes accents and converts punctuation to spaces
+    SYMBOLS = auto()  # translates only symbols to Unicode name
+    FULL = auto()  # BASIC + SYMBOLS
+
+
+class NamingConvention(Enum):
+    NONE = auto()  # no style change
+    LOWER = auto()  # lowercase
+    UPPER = auto()  # UPPERCASE
+    CONSTANT = auto()  # CONSTANT_CASE (uppercase, underscores)
+    SNAKE = auto()  # snake_case (lowercase, underscores)
+    CAMEL = auto()  # camelCase (capitalize words except first one, no spaces)
+    PASCAL = auto()  # PascalCase (capitalize words including first one, no spaces)
+    PARAM = auto()  # parameterize (hyphens)
+    TITLE = auto()  # titleize (capitalize words)
+
+
+########################################################################################################################
+# FUNCTIONS
+
+
+def get_unidecoded_text(input_text: str, allowed_chars: Set[str], apply_lowercase: bool = False) -> str:
+    """
+    Processes a string by unidecoding characters, optionally lowercasing them,
+    while preserving a specified set of allowed characters.
+
+    Args:
+        input_text: The string to process.
+        allowed_chars: A set of characters to preserve in their original form.
+        apply_lowercase: Whether to convert unidecoded characters to lowercase. Defaults to False.
+
+    Returns:
+        The processed string.
+    """
+    chars_list: list[str] = []
+    for char_original in input_text:
+        if char_original in allowed_chars:
+            chars_list.append(char_original)
+        else:
+            decoded_segment = unidecode(char_original)
+            for dc in decoded_segment:  # unidecode can return multiple chars
+                if apply_lowercase:
+                    chars_list.append(dc.lower())
+                else:
+                    chars_list.append(dc)
+    return "".join(chars_list)
+
+
+def transliterate_symbols(s: str, allowed_symbols_set: Optional[Set[str]] = None) -> str:
+    """
+    Translates Unicode symbols (category S*) in the input string to their lowercase Unicode names,
+    with spaces replaced by underscores. Other characters, or characters in allowed_symbols_set, remain unchanged.
+
+    Args:
+        s: The input string.
+        allowed_symbols_set: A set of characters to preserve without transliteration.
+
+    Returns:
+        The string with symbols transliterated or preserved.
+    """
+    if allowed_symbols_set is None:
+        allowed_symbols_set = set()
+    out: list[str] = []
+    for c in s:
+        if c in allowed_symbols_set:
+            out.append(c)
+        elif unicodedata.category(c).startswith("S"):
+            name = unicodedata.name(c, "")
+            if name:
+                out.append(name.lower().replace(" ", "_"))
+        else:
+            out.append(c)
+    return "".join(out)
+
+
+def normalize(
+    s: Any,
+    mode: Union[NormalizationMode, str] = NormalizationMode.BASIC,
+    naming: Union[NamingConvention, str] = NamingConvention.LOWER,
+    allowed_symbols: Optional[str] = None,
+) -> str:
+    """
+    Normalizes and applies a naming convention to the input.
+
+    Handles None and NaN values by returning an empty string. Converts non-string inputs to strings.
+
+    Normalization (controlled by `mode`) occurs first, followed by naming convention application.
+    - NONE: Returns the input as a string without any normalization. Case is preserved.
+    - BASIC: Removes accents (via unidecode). Punctuation and spaces typically become single spaces between tokens.
+             Case is preserved from the unidecode step by default.
+    - SYMBOLS: Translates only Unicode symbols (category S*) to their lowercase Unicode names with underscores.
+               Other characters are preserved, including their case.
+    - FULL: Applies unidecode (case-preserved by default) and then SYMBOLS-like transliteration for S* category
+            characters not otherwise handled.
+
+    The `allowed_symbols` parameter can be used to specify characters that should be preserved in their original form
+    throughout the normalization process. These characters will not be unidecoded or transliterated by the symbol logic.
+
+    After normalization, a naming convention (controlled by `naming`) is applied:
+    - NONE: Returns the normalized text, preserving its case from the normalization step.
+    - LOWER: Converts the normalized text to lowercase. (Default)
+    - UPPER: Converts the normalized text to UPPERCASE.
+    - CONSTANT: Converts to CONSTANT_CASE (uppercase with underscores).
+    - SNAKE: Converts to snake_case (lowercase with underscores).
+    - CAMEL: Converts to camelCase (lowercase first word, capitalize subsequent words, no spaces).
+    - PASCAL: Converts to PascalCase (capitalize all words, no spaces).
+    - PARAM: Converts to parameterize (lowercase with hyphens).
+    - TITLE: Converts to Title Case (capitalize each word).
+
+    Args:
+        s: The input value to normalize and format. Can be any type.
+        mode: The normalization mode to apply. Defaults to NormalizationMode.BASIC.
+        naming: The naming convention to apply. Defaults to NamingConvention.LOWER.
+        allowed_symbols: A string of characters to preserve during normalization.
+
+    Returns:
+        The normalized and formatted string.
+    """
+    # Parameter mapping
+    if isinstance(mode, str):
+        mode = NormalizationMode[mode.upper()]
+    if not isinstance(mode, NormalizationMode):
+        raise TypeError("mode must be NormalizationMode or str")
+
+    if isinstance(naming, str):
+        naming = NamingConvention[naming.upper()]
+    if not isinstance(naming, NamingConvention):
+        raise TypeError("naming must be NamingConvention or str")
+
+    _allowed_symbols_set: Set[str] = set(allowed_symbols) if allowed_symbols else set()
+
+    # Handling null values
+    if s is None or (isinstance(s, float) and np.isnan(s)):
+        normalized = ""
+    elif not isinstance(s, str):
+        return str(s)
+    else:
+        raw_text = str(s)
+        if naming is NamingConvention.NONE:
+            text = raw_text
+        else:
+            text = prettify(strip_html(raw_text, True))
+
+        if mode is NormalizationMode.NONE:
+            normalized = text
+        elif mode is NormalizationMode.SYMBOLS:
+            normalized = transliterate_symbols(text, _allowed_symbols_set)
+        else:
+            # BASIC and FULL modes
+            intermediate_text = get_unidecoded_text(text, _allowed_symbols_set)
+
+            # Now, tokenize the intermediate_text for BASIC and FULL
+            tokens: list[str] = []
+            current_token_chars: list[str] = []
+
+            def flush_current_token():
+                nonlocal current_token_chars
+                if current_token_chars:
+                    tokens.append("".join(current_token_chars))
+                    current_token_chars.clear()
+
+            for c in intermediate_text:
+                cat = unicodedata.category(c)
+                if c in _allowed_symbols_set or c.isalnum():  # Allowed symbols are part of tokens
+                    current_token_chars.append(c)
+                elif mode is NormalizationMode.FULL and cat.startswith("S"):
+                    # Transliterate S* category symbols not in allowed_symbols
+                    flush_current_token()
+                    name = unicodedata.name(c, "")
+                    if name:
+                        tokens.append(name.lower().replace(" ", "_"))
+                elif cat.startswith("P") or c.isspace():
+                    # Punctuation (not allowed) or space acts as a separator
+                    flush_current_token()
+                # Other characters are ignored
+
+            flush_current_token()
+            normalized = " ".join(tokens)
+
+    # Apply naming convention
+    if naming is NamingConvention.NONE:
+        return normalized
+    if naming is NamingConvention.LOWER:
+        return normalized.lower()
+    if naming is NamingConvention.UPPER:
+        return normalized.upper()
+    if naming is NamingConvention.PARAM:
+        return parameterize(normalized)
+    if naming is NamingConvention.TITLE:
+        return titleize(normalized)
+
+    underscored = underscore(parameterize(normalized))
+    if naming is NamingConvention.CONSTANT:
+        return underscored.upper()
+    if naming is NamingConvention.CAMEL:
+        return camelize(underscored, False)
+    if naming is NamingConvention.PASCAL:
+        return camelize(underscored)
+
+    return underscored

datamarket/utils/strings/obfuscation.py

@@ -0,0 +1,153 @@
+########################################################################################################################
+# IMPORTS
+
+import logging
+import warnings
+from typing import List, Optional
+
+
+class PiiDependenciesMissingError(ImportError):
+    pass
+
+
+class SpacyModelNotFoundError(ImportError):
+    pass
+
+
+try:
+    import phonenumbers  # type: ignore
+    import spacy  # type: ignore
+    from presidio_analyzer import AnalyzerEngine, RecognizerRegistry  # type: ignore
+    from presidio_analyzer.nlp_engine import NlpEngineProvider  # type: ignore
+    from presidio_analyzer.predefined_recognizers import PhoneRecognizer  # type: ignore
+    from presidio_anonymizer import AnonymizerEngine  # type: ignore
+    from spacy.language import Language  # type: ignore
+    from spacy_langdetect import LanguageDetector  # type: ignore
+except ImportError as e:
+    raise PiiDependenciesMissingError(
+        "One or more PII anonymization dependencies are missing. "
+        "Please install them by running: pip install datamarket[pii]\n"
+        f"Original error: {e}"
+    ) from e
+
+
+########################################################################################################################
+# SETTINGS
+
+logger = logging.getLogger()
+logging.getLogger("presidio-analyzer").setLevel(logging.ERROR)
+
+warnings.filterwarnings(
+    "ignore",
+    message=r"\[W108\]",
+    category=UserWarning,
+    module="spacy.pipeline.lemmatizer",
+)
+
+
+@Language.factory("language_detector")
+def get_lang_detector(nlp, name):
+    return LanguageDetector()
+
+
+########################################################################################################################
+# CLASSES
+
+
+class PiiAnonymizer:
+    SUPPORTED_LANG = ["es", "en"]
+
+    def __init__(self):
+        # Check for required spaCy models
+        required_models = {
+            "es_core_news_md": "python -m spacy download es_core_news_md",
+            "en_core_web_md": "python -m spacy download en_core_web_md",
+        }
+        missing_models_instructions = []
+        for model_name, install_command in required_models.items():
+            if not spacy.util.is_package(model_name):
+                missing_models_instructions.append(
+                    f"Model '{model_name}' not found. Please install it by running: {install_command}"
+                )
+
+        if missing_models_instructions:
+            raise SpacyModelNotFoundError("\n".join(missing_models_instructions))
+
+        self.anonymizer = AnonymizerEngine()
+        self.analyzer = self._load_analyzer_engine()
+
+        self.nlp = self._nlp()
+
+    def _nlp(self) -> Language:
+        analyzer_en_model = self.analyzer.nlp_engine.nlp.get("en")
+        shared_vocab = analyzer_en_model.vocab
+        nlp = spacy.blank("en", vocab=shared_vocab)
+
+        if nlp.has_factory("sentencizer"):
+            nlp.add_pipe("sentencizer")
+
+        if nlp.has_factory("language_detector"):
+            nlp.add_pipe("language_detector", last=True)
+
+        return nlp
+
+    @staticmethod
+    def _nlp_config():
+        return {
+            "nlp_engine_name": "spacy",
+            "models": [
+                {"lang_code": "es", "model_name": "es_core_news_md"},
+                {"lang_code": "en", "model_name": "en_core_web_md"},
+            ],
+        }
+
+    def _load_analyzer_engine(self) -> AnalyzerEngine:
+        provider = NlpEngineProvider(nlp_configuration=PiiAnonymizer._nlp_config())
+        nlp_engine = provider.create_engine()
+        phone_recognizer_es = PhoneRecognizer(
+            supported_language="es",
+            supported_regions=phonenumbers.SUPPORTED_REGIONS,
+            context=["teléfono", "móvil", "número"],
+        )
+        registry = RecognizerRegistry(supported_languages=self.SUPPORTED_LANG)
+        registry.load_predefined_recognizers(nlp_engine=nlp_engine, languages=self.SUPPORTED_LANG)
+        registry.add_recognizer(phone_recognizer_es)
+
+        analyzer = AnalyzerEngine(
+            registry=registry,
+            nlp_engine=nlp_engine,
+            supported_languages=self.SUPPORTED_LANG,
+        )
+        return analyzer
+
+    def detect_lang(self, text: str) -> str:
+        if hasattr(self, "nlp") and self.nlp:
+            with self.nlp.select_pipes(enable=["tokenizer", "sentencizer", "language_detector"]):
+                doc = self.nlp(text)
+            return doc._.language["language"]
+        else:
+            logger.error("Language detection NLP model not initialized. Cannot detect language.")
+            return "unknown"
+
+    def anonymize_text(
+        self,
+        text: str,
+        entities: Optional[List[str]] = None,
+        lang: str = "unknown",
+    ) -> str:
+        if lang == "unknown":
+            lang = self.detect_lang(text)
+            if lang not in self.SUPPORTED_LANG:
+                logger.warning(f"Support for language {lang} is not implemented yet! Fail safe to empty string.")
+                return ""
+        elif lang not in self.SUPPORTED_LANG:
+            logger.warning(f"Support for language {lang} is not implemented yet! Fail safe to empty string.")
+            return ""
+
+        analyzer_result = self.analyzer.analyze(
+            text=text,
+            entities=entities,
+            language=lang,
+        )
+        anonymizer_result = self.anonymizer.anonymize(text=text, analyzer_results=analyzer_result)
+        return anonymizer_result.text

datamarket/utils/strings/standardization.py

@@ -0,0 +1,40 @@
+########################################################################################################################
+# IMPORTS
+
+import re
+from typing import Literal
+
+from ...params.nominatim import COUNTRY_PARSING_RULES
+
+########################################################################################################################
+# FUNCTIONS
+
+
+def parse_phone_number(number: str, country_code: Literal["es", "pt"]) -> str | None:
+    """Clean and standardize phone number from a certain country_code
+
+    Args:
+        number (str): phone number
+        country_code (Literal["es", "pt"]): country code of the phone number to parse
+
+    Raises:
+        ValueError: when parsing is not supported for a certain country
+
+    Returns:
+        str | None: standardized phone number
+    """
+    clean_number = re.sub(r"\D", "", number)
+    if country_code in {"es", "pt"}:
+        # Get the validation regex from params
+        pattern = COUNTRY_PARSING_RULES[country_code]["phone_validate_pattern"]
+
+        # Validate and extract in one step
+        if len(clean_number) >= 9:  # Check if the cleaned number has at least 9 digits
+            match = pattern.match(clean_number)
+
+            # Return the captured group (the 9-digit number)
+            return match.group(0)[-9:] if match else None
+        else:
+            return None  # Or handle the case where the number is too short
+    else:
+        raise ValueError(f"Country code ({country_code}) is not currently supported")

datamarket/utils/typer.py

@@ -9,6 +9,7 @@ from typing_extensions import Annotated
 ########################################################################################################################
 # TYPES
 
+
 class Dict(dict):
     def __init__(self, value: str):
         super().__init__(json.loads(value))
@@ -25,4 +26,4 @@ def parse_json_dict(value: str) -> Dict:
 
 
 DictArg = Annotated[Dict, typer.Argument(parser=parse_json_dict)]
-DictOpt = Annotated[Dict, typer.Option(parser=parse_json_dict)]
+DictOpt = Annotated[Dict, typer.Option(parser=parse_json_dict)]

datamarket/utils/types.py

@@ -0,0 +1 @@
+Json = str | int | float | bool | None | dict[str, "Json"] | list["Json"]

datamarket-0.10.3.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: datamarket
+Version: 0.10.3
+Summary: Utilities that integrate advanced scraping knowledge into just one library.
+License: GPL-3.0-or-later
+License-File: LICENSE
+Author: DataMarket
+Author-email: techsupport@datamarket.es
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: aws
+Provides-Extra: azure-storage-blob
+Provides-Extra: boto3
+Provides-Extra: camoufox
+Provides-Extra: chompjs
+Provides-Extra: click
+Provides-Extra: clickhouse-driver
+Provides-Extra: datetime
+Provides-Extra: ddgs
+Provides-Extra: demjson3
+Provides-Extra: dnspython
+Provides-Extra: drive
+Provides-Extra: fake-useragent
+Provides-Extra: geoalchemy2
+Provides-Extra: geopandas
+Provides-Extra: google-api-python-client
+Provides-Extra: google-auth-httplib2
+Provides-Extra: google-auth-oauthlib
+Provides-Extra: html2text
+Provides-Extra: httpx
+Provides-Extra: json5
+Provides-Extra: llm
+Provides-Extra: lxml
+Provides-Extra: matplotlib
+Provides-Extra: nodriver
+Provides-Extra: openai
+Provides-Extra: openpyxl
+Provides-Extra: pandarallel
+Provides-Extra: pandas
+Provides-Extra: pandera
+Provides-Extra: peerdb
+Provides-Extra: pii
+Provides-Extra: pillow
+Provides-Extra: playwright
+Provides-Extra: playwright-stealth
+Provides-Extra: plotly
+Provides-Extra: pyarrow
+Provides-Extra: pydantic
+Provides-Extra: pydrive2
+Provides-Extra: pymupdf
+Provides-Extra: pyproj
+Provides-Extra: pyrate-limiter
+Provides-Extra: pysocks
+Provides-Extra: pyspark
+Provides-Extra: pytest
+Provides-Extra: retry
+Provides-Extra: shapely
+Provides-Extra: soda-core-mysql
+Provides-Extra: soda-core-postgres
+Provides-Extra: sqlparse
+Provides-Extra: tqdm
+Provides-Extra: undetected-chromedriver
+Provides-Extra: xmltodict
+Requires-Dist: SQLAlchemy (>=2.0.0,<3.0.0)
+Requires-Dist: azure-storage-blob (>=12.0.0,<13.0.0) ; extra == "azure-storage-blob"
+Requires-Dist: babel (>=2.0.0,<3.0.0)
+Requires-Dist: beautifulsoup4 (>=4.0.0,<5.0.0)
+Requires-Dist: boto3 (>=1.35.0,<1.36.0) ; extra == "boto3" or extra == "aws" or extra == "peerdb"
+Requires-Dist: browserforge (>=1.2.0,<2.0.0) ; extra == "camoufox"
+Requires-Dist: camoufox[geoip] (>=0.4.11,<0.5.0) ; extra == "camoufox"
+Requires-Dist: chompjs (>=1.0.0,<2.0.0) ; extra == "chompjs"
+Requires-Dist: click (>=8.0.0,<9.0.0) ; extra == "click"
+Requires-Dist: clickhouse-driver (>=0.2.0,<0.3.0) ; extra == "clickhouse-driver" or extra == "peerdb"
+Requires-Dist: croniter (>=3.0.0,<4.0.0)
+Requires-Dist: datetime (>=5.0,<6.0) ; extra == "datetime"
+Requires-Dist: ddgs (>=9.0.0,<10.0.0) ; extra == "ddgs"
+Requires-Dist: demjson3 (>=3.0.0,<4.0.0) ; extra == "demjson3"
+Requires-Dist: dnspython (>=2.0.0,<3.0.0) ; extra == "dnspython"
+Requires-Dist: dynaconf (>=3.0.0,<4.0.0)
+Requires-Dist: fake-useragent (>=2.0.0,<3.0.0) ; extra == "fake-useragent"
+Requires-Dist: geoalchemy2 (>=0.17.0,<0.18.0) ; extra == "geoalchemy2"
+Requires-Dist: geopandas (>=1.0.0,<2.0.0) ; extra == "geopandas"
+Requires-Dist: geopy (>=2.0.0,<3.0.0)
+Requires-Dist: google-api-python-client (>=2.0.0,<3.0.0) ; extra == "google-api-python-client"
+Requires-Dist: google-auth-httplib2 (>=0.2.0,<0.3.0) ; extra == "google-auth-httplib2"
+Requires-Dist: google-auth-oauthlib (>=1.0.0,<2.0.0) ; extra == "google-auth-oauthlib"
+Requires-Dist: html2text (>=2024.0.0,<2025.0.0) ; extra == "html2text"
+Requires-Dist: httpx[http2] (>=0.28.0,<0.29.0) ; extra == "httpx"
+Requires-Dist: inflection (>=0.5.0,<0.6.0)
+Requires-Dist: jellyfish (>=1.0.0,<2.0.0)
+Requires-Dist: jinja2 (>=3.0.0,<4.0.0)
+Requires-Dist: json5 (>=0.10.0,<0.11.0) ; extra == "json5"
+Requires-Dist: lxml[html-clean] (>=5.0.0,<6.0.0) ; extra == "lxml"
+Requires-Dist: matplotlib (>=3.0.0,<4.0.0) ; extra == "matplotlib"
+Requires-Dist: nodriver (>=0.44,<0.45) ; extra == "nodriver"
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: openai (>=2.0.0,<3.0.0) ; extra == "openai" or extra == "llm"
+Requires-Dist: openpyxl (>=3.0.0,<4.0.0) ; extra == "openpyxl"
+Requires-Dist: pandarallel (>=1.0.0,<2.0.0) ; extra == "pandarallel"
+Requires-Dist: pandas (>=2.0.0,<3.0.0) ; extra == "pandas"
+Requires-Dist: pandera (>=0.22.0,<0.23.0) ; extra == "pandera"
+Requires-Dist: pendulum (>=3.0.0,<4.0.0)
+Requires-Dist: pillow (>=11.0.0,<12.0.0) ; extra == "pillow"
+Requires-Dist: playwright (==1.47.0) ; extra == "playwright" or extra == "camoufox"
+Requires-Dist: plotly (>=6.0.0,<7.0.0) ; extra == "plotly"
+Requires-Dist: pre-commit (>=4.0.0,<5.0.0)
+Requires-Dist: presidio-analyzer[phonenumbers] (>=2.0.0,<3.0.0) ; extra == "pii"
+Requires-Dist: presidio-anonymizer (>=2.0.0,<3.0.0) ; extra == "pii"
+Requires-Dist: psycopg2-binary (>=2.0.0,<3.0.0)
+Requires-Dist: pyarrow (>=19.0.0,<20.0.0) ; extra == "pyarrow"
+Requires-Dist: pycountry (>=24.0.0,<25.0.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0) ; extra == "pydantic" or extra == "llm"
+Requires-Dist: pydrive2 (>=1.0.0,<2.0.0) ; extra == "pydrive2" or extra == "drive"
+Requires-Dist: pymupdf (>=1.0.0,<2.0.0) ; extra == "pymupdf"
+Requires-Dist: pyproj (>=3.0.0,<4.0.0) ; extra == "pyproj"
+Requires-Dist: pyrate-limiter (>=3.0.0,<4.0.0) ; extra == "pyrate-limiter"
+Requires-Dist: pysocks (>=1.0.0,<2.0.0) ; extra == "pysocks"
+Requires-Dist: pyspark (>=3.0.0,<4.0.0) ; extra == "pyspark"
+Requires-Dist: pytest (>=8.0.0,<9.0.0) ; extra == "pytest"
+Requires-Dist: python-string-utils (>=1.0.0,<2.0.0)
+Requires-Dist: rapidfuzz (>=3.0.0,<4.0.0)
+Requires-Dist: requests (>=2.0.0,<3.0.0)
+Requires-Dist: retry (>=0.9.0,<0.10.0) ; extra == "retry"
+Requires-Dist: rnet (>=3.0.0rc10,<4.0.0)
+Requires-Dist: shapely (>=2.0.0,<3.0.0) ; extra == "shapely"
+Requires-Dist: soda-core-mysql-utf8-hotfix (>=3.0.0,<4.0.0) ; extra == "soda-core-mysql"
+Requires-Dist: soda-core-postgres (>=3.0.0,<4.0.0) ; extra == "soda-core-postgres"
+Requires-Dist: spacy (>=3.0.0,<4.0.0) ; extra == "pii"
+Requires-Dist: spacy-langdetect (>=0.1.0,<0.2.0) ; extra == "pii"
+Requires-Dist: sqlparse (>=0.5.0,<0.6.0) ; extra == "sqlparse"
+Requires-Dist: stem (>=1.0.0,<2.0.0)
+Requires-Dist: tenacity (>=9.0.0,<10.0.0)
+Requires-Dist: tqdm (>=4.0.0,<5.0.0) ; extra == "tqdm"
+Requires-Dist: typer (>=0.15.0,<0.16.0)
+Requires-Dist: unidecode (>=1.0.0,<2.0.0)
+Requires-Dist: xmltodict (>=0.14.0,<0.15.0) ; extra == "xmltodict"
+Project-URL: Documentation, https://github.com/Data-Market/datamarket
+Project-URL: Homepage, https://datamarket.es
+Project-URL: Repository, https://github.com/Data-Market/datamarket
+Description-Content-Type: text/markdown
+
+# DataMarket scraping core
+
+------------------------------------------------------
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+
+Utilities that integrate advance scraping knowledge into just one library.
+
+## Installation
+
+To install this library in your Python environment:
+
+`pip install datamarket`
+
+## Documentation
+
+This library has built functionalities for the following topics:
+
+- **Databases**: through sqlalchemy it allows to insert records and perform queries in any database.
+- **Proxies**: wide range of functions to perform HTTP requests through custom proxies or the Tor network.
+- **Tinybird**: a Python client for this popular API.
+- **Drive**: functions to upload, delete or authenticate to Google Drive.
+- **FTP**: functions to upload, delete or authenticate to an FTP, SFTP or FTPS server.
+- **Selenium**: wrapper for the main Selenium functions.
+

datamarket-0.10.3.dist-info/RECORD

@@ -0,0 +1,38 @@
+datamarket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamarket/exceptions/__init__.py,sha256=FHLh-Qp9XpM4LkAocppCf_llW2CWVVghGorkqxqt1wk,34
+datamarket/exceptions/main.py,sha256=S5EksLt_pmmX5OY-_keB12K3r5R-lTBnqdJ9VBPy8D8,3674
+datamarket/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamarket/interfaces/alchemy.py,sha256=KoZrXnfYAT9Gv9voKRlOgXVML5PdMqJr2sJbHSnWpvY,76516
+datamarket/interfaces/aws.py,sha256=4HEN_VfQuEEvDnksRYlcMBUdKbgJXWBkLnymKpyRtrs,4781
+datamarket/interfaces/azure.py,sha256=0pqd6LmQzRGjOUu85YKlPeQnlwsq0q5laNUw_iI3XPw,5180
+datamarket/interfaces/drive.py,sha256=3nhx3THr2SHNWKYwme9F2nPpvsqyEMFIxz0whF2FjHk,4840
+datamarket/interfaces/ftp.py,sha256=LH3Oz19k_xUNhzDXcrq5Ofb4c3uiph5pWUqpgiaDvHI,2671
+datamarket/interfaces/llm.py,sha256=rRD_Rghm8uSDNLpflwTxGVkzQAH2Or-FTXOcJHSstFg,43829
+datamarket/interfaces/nominatim.py,sha256=57hlW0w6XHBWEmyLyMn6eq1o_T5caYcLNBSNI1qLWCQ,16145
+datamarket/interfaces/peerdb.py,sha256=sO451wEGNb_0DDwchZ6eBVYKltqHM5XKau-WsfspXzA,23640
+datamarket/interfaces/proxy.py,sha256=fke9THv2h1jpr5cxJ25w0bYchuboErokQlSiq50FWVE,14632
+datamarket/interfaces/tinybird.py,sha256=cNG-kAPTdQn2inlNX9LPf-VVdtnLud947ApLVO40Now,2594
+datamarket/params/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamarket/params/nominatim.py,sha256=yWOBZ0CQ7YfsBbhpbOZZEgFQTTc6vATPOPDQ7EmWGBk,14648
+datamarket/utils/__init__.py,sha256=FHLh-Qp9XpM4LkAocppCf_llW2CWVVghGorkqxqt1wk,34
+datamarket/utils/airflow.py,sha256=Tc8vFB85NGJn0vgEkvT_yGMbn_NmW0OAJa9fy1qKocQ,804
+datamarket/utils/alchemy.py,sha256=B-6cdMiEStzD4JKhi7Xpk7pVs7eUcdT_fHqpfm2ToNc,637
+datamarket/utils/logs.py,sha256=EX7rI7c-QmQbTTDutyxeCbprUilzV58pypZUwA_vPK0,2543
+datamarket/utils/main.py,sha256=MDCR-EWKgWMXo2XmLR_K7YEp26vSTcuwuijzNcMt5EQ,7271
+datamarket/utils/nominatim.py,sha256=HUJfR86lw68PzaLfhZOCIT5YlopDvRSbwEY2JCf0WyI,5704
+datamarket/utils/playwright/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamarket/utils/playwright/async_api.py,sha256=Wl2LFHiOTZDg4Jic5nJDPSk1g_AWsY04XKvs3m_ZTrQ,10838
+datamarket/utils/playwright/sync_api.py,sha256=JrVZkphQfCxOtl0oxQZd3W0LALdT7qVV6kwph7FfA94,10729
+datamarket/utils/requests.py,sha256=YJ97ziTe6z8lq3Wu0_ivNbYWWXkyjaaB_pnUShWhFRU,24368
+datamarket/utils/selenium.py,sha256=Fc2BJzTH7_xIqjBP9LbZODF69RSH4fF8LhD5WuGdlZ0,2457
+datamarket/utils/soda.py,sha256=eZTXFbI1P3WoMd1MM-YjoVTpdjTcDSWuvBb7ViBMhSQ,941
+datamarket/utils/strings/__init__.py,sha256=b6TYOT9v7y9ID-lDyZk4E8BH2uIPbsF2ZSLGjCQ1MCQ,43
+datamarket/utils/strings/normalization.py,sha256=tlZHq8h9AtcANkaJ2AOrR6UD5yKShn1cLldfFfFQgTA,8990
+datamarket/utils/strings/obfuscation.py,sha256=lQL1TiDMpY1veYGKHqYgsHFgFJhuD9GLcJ1uwglOMy8,5374
+datamarket/utils/strings/standardization.py,sha256=j_NbT-O1XnxDvDhct8panfkrfAC8R5OX6XM5fYBZ4RU,1496
+datamarket/utils/typer.py,sha256=geWuwMwGQjBQhxo27hX0vEAeRl1j1TS0u2oFVfpAs5I,816
+datamarket/utils/types.py,sha256=vxdQZdwdXrfPR4Es52gBgol-tMRIOD6oK9cBo3rB0JQ,74
+datamarket-0.10.3.dist-info/METADATA,sha256=dhTFRAUsUG2EhIBbujgSk81cWbmegxEAZRSplayQd4M,7695
+datamarket-0.10.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+datamarket-0.10.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+datamarket-0.10.3.dist-info/RECORD,,

{datamarket-0.6.0.dist-info → datamarket-0.10.3.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any
-