hyper-sdk 0.1.2__tar.gz → 0.3.0__tar.gz

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper_sdk
-Version: 0.1.2
+Version: 0.3.0
 Summary: Hyper Solutions Python SDK
 Project-URL: homepage, https://github.com/Hyper-Solutions/hyper-sdk-py
 Classifier: Intended Audience :: Developers
@@ -192,3 +192,99 @@ from hyper_sdk.incapsula.utmvc import get_utmvc_submit_path
 
 submit_path = get_utmvc_submit_path()
 ```
+
+## Kasada
+
+The Kasada package provides functions for interacting with Kasada Bot Manager, including parsing script path.
+
+### Generating Payload Data (CT)
+
+To generate payload data required for generating valid `x-kpsdk-ct` tokens, use the `generate_kasada_payload` function:
+
+```python
+payload, headers = hyper_session.generate_kasada_payload(hyper_sdk.KasadaPayloadInput(
+    user_agent=USER_AGENT,
+    ips_link=ips_link,
+    script=ips_script,
+    language="en-US"
+))
+# Use payload and headers for the next request
+```
+
+### Generating Pow Data (CD)
+
+To generate POW data (`x-kpsdk-cd`) tokens, use the `generate_kasada_pow` function:
+
+```python
+cd = hyper_session.generate_kasada_pow(hyper_sdk.KasadaPowInput(
+    st=st,
+    work_time=None
+))
+# Use cd as the x-kpsdk-cd header in the next request
+```
+
+### Parsing Script Path
+
+To parse the Kasada script path from the given blocked page (status code 429) HTML code, use the `parse_script_path` function:
+
+```python
+from hyper_sdk.kasada import parse_script_path
+
+script_path = parse_script_path(html_content)
+# script_path will look like: /ips.js?...
+```
+
+## DataDome
+
+The DataDome package provides functions for interacting with DataDome Bot Manager, including parsing device link URLs
+for interstitial and slider challenges.
+
+### Generating Interstitial Payload
+
+To generate payload data required for solving interstitial challenges, use the `generate_interstitial_payload` function:
+
+```python
+payload = hyper_session.generate_interstitial_payload(hyper_sdk.DataDomeInterstitialInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content
+))
+# Use the payload to POST to https://geo.captcha-delivery.com/interstitial/
+```
+
+### Generating Slider Payload
+
+To solve DataDome Slider challenges, use the `generate_slider_payload` function:
+
+```python
+payload = hyper_session.generate_slider_payload(hyper_sdk.DataDomeSliderInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content,
+    puzzle=base64_encoded_puzzle,
+    piece=base64_encoded_piece
+))
+# Create a GET request to the payload URL
+```
+
+### Parsing Interstitial DeviceLink URL
+
+To parse the Interstitial DeviceLink URL from the HTML code, use the `parse_interstitial_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_interstitial_device_check_link
+
+device_link = parse_interstitial_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/interstitial/?...
+```
+
+### Parsing Slider DeviceLink URL
+
+To parse the Slider DeviceLink URL from the HTML code, use the `parse_slider_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_slider_device_check_link
+
+device_link = parse_slider_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/captcha/?...
+```

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/README.md

@@ -172,4 +172,100 @@ To generate a unique UTMVC submit path with a random query parameter, use the `g
 from hyper_sdk.incapsula.utmvc import get_utmvc_submit_path
 
 submit_path = get_utmvc_submit_path()
+```
+
+## Kasada
+
+The Kasada package provides functions for interacting with Kasada Bot Manager, including parsing script path.
+
+### Generating Payload Data (CT)
+
+To generate payload data required for generating valid `x-kpsdk-ct` tokens, use the `generate_kasada_payload` function:
+
+```python
+payload, headers = hyper_session.generate_kasada_payload(hyper_sdk.KasadaPayloadInput(
+    user_agent=USER_AGENT,
+    ips_link=ips_link,
+    script=ips_script,
+    language="en-US"
+))
+# Use payload and headers for the next request
+```
+
+### Generating Pow Data (CD)
+
+To generate POW data (`x-kpsdk-cd`) tokens, use the `generate_kasada_pow` function:
+
+```python
+cd = hyper_session.generate_kasada_pow(hyper_sdk.KasadaPowInput(
+    st=st,
+    work_time=None
+))
+# Use cd as the x-kpsdk-cd header in the next request
+```
+
+### Parsing Script Path
+
+To parse the Kasada script path from the given blocked page (status code 429) HTML code, use the `parse_script_path` function:
+
+```python
+from hyper_sdk.kasada import parse_script_path
+
+script_path = parse_script_path(html_content)
+# script_path will look like: /ips.js?...
+```
+
+## DataDome
+
+The DataDome package provides functions for interacting with DataDome Bot Manager, including parsing device link URLs
+for interstitial and slider challenges.
+
+### Generating Interstitial Payload
+
+To generate payload data required for solving interstitial challenges, use the `generate_interstitial_payload` function:
+
+```python
+payload = hyper_session.generate_interstitial_payload(hyper_sdk.DataDomeInterstitialInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content
+))
+# Use the payload to POST to https://geo.captcha-delivery.com/interstitial/
+```
+
+### Generating Slider Payload
+
+To solve DataDome Slider challenges, use the `generate_slider_payload` function:
+
+```python
+payload = hyper_session.generate_slider_payload(hyper_sdk.DataDomeSliderInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content,
+    puzzle=base64_encoded_puzzle,
+    piece=base64_encoded_piece
+))
+# Create a GET request to the payload URL
+```
+
+### Parsing Interstitial DeviceLink URL
+
+To parse the Interstitial DeviceLink URL from the HTML code, use the `parse_interstitial_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_interstitial_device_check_link
+
+device_link = parse_interstitial_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/interstitial/?...
+```
+
+### Parsing Slider DeviceLink URL
+
+To parse the Slider DeviceLink URL from the HTML code, use the `parse_slider_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_slider_device_check_link
+
+device_link = parse_slider_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/captcha/?...
 ```

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/hyper_sdk/__init__.py

@@ -4,3 +4,5 @@ from .akamai.sec_cpt import *
 from .akamai.stop_signal import *
 from .incapsula.utmvc import *
 from .session import *
+from .kasada.parse import *
+from .datadome.parse import *

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/hyper_sdk/akamai/sec_cpt.py

@@ -9,15 +9,16 @@ from typing import List
 
 sec_duration_expr = re.compile(r'data-duration=(\d+)')
 sec_challenge_expr = re.compile(r'challenge="(.*?)"')
-sec_page_expr = re.compile(r'src="(/_sec/cp_challenge/ak-challenge-\d+-\d+.htm)"')
+sec_page_expr = re.compile(r'data-duration=\d+\s+src="([^"]+)"')
 
 
 class SecCptChallengeData:
-    def __init__(self, token: str, timestamp: int, nonce: str, difficulty: int):
+    def __init__(self, token: str, timestamp: int, nonce: str, difficulty: int, count: int):
         self.token = token
         self.timestamp = timestamp
         self.nonce = nonce
         self.difficulty = difficulty
+        self.count = count
 
 
 class SecCptChallenge:
@@ -63,7 +64,8 @@ class SecCptChallenge:
             challenge_data.get('token', ''),
             challenge_data.get('timestamp', 0),
             challenge_data.get('nonce', ''),
-            challenge_data.get('difficulty', 0)
+            challenge_data.get('difficulty', 0),
+            challenge_data.get('count', 0)
         )
 
     @staticmethod
@@ -121,7 +123,7 @@ class SecCptChallenge:
                 difficulty += 1
                 answers.append(answer)
 
-                if len(answers) == 10:
+                if len(answers) == self.challenge_data.count:
                     break
                 continue
 

hyper_sdk-0.3.0/hyper_sdk/akamai_input.py

@@ -0,0 +1,33 @@
+class SensorInput:
+    def __init__(self, abck: str, bmsz: str, version: str, page_url: str, user_agent: str, ip = "", language = "", script_hash="", dynamic_values=""):
+        self.abck = abck
+        self.bmsz = bmsz
+        self.version = version
+        self.page_url = page_url
+        self.user_agent = user_agent
+        self.script_hash = script_hash
+        self.dynamic_values = dynamic_values
+        self.ip = ip
+        self.language = language
+
+
+class PixelInput:
+    def __init__(self, user_agent: str, html_var: str, script_var: str):
+        self.user_agent = user_agent
+        self.html_var = html_var
+        self.script_var = script_var
+
+
+class DynamicInput:
+    def __init__(self, script: str):
+        self.script = script
+
+
+class SbsdInput:
+    def __init__(self, user_agent: str, uuid: str, page_url: str, o_cookie: str, language = "", ip = ""):
+        self.user_agent = user_agent
+        self.uuid = uuid
+        self.page_url = page_url
+        self.o_cookie = o_cookie
+        self.language = language
+        self.ip = ip

hyper_sdk-0.3.0/hyper_sdk/datadome/__init__.py

@@ -0,0 +1 @@
+from .parse import *

hyper_sdk-0.3.0/hyper_sdk/datadome/parse.py

@@ -0,0 +1,82 @@
+import json
+from urllib.parse import urlencode
+
+
+def parse_slider_device_check_link(src: str, datadome_cookie: str, referer: str) -> str:
+    """
+        Parse the device check URL for DataDome slider captcha from a blocked response body.
+
+        This function extracts the necessary parameters from the DataDome JavaScript object
+        embedded in the HTML source and constructs the URL for the slider captcha challenge.
+
+        Args:
+            src (str): The HTML source of the blocked page containing the DataDome JavaScript object.
+            datadome_cookie (str): The current value of the 'datadome' cookie.
+            referer (str): The referer URL to be included in the device check link.
+
+        Returns:
+            str: The constructed device check URL for the slider captcha.
+
+        Raises:
+            RuntimeError: If the dd object cannot be extracted or parsed,
+                          or if the proxy is blocked (indicated by 't' == 'bv').
+    """
+    try:
+        dd_object = src.split("var dd=")[1].split("</script>")[0]
+        dd_object = dd_object.replace("'", '"')
+        dd_object_parsed = json.loads(dd_object)
+    except Exception as _:
+        raise RuntimeError("Failed to parse dd object.")
+
+    if dd_object_parsed.get("t") == "bv":
+        raise RuntimeError("proxy blocked")
+
+    params = {
+        "initialCid": dd_object_parsed.get("cid"),
+        "hash": dd_object_parsed.get("hsh"),
+        "cid": datadome_cookie,
+        "t": dd_object_parsed.get("t"),
+        "referer": referer,
+        "s": str(dd_object_parsed.get("s")),
+        "e": dd_object_parsed.get("e"),
+        "dm": "cd",
+    }
+
+    return f"https://geo.captcha-delivery.com/captcha/?{urlencode(params)}"
+
+
+def parse_interstitial_device_check_link(src: str, datadome_cookie: str, referer: str) -> str:
+    """
+        Parse the device check URL for DataDome interstitial challenge from a blocked response body.
+
+        This function extracts the necessary parameters from the DataDome JavaScript object
+        embedded in the HTML source and constructs the URL for the interstitial challenge.
+
+        Args:
+            src (str): The HTML source of the blocked page containing the DataDome JavaScript object.
+            datadome_cookie (str): The current value of the 'datadome' cookie.
+            referer (str): The referer URL to be included in the device check link.
+
+        Returns:
+            str: The constructed device check URL for the interstitial challenge.
+
+        Raises:
+            RuntimeError: If the DataDome dd object cannot be extracted or parsed.
+    """
+    try:
+        dd_object = src.split("var dd=")[1].split("</script>")[0]
+        dd_object = dd_object.replace("'", '"')
+        dd_object_parsed = json.loads(dd_object)
+    except Exception as _:
+        raise RuntimeError("Failed to parse dd object.")
+
+    params = {
+        "initialCid": dd_object_parsed.get("cid"),
+        "hash": dd_object_parsed.get("hsh"),
+        "cid": datadome_cookie,
+        "referer": referer,
+        "s": str(dd_object_parsed.get("s")),
+        "b": str(dd_object_parsed.get("b")),
+    }
+
+    return f"https://geo.captcha-delivery.com/interstitial/?{urlencode(params)}"

hyper_sdk-0.3.0/hyper_sdk/datadome_input.py

@@ -0,0 +1,73 @@
+class DataDomeSliderInput:
+    def __init__(self, user_agent: str, device_link: str, html: str, puzzle: str, piece: str):
+        # UserAgent must be a Chrome Windows User-Agent.
+        self.user_agent = user_agent
+
+        # DeviceLink is the URL that contains the script and starts like this:
+        # https://geo.captcha-delivery.com/captcha/?initialCid
+        self.device_link = device_link
+
+        # Html is the response body of the GET request to the DeviceLink
+        self.html = html
+
+        # Puzzle is the captcha puzzle image bytes, base64 encoded.
+        # The URL that returns the puzzle looks like this:
+        # https://dd.prod.captcha-delivery.com/image/2024-xx-xx/hash.jpg
+        self.puzzle = puzzle
+
+        # Piece is the captcha puzzle piece image bytes, base64 encoded.
+        # The URL that returns the puzzle looks like this:
+        # https://dd.prod.captcha-delivery.com/image/2024-xx-xx/hash.frag.png
+        self.piece = piece
+
+    def to_dict(self):
+        return {
+            "userAgent": self.user_agent,
+            "deviceLink": self.device_link,
+            "html": self.html,
+            "puzzle": self.puzzle,
+            "piece": self.piece
+        }
+
+
+class DataDomeInterstitialInput:
+    def __init__(self, user_agent: str, device_link: str, html: str):
+        # UserAgent must be a Chrome Windows User-Agent.
+        self.user_agent = user_agent
+
+        # DeviceLink is the URL that contains the script and starts like this:
+        # https://geo.captcha-delivery.com/captcha/?initialCid
+        self.device_link = device_link
+
+        # Html is the response body of the GET request to the DeviceLink
+        self.html = html
+
+    def to_dict(self):
+        return {
+            "userAgent": self.user_agent,
+            "deviceLink": self.device_link,
+            "html": self.html
+        }
+
+
+class DataDomeTagsInput:
+    def __init__(self, user_agent: str, cid: str, ddk: str, referer: str, tags_type: str, language = "", ip = ""):
+        # UserAgent must be a Chrome Windows User-Agent.
+        self.user_agent = user_agent
+        self.cid = cid
+        self.ddk = ddk
+        self.referer = referer
+        self.tags_type = tags_type
+        self.language = language
+        self.ip = ip
+
+    def to_dict(self):
+        return {
+            "userAgent": self.user_agent,
+            "cid": self.cid,
+            "ddk": self.ddk,
+            "referer": self.referer,
+            "type": self.tags_type,
+            "language": self.language,
+            "ip": self.ip,
+        }

hyper_sdk-0.3.0/hyper_sdk/kasada/__init__.py

@@ -0,0 +1 @@
+from .parse import *

hyper_sdk-0.3.0/hyper_sdk/kasada/parse.py

@@ -0,0 +1,27 @@
+import re
+
+# Precompiled regular expression
+script_path_expr = re.compile(r'<script\s+src="([^"]+)"')
+
+
+def parse_script_path(src: str) -> str:
+    """
+        Gets the Akamai Bot Manager web SDK path from the given HTML code src.
+
+        This function searches the provided HTML source code for the path of a JavaScript script tag that matches the
+        specified regular expression pattern.
+
+        Args:
+            src (str): The HTML source code as a string.
+
+        Returns:
+            str: The path of the script extracted from the script tag.
+
+        Raises:
+            Exception: If the script path is not found in the source.
+    """
+    match = script_path_expr.search(src)
+    if match:
+        return re.sub(r'&amp;', '&', match.group(1))
+    else:
+        raise Exception("hyper-sdk: script path not found")

hyper_sdk-0.3.0/hyper_sdk/kasada_input.py

@@ -0,0 +1,37 @@
+class KasadaPowInput:
+    def __init__(self, st: int, work_time: int = None):
+        # St is the x-kpsdk-st value returned by the /tl POST request
+        self.st = st
+        # WorkTime can be used to pre-generate POW strings
+        self.work_time = work_time
+
+    def to_dict(self):
+        result = {"st": self.st}
+        if self.work_time is not None:
+            result["workTime"] = self.work_time
+        return result
+
+
+class KasadaPayloadInput:
+    def __init__(self, user_agent: str, ips_link: str, script: str, language: str = "en-US"):
+        # UserAgent must be a Chrome Windows User-Agent.
+        self.user_agent = user_agent
+
+        # IpsLink is the ips.js script link, parsed from the block page (429 status code)
+        self.ips_link = ips_link
+
+        # Script is the ips.js script retrieved using the IpsLink url
+        self.script = script
+
+        # Language is the first language of your accept-language header, it defaults to "en-US" if left empty.
+        self.language = language
+
+    def to_dict(self):
+        result = {
+            "userAgent": self.user_agent,
+            "ipsLink": self.ips_link,
+            "script": self.script
+        }
+        if self.language != "en-US":
+            result["language"] = self.language
+        return result

hyper_sdk-0.3.0/hyper_sdk/session.py

@@ -0,0 +1,265 @@
+from typing import Optional, Dict, Any
+from urllib.parse import quote
+
+import requests
+import jwt
+from datetime import datetime, timedelta, timezone
+
+from .akamai_input import SensorInput, PixelInput, DynamicInput, SbsdInput
+from .kasada_input import KasadaPowInput, KasadaPayloadInput
+from .datadome_input import DataDomeSliderInput, DataDomeInterstitialInput, DataDomeTagsInput
+from .incapsula_input import UtmvcInput
+
+
+class Session:
+    def __init__(self, api_key: str, jwt_key: Optional[str] = None, client: Optional[requests.Session] = None) -> None:
+        self.api_key = api_key
+        self.jwt_key = jwt_key
+        self.client = requests.Session() if client is None else client
+
+    def generate_sensor_data(self, input_data: SensorInput) -> str:
+        """
+            Returns the sensor data required to generate valid akamai cookies using the Hyper Solutions API.
+
+            Args:
+                input_data (SensorInput): An instance of SensorInput containing the necessary data for generating the sensor data.
+
+            Returns:
+                str: Sensor data as a string.
+        """
+        sensor_endpoint = "https://akm.justhyped.dev/sensor"
+        return self._send_request(sensor_endpoint, {
+            'userAgent': input_data.user_agent,
+            'abck': input_data.abck,
+            'bmsz': input_data.bmsz,
+            'version': input_data.version,
+            'pageUrl': input_data.page_url,
+            'scriptHash': input_data.script_hash,
+            'dynamicValues': input_data.dynamic_values,
+            'ip': input_data.ip,
+            'language': input_data.language,
+        })
+
+    def generate_sbsd_data(self, input_data: SbsdInput) -> str:
+        """
+            Returns the sbsd data required to solve SBSD using the Hyper Solutions API.
+
+            Args:
+                input_data (SbsdInput): An instance of SbsdInput containing the necessary data for generating the sbsd data.
+
+            Returns:
+                str: Sensor data as a string.
+        """
+        sensor_endpoint = "https://akm.justhyped.dev/sbsd"
+        return self._send_request(sensor_endpoint, {
+            'userAgent': input_data.user_agent,
+            'uuid': input_data.uuid,
+            'pageUrl': input_data.page_url,
+            'o': input_data.o_cookie,
+            'language': input_data.language,
+            'ip': input_data.ip,
+        })
+
+    def parse_v3_dynamic(self, input_data: DynamicInput) -> str:
+        """
+            Returns the dynamic values required to generate sensor data for V3 dynamic with Hyper Solutions API.
+
+            Args:
+                input_data (DynamicInput): An instance of DynamicInput containing the necessary data for parsing the script.
+
+            Returns:
+                str: Dynamic values as a string.
+        """
+        sensor_endpoint = "https://akm.justhyped.dev/dynamic"
+        return self._send_request(sensor_endpoint, {
+            'script': input_data.script,
+        })
+
+    def generate_pixel_data(self, input_data: PixelInput) -> str:
+        """
+            Returns the pixel data using the Hyper Solutions API.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (PixelInput): An instance of PixelInput containing the necessary data for generating the pixel data.
+
+            Returns:
+                str: Pixel data as a string.
+        """
+        pixel_endpoint = "https://akm.justhyped.dev/pixel"
+        return self._send_request(pixel_endpoint, {
+            'userAgent': input_data.user_agent,
+            'htmlVar': input_data.html_var,
+            'scriptVar': input_data.script_var,
+        })
+
+    def generate_reese84_sensor(self, site: str, user_agent: str) -> str:
+        """
+            Returns the sensor data required to generate valid reese84 cookies using the Hyper Solutions API.
+
+            This function sends a request to the specified sensor endpoint with the necessary data to generate the reese84 sensor data.
+
+            Args:
+                site (str): The name of the site that will be used to generate the sensor data.
+                user_agent (str): The user agent string used to generate the sensor data.
+
+            Returns:
+                str: Sensor data as a string.
+
+            Raises:
+                ValueError: If the script attribute in input_data is empty.
+        """
+        return self._send_request("https://incapsula.justhyped.dev/reese84/" + quote(site),
+                                  {
+                                      'userAgent': user_agent,
+                                  })
+
+    def generate_utmvc_cookie(self, input_data: UtmvcInput) -> str:
+        """
+            Returns the utmvc cookie using the Hyper Solutions API.
+
+            This function sends a request to the utmvc sensor endpoint with the necessary data to generate the utmvc cookie.
+            The input data must include a non-empty script and session IDs.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (Input): An instance of Input containing the user agent, session IDs, and script.
+
+            Returns:
+                str: The utmvc cookie as a string.
+
+            Raises:
+                ValueError: If the script attribute or session IDs in input_data are empty.
+        """
+        if not input_data.script:
+            raise ValueError("script must be non empty")
+
+        if not input_data.session_ids:
+            raise ValueError("no session ids set")
+
+        return self._send_request("https://incapsula.justhyped.dev/utmvc", {
+            'userAgent': input_data.user_agent,
+            'sessionIds': input_data.session_ids,
+            'script': input_data.script,
+        })
+
+    def generate_kasada_pow(self, input_data: KasadaPowInput) -> str:
+        """
+            Returns the x-kpsdk-cd value using the Hyper Solutions API.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (Input): An instance of Input containing the st and optionally workTime.
+
+            Returns:
+                str: The x-kpsdk-cd value as a string.
+        """
+        return self._send_request("https://kasada.justhyped.dev/cd", input_data.to_dict())
+
+    def generate_kasada_payload(self, input_data: KasadaPayloadInput) -> tuple[str, dict]:
+        """
+        Returns a base64 encoded payload and headers using the Hyper Solutions API.
+
+        Args: input_data (KasadaPayloadInput): An instance of KasadaPayloadInput containing the userAgent,
+        ipsLink and script.
+
+        Returns: tuple[str, dict]: A tuple containing the base64 encoded payload (to POST to /tl) as a string and a
+        dictionary of headers.
+        """
+        if not self.api_key:
+            raise ValueError("Missing API key")
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept-Encoding': 'gzip',
+            'X-Api-Key': self.api_key
+        }
+
+        if self.jwt_key:
+            signature = self.generate_signature()
+            headers['X-Signature'] = signature
+
+        response = self.client.post("https://kasada.justhyped.dev/payload", headers=headers, json=input_data.to_dict())
+
+        response_data = response.json()
+
+        if "error" in response_data and response_data["error"]:
+            raise Exception(f"API returned with error: {response_data['error']}")
+
+        if response.status_code != 200:
+            raise Exception(f"API returned with status code: {response.status_code}")
+
+        return response_data["payload"], response_data["headers"]
+
+    def generate_interstitial_payload(self, input_data: DataDomeInterstitialInput) -> str:
+        """
+            Returns the DataDome interstitial payload value using the Hyper Solutions API.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (DataDomeInterstitialInput): An instance of DataDomeInterstitialInput.
+
+            Returns:
+                str: The payload to post to /interstitial/
+        """
+        return self._send_request("https://datadome.justhyped.dev/interstitial", input_data.to_dict())
+
+    def generate_slider_payload(self, input_data: DataDomeSliderInput) -> str:
+        """
+            Returns the DataDome Slider URL value using the Hyper Solutions API.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (DataDomeSliderInput): An instance of DataDomeSliderInput.
+
+            Returns:
+                str: The URL to make a GET request to and returns a solved datadome cookie.
+        """
+        return self._send_request("https://datadome.justhyped.dev/slider", input_data.to_dict())
+
+    def generate_tags_payload(self, input_data: DataDomeTagsInput) -> str:
+        """
+            Returns the DataDome Tags payload using the Hyper Solutions API.
+
+            Args:
+                session (Session): An instance of Session to handle the network request.
+                input_data (DataDomeTagsInput): An instance of DataDomeTagsInput.
+
+            Returns:
+                str: The tags payload.
+        """
+        return self._send_request("https://datadome.justhyped.dev/tags", input_data.to_dict())
+
+    def generate_signature(self) -> str:
+        claims = {
+            "key": self.api_key,
+            "exp": datetime.now(timezone.utc) + timedelta(seconds=60)
+        }
+        token = jwt.encode(claims, self.jwt_key, algorithm='HS256')
+        return token.decode('utf-8')
+
+    def _send_request(self, url: str, input_data: Dict[str, Any]) -> str:
+        if not self.api_key:
+            raise ValueError("Missing API key")
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept-Encoding': 'gzip',
+            'X-Api-Key': self.api_key
+        }
+
+        if self.jwt_key:
+            signature = self.generate_signature()
+            headers['X-Signature'] = signature
+
+        response = self.client.post(url, headers=headers, json=input_data)
+
+        response_data = response.json()
+
+        if "error" in response_data and response_data["error"]:
+            raise Exception(f"API returned with error: {response_data['error']}")
+
+        if response.status_code != 200:
+            raise Exception(f"API returned with status code: {response.status_code}")
+
+        return response_data["payload"]

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/hyper_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper_sdk
-Version: 0.1.2
+Version: 0.3.0
 Summary: Hyper Solutions Python SDK
 Project-URL: homepage, https://github.com/Hyper-Solutions/hyper-sdk-py
 Classifier: Intended Audience :: Developers
@@ -192,3 +192,99 @@ from hyper_sdk.incapsula.utmvc import get_utmvc_submit_path
 
 submit_path = get_utmvc_submit_path()
 ```
+
+## Kasada
+
+The Kasada package provides functions for interacting with Kasada Bot Manager, including parsing script path.
+
+### Generating Payload Data (CT)
+
+To generate payload data required for generating valid `x-kpsdk-ct` tokens, use the `generate_kasada_payload` function:
+
+```python
+payload, headers = hyper_session.generate_kasada_payload(hyper_sdk.KasadaPayloadInput(
+    user_agent=USER_AGENT,
+    ips_link=ips_link,
+    script=ips_script,
+    language="en-US"
+))
+# Use payload and headers for the next request
+```
+
+### Generating Pow Data (CD)
+
+To generate POW data (`x-kpsdk-cd`) tokens, use the `generate_kasada_pow` function:
+
+```python
+cd = hyper_session.generate_kasada_pow(hyper_sdk.KasadaPowInput(
+    st=st,
+    work_time=None
+))
+# Use cd as the x-kpsdk-cd header in the next request
+```
+
+### Parsing Script Path
+
+To parse the Kasada script path from the given blocked page (status code 429) HTML code, use the `parse_script_path` function:
+
+```python
+from hyper_sdk.kasada import parse_script_path
+
+script_path = parse_script_path(html_content)
+# script_path will look like: /ips.js?...
+```
+
+## DataDome
+
+The DataDome package provides functions for interacting with DataDome Bot Manager, including parsing device link URLs
+for interstitial and slider challenges.
+
+### Generating Interstitial Payload
+
+To generate payload data required for solving interstitial challenges, use the `generate_interstitial_payload` function:
+
+```python
+payload = hyper_session.generate_interstitial_payload(hyper_sdk.DataDomeInterstitialInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content
+))
+# Use the payload to POST to https://geo.captcha-delivery.com/interstitial/
+```
+
+### Generating Slider Payload
+
+To solve DataDome Slider challenges, use the `generate_slider_payload` function:
+
+```python
+payload = hyper_session.generate_slider_payload(hyper_sdk.DataDomeSliderInput(
+    user_agent=USER_AGENT,
+    device_link=device_check_link,
+    html=html_content,
+    puzzle=base64_encoded_puzzle,
+    piece=base64_encoded_piece
+))
+# Create a GET request to the payload URL
+```
+
+### Parsing Interstitial DeviceLink URL
+
+To parse the Interstitial DeviceLink URL from the HTML code, use the `parse_interstitial_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_interstitial_device_check_link
+
+device_link = parse_interstitial_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/interstitial/?...
+```
+
+### Parsing Slider DeviceLink URL
+
+To parse the Slider DeviceLink URL from the HTML code, use the `parse_slider_device_check_link` function:
+
+```python
+from hyper_sdk.datadome import parse_slider_device_check_link
+
+device_link = parse_slider_device_check_link(html_content, datadome_cookie, referer)
+# device_link will look like: https://geo.captcha-delivery.com/captcha/?...
+```

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/hyper_sdk.egg-info/SOURCES.txt

@@ -3,7 +3,9 @@ README.md
 pyproject.toml
 hyper_sdk/__init__.py
 hyper_sdk/akamai_input.py
+hyper_sdk/datadome_input.py
 hyper_sdk/incapsula_input.py
+hyper_sdk/kasada_input.py
 hyper_sdk/session.py
 hyper_sdk.egg-info/PKG-INFO
 hyper_sdk.egg-info/SOURCES.txt
@@ -15,5 +17,9 @@ hyper_sdk/akamai/pixel.py
 hyper_sdk/akamai/script_path.py
 hyper_sdk/akamai/sec_cpt.py
 hyper_sdk/akamai/stop_signal.py
+hyper_sdk/datadome/__init__.py
+hyper_sdk/datadome/parse.py
 hyper_sdk/incapsula/__init__.py
-hyper_sdk/incapsula/utmvc.py
+hyper_sdk/incapsula/utmvc.py
+hyper_sdk/kasada/__init__.py
+hyper_sdk/kasada/parse.py

{hyper_sdk-0.1.2 → hyper_sdk-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyper_sdk"
-version = "0.1.2"
+version = "0.3.0"
 description = "Hyper Solutions Python SDK"
 readme = "README.md"
 requires-python = ">=3.6"
@@ -27,4 +27,4 @@ dependencies = [
 homepage = "https://github.com/Hyper-Solutions/hyper-sdk-py"
 
 [tool.setuptools]
-packages = ["hyper_sdk", "hyper_sdk.akamai", "hyper_sdk.incapsula"]
+packages = ["hyper_sdk", "hyper_sdk.akamai", "hyper_sdk.incapsula", "hyper_sdk.kasada", "hyper_sdk.datadome"]

hyper_sdk-0.1.2/hyper_sdk/akamai_input.py

@@ -1,15 +0,0 @@
-class SensorInput:
-    def __init__(self, abck: str, bmsz: str, version: str, page_url: str, user_agent: str, script_hash=""):
-        self.abck = abck
-        self.bmsz = bmsz
-        self.version = version
-        self.page_url = page_url
-        self.user_agent = user_agent
-        self.script_hash = script_hash
-
-
-class PixelInput:
-    def __init__(self, user_agent: str, html_var: str, script_var: str):
-        self.user_agent = user_agent
-        self.html_var = html_var
-        self.script_var = script_var

hyper_sdk-0.1.2/hyper_sdk/session.py

@@ -1,138 +0,0 @@
-from typing import Optional, Dict, Any
-from urllib.parse import quote
-
-import requests
-import jwt
-from datetime import datetime, timedelta, timezone
-
-from .akamai_input import SensorInput, PixelInput
-from .incapsula_input import UtmvcInput
-
-
-class Session:
-    def __init__(self, api_key: str, jwt_key: Optional[str] = None, client: Optional[requests.Session] = None) -> None:
-        self.api_key = api_key
-        self.jwt_key = jwt_key
-        self.client = requests.Session() if client is None else client
-
-    def generate_sensor_data(self, input_data: SensorInput) -> str:
-        """
-            Returns the sensor data required to generate valid akamai cookies using the Hyper Solutions API.
-
-            Args:
-                input_data (SensorInput): An instance of SensorInput containing the necessary data for generating the sensor data.
-
-            Returns:
-                str: Sensor data as a string.
-        """
-        sensor_endpoint = "https://akm.justhyped.dev/sensor"
-        return self._send_request(sensor_endpoint, {
-            'userAgent': input_data.user_agent,
-            'abck': input_data.abck,
-            'bmsz': input_data.bmsz,
-            'version': input_data.version,
-            'pageUrl': input_data.page_url,
-            'scriptHash': input_data.script_hash,
-        })
-
-    def generate_pixel_data(self, input_data: PixelInput) -> str:
-        """
-            Returns the pixel data using the Hyper Solutions API.
-
-            Args:
-                session (Session): An instance of Session to handle the network request.
-                input_data (PixelInput): An instance of PixelInput containing the necessary data for generating the pixel data.
-
-            Returns:
-                str: Pixel data as a string.
-        """
-        pixel_endpoint = "https://akm.justhyped.dev/pixel"
-        return self._send_request(pixel_endpoint, {
-            'userAgent': input_data.user_agent,
-            'htmlVar': input_data.html_var,
-            'scriptVar': input_data.script_var,
-        })
-
-    def generate_reese84_sensor(self, site: str, user_agent: str) -> str:
-        """
-            Returns the sensor data required to generate valid reese84 cookies using the Hyper Solutions API.
-
-            This function sends a request to the specified sensor endpoint with the necessary data to generate the reese84 sensor data.
-
-            Args:
-                site (str): The name of the site that will be used to generate the sensor data.
-                user_agent (str): The user agent string used to generate the sensor data.
-
-            Returns:
-                str: Sensor data as a string.
-
-            Raises:
-                ValueError: If the script attribute in input_data is empty.
-        """
-        return self._send_request("https://incapsula.justhyped.dev/reese84/" + quote(site),
-                                  {
-                                      'userAgent': user_agent,
-                                  })
-
-    def generate_utmvc_cookie(self, input_data: UtmvcInput) -> str:
-        """
-            Returns the utmvc cookie using the Hyper Solutions API.
-
-            This function sends a request to the utmvc sensor endpoint with the necessary data to generate the utmvc cookie.
-            The input data must include a non-empty script and session IDs.
-
-            Args:
-                session (Session): An instance of Session to handle the network request.
-                input_data (Input): An instance of Input containing the user agent, session IDs, and script.
-
-            Returns:
-                str: The utmvc cookie as a string.
-
-            Raises:
-                ValueError: If the script attribute or session IDs in input_data are empty.
-        """
-        if not input_data.script:
-            raise ValueError("script must be non empty")
-
-        if not input_data.session_ids:
-            raise ValueError("no session ids set")
-
-        return self._send_request("https://incapsula.justhyped.dev/utmvc", {
-            'userAgent': input_data.user_agent,
-            'sessionIds': input_data.session_ids,
-            'script': input_data.script,
-        })
-
-    def generate_signature(self) -> str:
-        claims = {
-            "key": self.api_key,
-            "exp": datetime.now(timezone.utc) + timedelta(seconds=60)
-        }
-        token = jwt.encode(claims, self.jwt_key, algorithm='HS256')
-        return token.decode('utf-8')
-
-    def _send_request(self, url: str, input_data: Dict[str, Any]) -> str:
-        if not self.api_key:
-            raise ValueError("Missing API key")
-
-        headers = {
-            'Content-Type': 'application/json',
-            'Accept-Encoding': 'gzip',
-            'X-Api-Key': self.api_key
-        }
-
-        if self.jwt_key:
-            signature = self.generate_signature()
-            headers['X-Signature'] = signature
-
-        response = self.client.post(url, headers=headers, json=input_data)
-
-        response_data = response.json()
-
-        if "error" in response_data and response_data["error"]:
-            raise Exception(f"API returned with error: {response_data['error']}")
-
-        if response.status_code != 200:
-            raise Exception(f"API returned with status code: {response.status_code}")
-
-        return response_data["payload"]