hyper-sdk 0.1.1__tar.gz → 0.2.0__tar.gz

{hyper_sdk-0.1.1 → hyper_sdk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper_sdk
-Version: 0.1.1
+Version: 0.2.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.1 → hyper_sdk-0.2.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.1 → hyper_sdk-0.2.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.1 → hyper_sdk-0.2.0}/hyper_sdk/akamai/sec_cpt.py

@@ -34,6 +34,22 @@ class SecCptChallenge:
 
         return SecCptChallenge(duration, challenge_path, challenge_data)
 
+    @staticmethod
+    def parse_from_json(json_payload: str) -> 'SecCptChallenge':
+        api_response = json.loads(json_payload)
+
+        challenge_data = SecCptChallengeData(
+            api_response.get('token', ''),
+            api_response.get('timestamp', 0),
+            api_response.get('nonce', ''),
+            api_response.get('difficulty', 0)
+        )
+
+        duration = api_response.get('chlg_duration', 0)
+        challenge_path = api_response.get('branding_url_content', '')
+
+        return SecCptChallenge(duration, challenge_path, challenge_data)
+
     @staticmethod
     def _parse_challenge_data(src: str) -> SecCptChallengeData:
         challenge_match = sec_challenge_expr.search(src)
@@ -109,4 +125,4 @@ class SecCptChallenge:
                     break
                 continue
 
-        return answers
+        return answers

hyper_sdk-0.2.0/hyper_sdk/datadome/__init__.py

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

hyper_sdk-0.2.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.2.0/hyper_sdk/datadome_input.py

@@ -0,0 +1,50 @@
+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
+        }

hyper_sdk-0.2.0/hyper_sdk/kasada/__init__.py

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

hyper_sdk-0.2.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 match.group(1)
+    else:
+        raise "hyper-sdk: script path not found"

hyper_sdk-0.2.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.1.1 → hyper_sdk-0.2.0}/hyper_sdk/session.py

@@ -6,6 +6,8 @@ import jwt
 from datetime import datetime, timedelta, timezone
 
 from .akamai_input import SensorInput, PixelInput
+from .kasada_input import KasadaPowInput, KasadaPayloadInput
+from .datadome_input import DataDomeSliderInput, DataDomeInterstitialInput
 from .incapsula_input import UtmvcInput
 
 
@@ -103,10 +105,84 @@ class Session:
             '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 (Input): An instance of Input containing the st and optionally workTime.
+
+            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 (Input): An instance of Input containing the st and optionally workTime.
+
+            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_signature(self) -> str:
         claims = {
             "key": self.api_key,
-            "exp": datetime.now(timezone.utc) + timedelta(seconds=15)
+            "exp": datetime.now(timezone.utc) + timedelta(seconds=60)
         }
         token = jwt.encode(claims, self.jwt_key, algorithm='HS256')
         return token.decode('utf-8')

{hyper_sdk-0.1.1 → hyper_sdk-0.2.0}/hyper_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hyper_sdk
-Version: 0.1.1
+Version: 0.2.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.1 → hyper_sdk-0.2.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.1 → hyper_sdk-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyper_sdk"
-version = "0.1.1"
+version = "0.2.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"]