codeplain 0.3.11.dev22__tar.gz → 0.3.12.dev24__tar.gz

{codeplain-0.3.11.dev22 → codeplain-0.3.12.dev24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.11.dev22
+Version: 0.3.12.dev24
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

{codeplain-0.3.11.dev22 → codeplain-0.3.12.dev24}/codeplain_REST_api.py

@@ -1,8 +1,11 @@
+import socket
 import time
 from typing import Optional
 
 import requests
+from requests.adapters import HTTPAdapter
 from requests.exceptions import ConnectionError, RequestException, Timeout
+from urllib3.connection import HTTPConnection
 
 import plain2code_exceptions
 from plain2code_console import RETRY_COLOR
@@ -15,6 +18,57 @@ RETRY_DELAY = 3
 # at exit, and requests waits indefinitely by default.
 REPORT_TIMEOUT_SECONDS = 5
 
+# A render call can leave the connection with nothing on it for several minutes while the
+# service works on the answer. Network equipment between the two, such as the address
+# translation a CI runner sits behind, drops a connection that quiet and tells neither end.
+# The answer then has nowhere to go and the client waits for it for as long as it is allowed
+# to run. These probes put a packet on the connection often enough to keep it, and they end
+# it when the other end has really gone.
+KEEPALIVE_IDLE_SECONDS = 60
+KEEPALIVE_INTERVAL_SECONDS = 30
+KEEPALIVE_FAILED_PROBES = 4
+
+
+def keepalive_socket_options():
+    """The socket options that keep a long, quiet request alive, for the platforms that have them."""
+    options = list(HTTPConnection.default_socket_options)
+    options.append((socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1))
+    # The option that sets the idle time is named differently per platform, and Windows has
+    # none of the three. Whatever is missing is left out; the keepalive itself still applies.
+    for idle_option in ("TCP_KEEPIDLE", "TCP_KEEPALIVE"):
+        if hasattr(socket, idle_option):
+            options.append((socket.IPPROTO_TCP, getattr(socket, idle_option), KEEPALIVE_IDLE_SECONDS))
+            break
+    if hasattr(socket, "TCP_KEEPINTVL"):
+        options.append((socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL_SECONDS))
+    if hasattr(socket, "TCP_KEEPCNT"):
+        options.append((socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_FAILED_PROBES))
+    return options
+
+
+class KeepaliveAdapter(HTTPAdapter):
+    """Opens every connection with keepalive on, whether it goes direct or through a proxy."""
+
+    def init_poolmanager(self, *args, **kwargs):
+        kwargs["socket_options"] = keepalive_socket_options()
+        return super().init_poolmanager(*args, **kwargs)
+
+    def proxy_manager_for(self, proxy, **proxy_kwargs):
+        # A request that goes through a proxy is served from a separate pool, which the
+        # options above never reach. A render behind a proxy is as quiet as any other and
+        # needs the same keepalive.
+        proxy_kwargs["socket_options"] = keepalive_socket_options()
+        return super().proxy_manager_for(proxy, **proxy_kwargs)
+
+
+def new_session():
+    """A requests session whose connections carry keepalive."""
+    session = requests.Session()
+    session.mount("https://", KeepaliveAdapter())
+    session.mount("http://", KeepaliveAdapter())
+    return session
+
+
 RETRY_ERROR_CODES = [
     "LLMInternalError",
 ]
@@ -36,6 +90,7 @@ class CodeplainAPI:
     def __init__(self, api_key, console):
         self.api_key = api_key
         self.console = console
+        self.session = new_session()
 
     @property
     def api_url(self):
@@ -139,7 +194,7 @@ class CodeplainAPI:
 
         for attempt in range(num_retries + 1):
             try:
-                response = requests.post(endpoint_url, headers=headers, json=payload, timeout=timeout)
+                response = self.session.post(endpoint_url, headers=headers, json=payload, timeout=timeout)
 
                 try:
                     response_json = response.json()

{codeplain-0.3.11.dev22 → codeplain-0.3.12.dev24}/file_utils.py

@@ -142,7 +142,20 @@ def get_existing_files_content(build_folder, existing_files):
     return existing_files_content
 
 
+def ensure_final_newline(content: str) -> str:
+    """Ends non-empty text with a newline, as linters expect (e.g. RuboCop, ESLint eol-last, Ruff W292)."""
+    if content and not content.endswith("\n"):
+        return content + "\n"
+    return content
+
+
 def store_response_files(target_folder, response_files, existing_files):
+    """Writes the files returned by the API to target_folder. None content deletes the file.
+
+    Every written file ends with a newline - whole-file rewrites come back from the API without one. The
+    added newline is also written back into response_files, so callers that diff response_files against
+    the folder afterwards see exactly what is on disk.
+    """
     for file_name in response_files:
         full_file_name = os.path.join(target_folder, file_name)
 
@@ -156,6 +169,8 @@ def store_response_files(target_folder, response_files, existing_files):
 
             continue
 
+        response_files[file_name] = ensure_final_newline(response_files[file_name])
+
         os.makedirs(os.path.dirname(full_file_name), exist_ok=True)
 
         with open(full_file_name, "w", encoding="utf-8") as f:

{codeplain-0.3.11.dev22 → codeplain-0.3.12.dev24}/tests/test_file_utils.py

@@ -3,7 +3,8 @@ import tempfile
 
 import pytest
 
-from file_utils import load_linked_resources, store_response_files
+from diff_utils import get_code_diff
+from file_utils import get_existing_files_content, load_linked_resources, store_response_files
 from plain2code_exceptions import UnsupportedBase64Content, UnsupportedResourceType
 from plain2code_utils import MAX_BASE64_BLOB_LENGTH
 
@@ -84,9 +85,64 @@ def test_load_linked_resources_real_base64_image_raises(template_dir):
 def test_store_response_files_writes_unicode_as_utf8(template_dir):
     # Content with a non-cp1252 character (📍 U+1F4CD) must be written as UTF-8
     # regardless of the platform's default text encoding (e.g. cp1252 on Windows).
-    content = "Location 📍 marker"
+    content = "Location 📍 marker\n"
     store_response_files(template_dir, {"notes.md": content}, [])
 
     file_path = os.path.join(template_dir, "notes.md")
     with open(file_path, "rb") as f:
         assert f.read().decode("utf-8") == content
+
+
+def _read_bytes(folder, file_name):
+    with open(os.path.join(folder, file_name), "rb") as f:
+        return f.read().decode("utf-8")
+
+
+@pytest.mark.parametrize(
+    "content, expected",
+    [
+        ("class Foo\nend", "class Foo\nend\n"),
+        ("class Foo\nend\n", "class Foo\nend\n"),
+        ("class Foo\nend\n\n", "class Foo\nend\n\n"),
+        ("class Foo\r\nend\r\n", "class Foo\r\nend\r\n"),
+        ("", ""),
+    ],
+)
+def test_store_response_files_ends_every_text_file_with_a_newline(template_dir, content, expected):
+    # Linters gate on a final newline (RuboCop Layout/TrailingEmptyLines, ESLint eol-last, Ruff W292), so a
+    # whole-file rewrite that comes back without one must not reach the disk that way.
+    store_response_files(template_dir, {"app/foo.rb": content}, [])
+
+    assert _read_bytes(template_dir, "app/foo.rb") == expected
+
+
+def test_store_response_files_hands_back_the_content_it_wrote(template_dir):
+    # Callers diff the response files against the build folder after storing them (fix journal, conformance
+    # fixes handed to the unit tests fixer), so the response files must match what is on disk.
+    response_files = {"app/foo.rb": "class Foo\nend", "app/bar.rb": "class Bar\nend\n"}
+
+    store_response_files(template_dir, response_files, [])
+
+    assert response_files == {"app/foo.rb": "class Foo\nend\n", "app/bar.rb": "class Bar\nend\n"}
+
+
+def test_rewriting_a_file_without_its_final_newline_does_not_change_it(template_dir):
+    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
+    existing_files_content = get_existing_files_content(template_dir, existing_files)
+
+    rewrite = {"app/foo.rb": "class Foo\nend"}
+    store_response_files(template_dir, rewrite, existing_files)
+
+    assert get_existing_files_content(template_dir, existing_files) == existing_files_content
+    assert get_code_diff(rewrite, existing_files_content) == {}
+
+
+def test_store_response_files_still_deletes_a_file_whose_content_is_none(template_dir):
+    existing_files = store_response_files(template_dir, {"app/foo.rb": "class Foo\nend\n"}, [])
+
+    response_files = {"app/foo.rb": None}
+    store_response_files(template_dir, response_files, existing_files)
+
+    assert not os.path.exists(os.path.join(template_dir, "app/foo.rb"))
+    assert existing_files == []
+    assert response_files == {"app/foo.rb": None}