web-valueist 0.1.0__tar.gz

web_valueist-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andreas Galazis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

web_valueist-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.1
+Name: web-valueist
+Version: 0.1.0
+Summary: 
+Author: Andreas Galazis
+Requires-Python: >=3.13,<4.0
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
+Requires-Dist: lxml (>=5.3.0,<6.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Web Valueist
+
+Fetches a value from the web, compares it with a given value and exits with zero
+exit code if the condition is satisfied
+
+
+## Setup
+
+While in project directory:
+```
+./install.sh
+```
+
+## Usage:
+
+`web_valueist [-h] [--debug] [--json] url parser_name [quantifier] selector operator_name value`
+
+```
+positional arguments:
+  url
+  parser_name
+  quantifier      Optional: ANY or EVERY (default: ANY)
+  selector
+  operator_name
+  value
+
+options:
+  -h, --help      show this help message and exit
+  --debug         Show debug logs including found values
+  --json          Output input and result as JSON
+```
+
+## Sample Usage
+
+By default, `web_valueist` is silent and communicates success or failure via the exit code.
+
+Sample success
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer ">" 240
+```
+
+( you can also use `gt` instead of `">"`)
+
+Exit Code: `0`
+
+Sample failure
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer "<" 240
+```
+
+( you can also use `lt` instead of `"<"`)
+
+Exit Code: `1`
+
+### Debugging
+
+Use the `--debug` flag to see the values fetched from the web.
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer ">" 240 --debug
+```
+
+Output:
+
+```
+DEBUG:web_valueist.lib:Found value ['245']
+```
+
+### JSON Output
+
+Use the `--json` flag to get a structured output.
+
+```
+python -m web_valueist http://example.com str h1 "eq" "Example Domain" --json
+```
+
+Output:
+```json
+{"args": {"url": "http://example.com", "parser_name": "str", "quantifier": "ANY", "selector": "h1", "operator_name": "eq", "value": "Example Domain"}, "result": {"success": true, "value": "Example Domain"}}
+```
+
+### Using Quantifiers
+
+When a selector matches multiple elements, you can use `ANY` or `EVERY`.
+
+- **ANY** (default): At least one selector match needs to satisfy the condition.
+- **EVERY**: All selector matches need to satisfy the condition.
+
+Example using `EVERY`:
+```
+python -m web_valueist https://example.com int EVERY .price ">" 100
+```
+
+If no quantifier is specified, `ANY` is used by default.
+
+### Sample cron job
+
+```
+*/30 * * * * web_valueist "https://www.bazaraki.com/car-motorbikes-boats-and-parts/cars-trucks-and-vans/mazda/mazda-mx5/year_min---71/?ordering=cheapest&lat=35.01804869361969&lng=34.04709596563199&radius=5000&price_max=30000" int .advert__content-price._not-title   "<" 22500 &&message="Some fancy car matching your criteria was found" &&if command -v notify-send >/dev/null 2>&1 ; then notify-send "$message"; else say "$message"; fi
+```
+

web_valueist-0.1.0/README.md

@@ -0,0 +1,102 @@
+# Web Valueist
+
+Fetches a value from the web, compares it with a given value and exits with zero
+exit code if the condition is satisfied
+
+
+## Setup
+
+While in project directory:
+```
+./install.sh
+```
+
+## Usage:
+
+`web_valueist [-h] [--debug] [--json] url parser_name [quantifier] selector operator_name value`
+
+```
+positional arguments:
+  url
+  parser_name
+  quantifier      Optional: ANY or EVERY (default: ANY)
+  selector
+  operator_name
+  value
+
+options:
+  -h, --help      show this help message and exit
+  --debug         Show debug logs including found values
+  --json          Output input and result as JSON
+```
+
+## Sample Usage
+
+By default, `web_valueist` is silent and communicates success or failure via the exit code.
+
+Sample success
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer ">" 240
+```
+
+( you can also use `gt` instead of `">"`)
+
+Exit Code: `0`
+
+Sample failure
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer "<" 240
+```
+
+( you can also use `lt` instead of `"<"`)
+
+Exit Code: `1`
+
+### Debugging
+
+Use the `--debug` flag to see the values fetched from the web.
+
+```
+python -m web_valueist https://www.ikea.com.cy/en/products/fjallhavre-duvet-warm-240x220-cm/70458057/ int span.price__integer ">" 240 --debug
+```
+
+Output:
+
+```
+DEBUG:web_valueist.lib:Found value ['245']
+```
+
+### JSON Output
+
+Use the `--json` flag to get a structured output.
+
+```
+python -m web_valueist http://example.com str h1 "eq" "Example Domain" --json
+```
+
+Output:
+```json
+{"args": {"url": "http://example.com", "parser_name": "str", "quantifier": "ANY", "selector": "h1", "operator_name": "eq", "value": "Example Domain"}, "result": {"success": true, "value": "Example Domain"}}
+```
+
+### Using Quantifiers
+
+When a selector matches multiple elements, you can use `ANY` or `EVERY`.
+
+- **ANY** (default): At least one selector match needs to satisfy the condition.
+- **EVERY**: All selector matches need to satisfy the condition.
+
+Example using `EVERY`:
+```
+python -m web_valueist https://example.com int EVERY .price ">" 100
+```
+
+If no quantifier is specified, `ANY` is used by default.
+
+### Sample cron job
+
+```
+*/30 * * * * web_valueist "https://www.bazaraki.com/car-motorbikes-boats-and-parts/cars-trucks-and-vans/mazda/mazda-mx5/year_min---71/?ordering=cheapest&lat=35.01804869361969&lng=34.04709596563199&radius=5000&price_max=30000" int .advert__content-price._not-title   "<" 22500 &&message="Some fancy car matching your criteria was found" &&if command -v notify-send >/dev/null 2>&1 ; then notify-send "$message"; else say "$message"; fi
+```

web_valueist-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "web-valueist"
+version = "0.1.0"
+description = ""
+authors = ["Andreas Galazis"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.13"
+beautifulsoup4 = "^4.12.3"
+requests = "^2.32.3"
+lxml = "^5.3.0"
+
+[tool.poetry.scripts]
+web_valueist = "web_valueist.__main__:__main__"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

web_valueist-0.1.0/web_valueist/__init__.py

@@ -0,0 +1,11 @@
+from .lib import *
+
+__all__ = [
+    "evaluate",
+    "Parser",
+    "Operator",
+    "ParserNotSupportedError",
+    "OperatorNotSupportedError",
+    "ValueistException",
+    "ValueNotFound",
+]

web_valueist-0.1.0/web_valueist/__main__.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import logging
+import web_valueist
+from argparse import ArgumentParser
+from typing import TypedDict, Unpack
+from signal import signal, SIGTERM
+logger = logging.getLogger(__name__)
+
+
+class Args(TypedDict):
+    url: str
+    selector: str
+    parser_name: web_valueist.Parser
+    operator_name: web_valueist.Operator
+    value: str
+    quantifier: str
+
+
+class CliArgs(Args):
+    debug: bool
+    json: bool
+
+
+def _detect_optional_arguments(config: dict[str, dict]):
+    import sys
+
+    positional_args = [arg for arg in sys.argv[1:] if not arg.startswith("-")]
+    results = {}
+    for name, attr in config.items():
+        pos = attr["position"]
+        possible_values = attr["possible_values"]
+        # Quantifier is at position 2 if there are 6 positional arguments.
+        # If there are only 5, then it's not present.
+        results[name] = (
+            len(positional_args) == 6
+            and len(positional_args) > pos
+            and positional_args[pos].upper() in possible_values
+        )
+    return results
+
+
+def _parse_args() -> CliArgs:
+    optional_args = _detect_optional_arguments(
+        {"quantifier": {"position": 2, "possible_values": ["ANY", "EVERY"]}}
+    )
+    has_quantifier = optional_args.get("quantifier")
+
+    parser = ArgumentParser(
+        prog="web_valueist",
+        usage="web_valueist [-h] [--debug] [--json] url parser_name [quantifier] selector operator_name value",
+        description="""Fetches  the value from the web, compares 
+        it with a given value and exits with zero exit code 
+        if the condition is satisfied """,
+        epilog="Did somebody say cron jobs? Have fun!",
+    )
+
+    _ = parser.add_argument("url", help="The URL to fetch")
+    _ = parser.add_argument(
+        "parser_name", help="The name of the parser to use (e.g., int, str, bool, float)"
+    )
+
+    if has_quantifier:
+        _ = parser.add_argument(
+            "quantifier", help="Quantifier for multiple matches (ANY or EVERY)"
+        )
+
+    _ = parser.add_argument("selector", help="The CSS selector to find the value")
+    _ = parser.add_argument(
+        "operator_name",
+        help="The operator to use for comparison (e.g., gt, lt, eq, ne, !=)",
+    )
+    _ = parser.add_argument("value", help="The reference value to compare against")
+
+    _ = parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+    _ = parser.add_argument(
+        "--json", action="store_true", help="Output input and result as JSON"
+    )
+
+    args = parser.parse_args().__dict__
+
+    if not has_quantifier:
+        args["quantifier"] = "ANY"
+    else:
+        args["quantifier"] = args["quantifier"].upper()
+
+    return args
+
+
+def _initialize_logger(debug: bool, **otherArgs: Unpack[Args]) -> Args:
+    logging.basicConfig()
+    if debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+    else:
+        logging.getLogger().setLevel(logging.INFO)
+    return otherArgs
+
+
+def _initialize_cli():
+    args = _parse_args()
+    return _initialize_logger(**args)
+
+
+def sigterm_handler(_, __):
+    logger.error("termination requested, bye...\n")
+    raise SystemExit(1)
+
+
+def main():
+    import json
+    import sys
+    args=_initialize_cli()
+    json_output = args.pop("json")
+    result = web_valueist.evaluate(**args)
+    if json_output:
+        print(json.dumps({"args": args, "result": result}))
+    if result["success"]:
+        sys.exit(0)
+    sys.exit(1)
+
+
+def __main__():
+    signal(SIGTERM, sigterm_handler)
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        logger.error("ok, bye...\n")
+        exit(1)
+    except web_valueist.ValueistException as e:
+        logger.error(f"Error: {e}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    __main__()

web_valueist-0.1.0/web_valueist/lib/__init__.py

@@ -0,0 +1,75 @@
+import requests
+from bs4 import BeautifulSoup
+from . import parser, operator
+from .exception import ValueistException, ValueNotFound
+from .parser import Parser, ParserNotSupportedError
+from .operator import Operator, OperatorNotSupportedError
+import logging
+
+logger = logging.getLogger(__name__)
+
+def _fetch_values(url: str, selector: str):
+    response = requests.get(url, timeout=10)
+    if logger.isEnabledFor(logging.DEBUG):
+        # We only access response.text if we are in debug mode
+        # to avoid unnecessary decoding of the response content
+        # for large payloads.
+        logger.debug("Looking for %s in %s", selector, response.text)
+    soup = BeautifulSoup(response.content, "lxml")
+    elements=soup.css.select(selector)
+    if len(elements)<1:
+        raise ValueNotFound
+    values = [el.text for el in elements]
+    return values
+
+
+def _apply_operator(
+    parser_name: Parser,
+    current_value: str,
+    operator_name: Operator,
+    reference_value: str,
+):
+    parsed_current_value = parser.parse(parser_name, current_value)
+    parsed_reference_value = parser.parse(parser_name, reference_value)
+    return operator.apply(operator_name, parsed_current_value, parsed_reference_value)
+
+
+def evaluate(
+    url: str,
+    selector: str,
+    parser_name: Parser,
+    operator_name: Operator,
+    value: str,
+    quantifier: str = "ANY",
+):
+
+    current_values = _fetch_values(url, selector)
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug("Found value %s", current_values)
+    results = [
+        _apply_operator(parser_name, val, operator_name, value)
+        for val in current_values
+    ]
+    if quantifier == "ANY":
+        success = any(results)
+    elif quantifier == "EVERY":
+        success = all(results)
+    else:
+        # Fallback to ANY if quantifier is unknown, or we could raise an error
+        success = any(results)
+
+    return {
+        "success": success,
+        "value": current_values if len(current_values) > 1 else current_values[0],
+    }
+
+
+__all__ = [
+    "evaluate",
+    "Parser",
+    "Operator",
+    "ParserNotSupportedError",
+    "OperatorNotSupportedError",
+    "ValueistException",
+    "ValueNotFound",
+]

web_valueist-0.1.0/web_valueist/lib/exception.py

@@ -0,0 +1,7 @@
+class ValueistException(Exception):
+    pass
+
+
+class ValueNotFound(ValueistException):
+    def __init__(self, *args: object) -> None:
+        super().__init__("Value not found")

web_valueist-0.1.0/web_valueist/lib/operator.py

@@ -0,0 +1,43 @@
+from typing import Any, Literal, TypedDict
+import operator
+
+from .exception import ValueistException
+
+type Operator = Literal[
+    "gt", ">", "lt", "<", "ge", ">=", "le", "<=", "eq", "=", "ne", "!="
+]
+
+type ParsedValue = str | int | float | bool
+
+_operators = {
+    "gt": operator.gt,
+    ">": operator.gt,
+    "lt": operator.lt,
+    "<": operator.lt,
+    "ge": operator.ge,
+    ">=": operator.ge,
+    "le": operator.le,
+    "<=": operator.le,
+    "eq": operator.eq,
+    "=": operator.eq,
+    "ne": operator.ne,
+    "!=": operator.ne,
+}
+
+
+class OperatorNotSupportedError(ValueistException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(
+            f"Operator not supported. Possible operators are: {','.join(_operators.keys())}"
+        )
+
+
+def _get_operator(operator_name: str):
+    try:
+        return _operators[operator_name]
+    except KeyError as exception:
+        raise OperatorNotSupportedError from exception
+
+
+def apply(operator_name: Operator, a: ParsedValue, b: ParsedValue) -> bool:
+    return _get_operator(operator_name)(a, b)

web_valueist-0.1.0/web_valueist/lib/parser.py

@@ -0,0 +1,108 @@
+from decimal import ROUND_HALF_UP, Decimal
+import re
+from typing import Literal
+
+from .exception import ValueistException
+
+type Parser = Literal["int", "str", "bool", "float"]
+
+INT_EXPONENT=Decimal('0')
+
+def _clean_float_string(val: str):
+    """Cleans up float string and returns float
+    The cleanup regex does the following
+    1) Keeps only digits, commas, dots and leading minus sign
+    2) Removes commas or dots that do not match coma or dot and the final 1 or 2 digits
+
+
+    Args:
+        val (str): a string that is expected to be parsed as float
+
+    Returns:
+        str: The float for the provided string
+    """
+    # Keep only digits, commas, dots and leading minus
+    cleaned = re.sub(r"[^\d|.,-]", "", val)
+
+    # Ensure minus is only at the beginning
+    if cleaned.startswith("-"):
+        cleaned = "-" + cleaned[1:].replace("-", "")
+    else:
+        cleaned = cleaned.replace("-", "")
+
+    # Handle thousands separators and decimal points
+    # This regex removes dots or commas that are NOT followed by exactly 1 or 2 digits at the end of the string
+    return re.sub(r"(?![.,]\d{1,2}$)[.,]", "", cleaned).replace(",", ".")
+
+def _clean_bool_tiny_int_string(val: str):
+    """Cleans up bool/tiny int values and returns tiny int string
+
+    Args:
+        val str: a string that is expected to be parsed as bool/ tiny int
+
+    Returns:
+        str: The tiny int for the provided string 
+    """
+    return (
+        re.sub("(?i)(?!true|false|yes|no|1|0|t|f|y|n).", "", val)
+        .upper()
+        .replace("F", "0")
+        .replace("T", "1")
+        .replace("Y", "1")
+        .replace("N", "0")
+    )
+
+def _parse_int(val:str):
+    """ Cleans up int string and returns int
+    The cleanup regex does the following
+    1) Cleans up string as float
+    2) Rounds it using HALF_UP rather than banker rounding
+
+    Args:
+        val (str): a string that is expected to be parsed as integer
+
+    Returns:
+        int: The rounded integer for the provided string 
+    """
+    float_string=_clean_float_string(val)
+    return int(Decimal(float_string).quantize(exp=INT_EXPONENT, rounding=ROUND_HALF_UP))
+
+def _parse_float(val:str):
+    return float(_clean_float_string(val))
+
+def _parse_bool(val:str):
+    """Cleans up bool/tiny int string and returns bool
+
+    Args:
+        val (str): a string that is expected to be parsed as boolean
+
+    Returns:
+        bool: The boolean for the provided string
+    """    
+    tiny_int_string = _clean_bool_tiny_int_string(val)
+    return bool(int(tiny_int_string))
+
+_parsers = {
+    "int": _parse_int, 
+    "float": _parse_float, 
+    "str": str, 
+    "bool": _parse_bool
+}
+
+
+class ParserNotSupportedError(ValueistException):
+    def __init__(self, *args: object) -> None:
+        super().__init__(
+            f"Parser not supported. Possible parsers are: {','.join(_parsers.keys())}"
+        )
+
+
+def _get_parser(parser_name: str):
+    try:
+        return _parsers[parser_name]
+    except KeyError as exception:
+        raise ParserNotSupportedError from exception
+
+
+def parse(parser_name: Parser, value: str):
+    return _get_parser(parser_name)(value)