I pasted this into Google Gemini

The requests.exceptions.SSLError: HTTPSConnectionPool(host='gitlab.example.com', port=80): Max retries exceeded with url: ... (Caused by SSLError(SSLError(1, '[SSL: WRONG_VERSION_NUMBER] wrong version number (_ssl.c:1028)'))) error indicates a problem with the SSL/TLS handshake between your Python program and the GitLab server.
Here's a breakdown of what's likely happening and how to troubleshoot it:
Understanding the Error

• SSLError: WRONG_VERSION_NUMBER: This is the core of the problem. It means that during the SSL/TLS handshake, the client (your Python program) and the server (gitlab.example.com) are unable to agree on a compatible SSL/TLS protocol version.
• HTTPSConnectionPool(host='gitlab.example.com', port=80): This part is crucial. You're trying to connect to gitlab.example.com on port 80. Port 80 is typically used for HTTP (unencrypted) traffic, not HTTPS (encrypted) traffic. SSL/TLS operates on a different port, usually 443.
  Most Likely Cause
  You are attempting to make an HTTPS request to an HTTP port (port 80). The server on port 80 is not expecting an SSL handshake, so it responds with something that the SSL client interprets as a "wrong version number" because it's not a valid SSL/TLS handshake.
  Solutions
• Correct the Port to 443 (Most Common Fix):
  If gitlab.example.com is indeed an HTTPS server (which is standard for GitLab), you should be connecting to port 443. Change your URL to use https:// and ensure you're not explicitly setting the port to 80.
  import requests

Correct URL for HTTPS

url = "https://gitlab.example.com/api/v4/projects/5/labels?id=5&include_ancestor_groups=true&page=2&per_page=20&with_counts=false"

try:
    response = requests.get(url)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
    print("Success!")
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

• Verify the Server's SSL/TLS Configuration:
  If you are sure you want to connect to gitlab.example.com and it's supposed to be an HTTPS endpoint, there might be an issue with the server's SSL/TLS configuration itself.

  • Self-signed certificates: If gitlab.example.com uses a self-signed certificate, your requests client won't trust it by default. You can tell requests to ignore SSL verification (use with caution, as it makes your connection vulnerable to Man-in-the-Middle attacks):
    requests.get(url, verify=False)

    Or, a better approach is to provide the path to your custom CA bundle:
    requests.get(url, verify='/path/to/your/custom_ca_bundle.pem')

  • Outdated TLS protocols: The server might be configured to only support older, insecure TLS versions (like TLS 1.0 or 1.1) which modern Python and OpenSSL versions might deprecate or not enable by default. While less common for GitLab, it's a possibility.

  • Intermediate Proxies/Firewalls: Sometimes, a network proxy or firewall can intercept SSL/TLS traffic and cause these issues. This is especially true in corporate environments. The proxy might be presenting its own certificate or interfering with the SSL handshake.

• Check for Network Intermediaries:
  As mentioned, firewalls, proxies, or even antivirus software can sometimes intercept and re-encrypt HTTPS traffic. If you're in such an environment, consult your IT department or try disabling any such software temporarily (if safe to do so) to see if it resolves the issue.

• Use curl to Test:
  You can use curl from your terminal to get more verbose information about the SSL handshake with the GitLab server.
  curl -vI https://gitlab.example.com/

  This will show you the SSL/TLS version, cipher suites, and certificate details. If you get a "wrong version number" with curl as well, it strongly indicates a server-side configuration issue or a network intermediary.
  In summary, the most likely solution is to ensure your URL uses https:// and therefore connects to port 443.