Support for timeout, retry and proxy from the dsl

* retry, timeout and proxy support

* more processing tests before request sent

* Dependency updates

  ✅ #417 - idna 3.10 → 3.15
  ✅ #416 - faker 37.12.0 → 40.18.0
  ✅ #415 - jsonschema 4.25.1 → 4.26.0
  ✅ #414 - pytest 8.4.2 → 9.0.3
  ✅ #413 - requests-aws4auth 1.3.1 → 1.3.2
  ✅ #408 - python 3.13-slim → 3.14-slim
  ✅ #401 - urllib3 2.2.3 → 2.7.0

* Update Python version to 3.14 in CI workflow
Examples added:
- Simple GraphQL query
- Query with variables
- Mutation example

Author: cedric05

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Install Python 3
         uses: actions/setup-python@v5
         with:
-          python-version: 3.11
+          python-version: 3.14
       - uses: Gr1N/setup-poetry@v8
       - name: Install dependencies
         run: |
@@ -52,4 +52,4 @@ jobs:
       #     alert-threshold: '150%'
       #     fail-on-alert: true
       #     github-token: ${{ secrets.PERSONAL_GITHUB_TOKEN }}
-      #     comment-on-alert: true
+      #     comment-on-alert: true

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.13
+FROM python:3.14-slim
 LABEL io.whalebrew.config.networks '["host"]'
 ADD pyproject.toml /app/
 WORKDIR /app

Dockerfile.test

@@ -1,4 +1,4 @@
-FROM python:3.13-slim
+FROM python:3.14-slim
 
 # Install system dependencies including build tools for compiling Python packages
 RUN apt-get update && apt-get install -y --no-install-recommends \

dothttp/http.tx

@@ -29,6 +29,9 @@ HTTP:
         urlwrap=URL
         (authwrap=AUTHWRAP)?
         (certificate = CERTAUTH)?
+        (timeout=TIMEOUT)?
+        (retry=RETRY)?
+        (proxy=PROXY)?
         (lines *= LINE)?
         (payload=PAYLOAD)?
         (output=TOFILE)?
@@ -133,6 +136,23 @@ AZURECLIAUTH:
     'azurecli' '(' (('scope' '=')?  scope=DotString )?  ')'
 ;
 
+TIMEOUT:
+    'timeout' '(' timeout_seconds=DotString ')'
+;
+
+RETRY:
+    'retry' '(' retry_params*=RETRY_PARAM[','] ','? ')'
+;
+
+RETRY_PARAM:
+      ('total' '=' total=DotString)
+    | ('status_forcelist' '=' '[' status_forcelist*=DotString[','] ','? ']')
+    | ('backoff_factor' '=' backoff_factor=DotString)
+;
+
+PROXY:
+    'proxy' '(' proxy=DotString ')'
+;
 
 EXTRA_ARG:
     // there can be more

dothttp/models/computed.py

@@ -88,6 +88,12 @@ class HttpDef:
     test_script: str = ""
     test_script_lang: ScriptType = ScriptType.PYTHON
     proxy: Optional[Dict[str, str]] = None
+    timeout: Optional[float] = None
+    # Retry fields - most commonly used urllib3.Retry parameters
+    retry_total: Optional[int] = None
+    retry_status_forcelist: Optional[List[int]] = None
+    retry_backoff_factor: Optional[float] = None
+    custom_proxy: Optional[str] = None
 
     def get_har(self):
         if self.auth:

dothttp/models/parse_models.py

@@ -126,6 +126,30 @@ class AuthWrap:
     azure_auth: Optional[AzureAuthWrap] = None
 
 
+@dataclass
+class Timeout:
+    timeout_seconds: str
+
+
+@dataclass
+class RetryParam:
+    """Most commonly used urllib3.Retry parameters"""
+    total: Optional[str] = None
+    status_forcelist: Optional[List[str]] = None
+    backoff_factor: Optional[str] = None
+
+
+@dataclass
+class Retry:
+    """Maps to commonly-used urllib3.Retry parameters"""
+    retry_params: Optional[List[RetryParam]] = None
+
+
+@dataclass
+class Proxy:
+    proxy: str
+
+
 @dataclass
 class Query:
     key: str
@@ -225,6 +249,9 @@ class Http:
     lines: Optional[List[Line]]
     payload: Optional[Payload]
     output: Optional[ToFile]
+    timeout: Optional[Timeout] = None
+    retry: Optional[Retry] = None
+    proxy: Optional[Proxy] = None
     description: Optional[str] = None
     extra_args: Optional[List[ExtraArg]] = field(default_factory=lambda: [])
     named_args: Optional[List[NamedArg]] = field(default_factory=lambda: [])

dothttp/parse/__init__.py

@@ -467,6 +467,53 @@ def _load_proxy_details(
                         else None
                     )
 
+    def load_timeout(self):
+        """Load timeout from current request or parent with inheritance"""
+        timeout_wrap = self.get_current_or_base("timeout")
+        if timeout_wrap:
+            timeout_str = self.get_updated_content(timeout_wrap.timeout_seconds)
+            try:
+                self.httpdef.timeout = float(timeout_str)
+                request_logger.debug(f"timeout set to {self.httpdef.timeout} seconds")
+            except ValueError:
+                base_logger.error(f"Invalid timeout value: {timeout_str}")
+
+    def load_retry(self):
+        """Load retry configuration - maps to commonly-used urllib3.Retry parameters"""
+        retry_wrap = self.get_current_or_base("retry")
+        if not retry_wrap or not retry_wrap.retry_params:
+            return
+
+        try:
+            # Process each retry parameter
+            for param in retry_wrap.retry_params:
+                if param.total:
+                    self.httpdef.retry_total = int(self.get_updated_content(param.total))
+
+                if param.status_forcelist:
+                    self.httpdef.retry_status_forcelist = [
+                        int(self.get_updated_content(code))
+                        for code in param.status_forcelist
+                    ]
+
+                if param.backoff_factor:
+                    self.httpdef.retry_backoff_factor = float(self.get_updated_content(param.backoff_factor))
+
+            request_logger.debug(
+                f"retry configured: total={self.httpdef.retry_total}, "
+                f"backoff_factor={self.httpdef.retry_backoff_factor}"
+            )
+        except (ValueError, TypeError) as e:
+            base_logger.error(f"Invalid retry configuration: {e}")
+
+    def load_custom_proxy(self):
+        """Load custom proxy from current request or parent with inheritance"""
+        proxy_wrap = self.get_current_or_base("proxy")
+        if proxy_wrap:
+            proxy_url = self.get_updated_content(proxy_wrap.proxy)
+            self.httpdef.custom_proxy = proxy_url
+            request_logger.debug(f"custom proxy set: {proxy_url}")
+
     def load_headers(self):
         """
             entrypoints
@@ -935,6 +982,9 @@ def load_def(self):
         self.load_payload()
         self.load_auth()
         self.load_proxy()
+        self.load_timeout()
+        self.load_retry()
+        self.load_custom_proxy()
         self.load_certificate()
         self.load_output()
         self._loaded = True

dothttp/parse/request_base.py

@@ -8,6 +8,8 @@
 
 import jstyleson as json
 from requests import PreparedRequest, Response, Session
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 
 # this is bad, loading private stuff. find a better way
 from requests.exceptions import SSLError
@@ -123,7 +125,7 @@ def get_cookie(self):
 
     def get_session(self):
         if self.httpdef.session_clear:
-            # calle should close session
+            # caller should close session
             # TODO
             return get_new_session()
         session = self.global_session
@@ -346,6 +348,30 @@ def format_http(http: Http, property_util: Optional[PropertyProvider]=None):
                     output_str += f'{new_line}azurespcert("tenant_id={cert_auth.tenant_id}", client_id="{cert_auth.client_id}", client_secret="{cert_auth.certificate_path}", scope="{cert_auth.scope}")'
                 else:
                     output_str += f'{new_line}azurecli( scope = "{azure_auth.scope}")'
+
+        # Format timeout
+        if timeout := http.timeout:
+            output_str += f'{new_line}timeout({timeout.timeout_seconds})'
+
+        # Format retry
+        if retry := http.retry:
+            if retry.retry_params:
+                params = []
+                for param in retry.retry_params:
+                    if param.total:
+                        params.append(f'total={param.total}')
+                    if param.backoff_factor:
+                        params.append(f'backoff_factor={param.backoff_factor}')
+                    if param.status_forcelist:
+                        codes = ', '.join(param.status_forcelist)
+                        params.append(f'status_forcelist=[{codes}]')
+                if params:
+                    output_str += f'{new_line}retry({", ".join(params)})'
+
+        # Format proxy
+        if proxy := http.proxy:
+            output_str += f'{new_line}proxy({apply_quote_or_unquote(proxy.proxy)})'
+
         if lines := http.lines:
 
             def check_for_quotes(line):
@@ -555,10 +581,59 @@ def func(data):
             )
             eprint("output file close failed")
 
+    def _create_retry_adapter(self):
+        """
+        Create a retry adapter based on httpdef retry settings.
+
+        Returns HTTPAdapter with retry configuration, or None if no retry is configured.
+        This adapter can be used directly with adapter.send() without mounting on session.
+
+        Passes parameters directly to urllib3.Retry without additional processing.
+        """
+        # Check if any retry configuration exists
+        if self.httpdef.retry_total is None:
+            return None  # No retry configuration
+
+        # Build kwargs for Retry, passing only configured parameters
+        retry_kwargs = {}
+
+        if self.httpdef.retry_total is not None:
+            retry_kwargs['total'] = self.httpdef.retry_total
+
+        if self.httpdef.retry_status_forcelist is not None:
+            retry_kwargs['status_forcelist'] = self.httpdef.retry_status_forcelist
+
+        if self.httpdef.retry_backoff_factor is not None:
+            retry_kwargs['backoff_factor'] = self.httpdef.retry_backoff_factor
+
+        # Always set raise_on_status=False for API testing tools
+        # Users want to see the response regardless of status code
+        retry_kwargs['raise_on_status'] = False
+
+        # Create retry strategy with configured parameters
+        retry_strategy = Retry(**retry_kwargs)
+
+        # Create adapter with retry strategy
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+
+        request_logger.debug(f"Retry adapter created with: {retry_kwargs}")
+
+        return adapter
+
     def get_response(self):
+        """
+        Get HTTP response with optional retry support via urllib3.Retry.
+
+        Uses adapter.send() directly if retry is configured, avoiding session
+        state modification and ensuring thread-safety in concurrent environments.
+        """
         session = self.get_session()
         request = self.get_request()
         session.cookies = request._cookies
+
+        # Create retry adapter if configured (doesn't modify session)
+        retry_adapter = self._create_retry_adapter()
+
         if self.httpdef.p12:
             session.mount(
                 request.url,
@@ -572,25 +647,56 @@ def get_response(self):
                 cert = tuple(self.httpdef.certificate)
             else:
                 cert = None
-            resp: Response = session.send(
-                request,
-                cert=cert,
-                verify=not self.httpdef.allow_insecure,
-                proxies=self.httpdef.proxy,
-                # stream=True
-            )
+
+            # Prepare kwargs for session.send
+            send_kwargs = {
+                'cert': cert,
+                'verify': not self.httpdef.allow_insecure,
+            }
+
+            # Handle proxy configuration
+            # Priority: custom_proxy (from DSL) > proxy (from named_args)
+            if self.httpdef.custom_proxy:
+                send_kwargs['proxies'] = {
+                    'http': self.httpdef.custom_proxy,
+                    'https': self.httpdef.custom_proxy,
+                }
+                request_logger.debug(f"Using custom proxy: {self.httpdef.custom_proxy}")
+            elif self.httpdef.proxy:
+                send_kwargs['proxies'] = self.httpdef.proxy
+
+            # Add timeout if configured
+            if self.httpdef.timeout:
+                send_kwargs['timeout'] = self.httpdef.timeout
+
+            # Use retry adapter if configured, otherwise use session.send()
+            if retry_adapter:
+                # Call adapter.send() directly - no need to mount on session!
+                # This keeps session state clean and is thread-safe
+                resp: Response = retry_adapter.send(request, **send_kwargs)
+            else:
+                # Normal request without retry
+                resp: Response = session.send(request, **send_kwargs)
         except UnicodeEncodeError:
             # for Chinese, smiley all other default encode converts into latin-1
             # as latin-1 didn't consist of those characters it will fail
             # in those scenarios, request will try to encode with utf-8
             # as a last resort, it may not be correct solution. may be it is.
             # for now proceeding with this
             request.prepare_body(request.body.encode("utf-8"), files=None)
-            resp: Response = session.send(
-                request,
-                cert=self.httpdef.certificate,
-                verify=not self.httpdef.allow_insecure,
-            )
+
+            send_kwargs = {
+                'cert': self.httpdef.certificate,
+                'verify': not self.httpdef.allow_insecure,
+            }
+            if self.httpdef.timeout:
+                send_kwargs['timeout'] = self.httpdef.timeout
+
+            # Use retry adapter if configured
+            if retry_adapter:
+                resp: Response = retry_adapter.send(request, **send_kwargs)
+            else:
+                resp: Response = session.send(request, **send_kwargs)
         # in case of ssl self signed error, try to catch it and add more info
         # to user
         except SSLError as e:

examples/graphql/github_api.http

@@ -0,0 +1,37 @@
+# GraphQL Examples with GitHub API
+# GraphQL works out of the box - it's just POST with JSON!
+
+# Simple query
+@name("viewer-info")
+POST https://api.github.com/graphql
+"Authorization": "Bearer {{GITHUB_TOKEN}}"
+
+json({
+  "query": "query { viewer { login name email bio } }"
+})
+
+
+# Query with variables
+@name("get-user-repos")
+POST https://api.github.com/graphql
+"Authorization": "Bearer {{GITHUB_TOKEN}}"
+
+json({
+  "query": "query GetUserRepos($login: String!) { user(login: $login) { name login bio avatarUrl repositories(first: 10, orderBy: {field: STARGAZERS, direction: DESC}) { totalCount nodes { name description stargazerCount forkCount url } } } }",
+  "variables": {
+    "login": "cedric05"
+  }
+})
+
+
+# Mutation example
+@name("add-star")
+POST https://api.github.com/graphql
+"Authorization": "Bearer {{GITHUB_TOKEN}}"
+
+json({
+  "query": "mutation AddStar($repositoryId: ID!) { addStar(input: {starrableId: $repositoryId}) { starrable { stargazerCount } } }",
+  "variables": {
+    "repositoryId": "{{repoId}}"
+  }
+})