vilvik 0.2.2__tar.gz → 0.4.0__tar.gz

{vilvik-0.2.2 → vilvik-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vilvik
-Version: 0.2.2
+Version: 0.4.0
 Summary: Official Python SDK for the Vilvik optimization cloud API.
 Author-email: Vilvik <ahmed.f.gad@gmail.com>
 License: MIT

{vilvik-0.2.2 → vilvik-0.4.0}/tests/test_client.py

@@ -86,6 +86,46 @@ def test_submissions_create_forwards_extra_ga_params(mock_api, client):
     assert body["parent_selection_type"] == "tournament"
 
 
+def test_submissions_create_auto_detects_entry_symbol(mock_api, client):
+    """The entry symbol is detected from the source and sent, so callers
+    don't have to repeat the function name. The runtime requires it."""
+    mock_api.add("POST", f"{BASE}/submissions",
+                 json={"id": "sub_e", "status": "queued"}, status=202)
+    client.submissions.create(
+        fitness_func="def my_fitness(g, s, i):\n    return sum(s)\n",
+        num_genes=3,
+    )
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body["fitness_func_entry"] == "my_fitness"
+
+
+def test_submissions_create_honors_explicit_entry_symbol(mock_api, client):
+    """An explicit <role>_entry is never overridden by detection."""
+    mock_api.add("POST", f"{BASE}/submissions",
+                 json={"id": "sub_e2", "status": "queued"}, status=202)
+    client.submissions.create(
+        fitness_func="def a(g, s, i): return 0\ndef b(g, s, i): return 1\n",
+        fitness_func_entry="a",
+        num_genes=3,
+    )
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body["fitness_func_entry"] == "a"
+
+
+def test_submissions_create_detects_entry_for_callbacks(mock_api, client):
+    """Callback code fields passed as source also get their entry symbol."""
+    mock_api.add("POST", f"{BASE}/submissions",
+                 json={"id": "sub_e3", "status": "queued"}, status=202)
+    client.submissions.create(
+        fitness_func="def fitness_func(g, s, i): return 0",
+        on_generation="def log_gen(ga):\n    pass\n",
+        num_genes=3,
+    )
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body["fitness_func_entry"] == "fitness_func"
+    assert body["on_generation_entry"] == "log_gen"
+
+
 def test_submissions_get(mock_api, client):
     mock_api.add(
         "GET",
@@ -173,6 +213,44 @@ def test_results_continue_run(mock_api, client):
     assert body == {"sol_per_pop": 200}
 
 
+def test_results_delete(mock_api, client):
+    mock_api.add("DELETE", f"{BASE}/results/res_1", status=204)
+    # Must not raise and returns None on 204.
+    assert client.results.delete("res_1") is None
+
+
+def test_results_update_sends_patch_and_returns_result(mock_api, client):
+    mock_api.add(
+        "PATCH",
+        f"{BASE}/results/res_1",
+        json={
+            "id": "res_1",
+            "submission_id": "sub_abc",
+            "name": "renamed result",
+            "is_shared": True,
+        },
+    )
+    r = client.results.update("res_1", name="renamed result", is_shared=True)
+    assert mock_api.calls[0].request.method == "PATCH"
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body == {"name": "renamed result", "is_shared": True}
+    assert r.name == "renamed result"
+    assert r.is_shared is True
+
+
+def test_results_update_sends_only_provided_fields(mock_api, client):
+    """Partial update: passing only is_shared=False must send just that key
+    (False is a real value, not 'unset')."""
+    mock_api.add(
+        "PATCH",
+        f"{BASE}/results/res_1",
+        json={"id": "res_1", "submission_id": "sub_abc", "is_shared": False},
+    )
+    client.results.update("res_1", is_shared=False)
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body == {"is_shared": False}
+
+
 def test_wait_for_returns_result_when_submission_succeeds(mock_api, client, monkeypatch):
     monkeypatch.setattr("vilvik.client.time.sleep", lambda *_a, **_k: None)
     # First poll: still running. Second poll: succeeded. Then list returns one row.
@@ -235,15 +313,30 @@ def test_code_upload_create(mock_api, client):
     mock_api.add(
         "POST",
         f"{BASE}/code-uploads",
-        json={"id": "code_1", "field": "fitness_func", "size_bytes": 42},
+        json={"code_id": "code_1", "content_size": 42, "is_expired": False},
         status=201,
     )
     blob = client.code_uploads.create(
-        field="fitness_func",
-        code="def fitness_func(g, s, i): return 0",
+        content="def fitness_func(g, s, i): return 0",
     )
-    assert blob.id == "code_1"
-    assert blob.field_name == "fitness_func"
+    assert blob.code_id == "code_1"
+    assert blob.content_size == 42
+    # The request sends the source under `content`, matching the REST API.
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body == {"content": "def fitness_func(g, s, i): return 0"}
+
+
+def test_code_upload_referenced_in_submission(mock_api, client):
+    """An uploaded blob is referenced by `<role>_id`, using its code_id."""
+    mock_api.add("POST", f"{BASE}/submissions",
+                 json={"id": "sub_ref", "status": "queued"}, status=202)
+    client.submissions.create(
+        fitness_func_id="code_1",
+        fitness_func_entry="fitness_func",
+        num_genes=3,
+    )
+    body = json.loads(mock_api.calls[0].request.body)
+    assert body["fitness_func_id"] == "code_1"
 
 
 def test_webhooks_list(mock_api, client):

vilvik-0.4.0/vilvik/_version.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{vilvik-0.2.2 → vilvik-0.4.0}/vilvik/client.py

@@ -12,6 +12,7 @@ import os
 import time
 from typing import Any, Dict, Iterable, Iterator, List, Optional
 
+from vilvik._capture import CODE_ROLES, _detect_entry_from_source
 from vilvik._http import DEFAULT_BASE_URL, DEFAULT_TIMEOUT_SECONDS, Transport
 from vilvik.exceptions import TimeoutError as VilvikTimeout
 from vilvik.models import CodeUpload, ImportRecord, Page, Result, Submission, Webhook
@@ -67,6 +68,24 @@ class Submissions(_Resource):
             body["notification_email"] = notification_email
         body.update({k: v for k, v in ga_params.items() if v is not None})
 
+        # Fill in the entry symbol for each code field, the way the website's
+        # new-submission form does. The runtime requires the top-level name to
+        # call and no longer guesses, so a code field sent without its
+        # `<role>_entry` is rejected by the server. Detect it from the source
+        # (the last top-level def/class), but never override an entry the
+        # caller passed explicitly. If detection fails we leave it unset and
+        # let the server return its clear "entry symbol is required" error.
+        for role in CODE_ROLES:
+            source = body.get(role)
+            if not isinstance(source, str) or not source.strip():
+                continue
+            entry_key = f"{role}_entry"
+            if body.get(entry_key):
+                continue
+            detected = _detect_entry_from_source(source)
+            if detected:
+                body[entry_key] = detected
+
         payload = self._t.request(
             "POST",
             "/submissions",
@@ -141,6 +160,30 @@ class Results(_Resource):
         items = [Result.from_api(row) for row in payload.get("data", [])]
         return Page(items=items, next_cursor=payload.get("next_cursor"), raw=payload)
 
+    def update(
+        self,
+        result_id: str,
+        *,
+        name: Optional[str] = None,
+        is_shared: Optional[bool] = None,
+    ) -> Result:
+        """PATCH /results/{id} — rename a result or change its shared flag.
+
+        Only the fields you pass are sent, so `is_shared=False` updates just
+        that flag. Returns the updated result.
+        """
+        body: Dict[str, Any] = {}
+        if name is not None:
+            body["name"] = name
+        if is_shared is not None:
+            body["is_shared"] = is_shared
+        payload = self._t.request("PATCH", f"/results/{result_id}", json_body=body)
+        return Result.from_api(payload)
+
+    def delete(self, result_id: str) -> None:
+        """DELETE /results/{id} — remove a result. The submission is untouched."""
+        self._t.request("DELETE", f"/results/{result_id}")
+
     def continue_run(
         self,
         result_id: str,
@@ -212,11 +255,17 @@ class Results(_Resource):
 class CodeUploads(_Resource):
     """Endpoints under `/api/v1/code-uploads`."""
 
-    def create(self, *, field: str, code: str) -> CodeUpload:
+    def create(self, *, content: str) -> CodeUpload:
+        """Upload a code blob and get back a `code_id` to reference.
+
+        The upload is role-agnostic. Reference it from a submission via the
+        matching `<role>_id` parameter, e.g. passing the returned
+        `code_id` as `fitness_func_id=...` to `submissions.create`.
+        """
         payload = self._t.request(
             "POST",
             "/code-uploads",
-            json_body={"field": field, "code": code},
+            json_body={"content": content},
         )
         return CodeUpload.from_api(payload)
 

{vilvik-0.2.2 → vilvik-0.4.0}/vilvik/models.py

@@ -70,6 +70,8 @@ class Result:
 
     id: str
     submission_id: str
+    name: Optional[str] = None
+    is_shared: Optional[bool] = None
     best_fitness: Optional[float] = None
     best_solution: Optional[List[Any]] = None
     num_generations_ran: Optional[int] = None
@@ -82,6 +84,8 @@ class Result:
         return cls(
             id=str(data.get("id", "")),
             submission_id=str(data.get("submission_id", "")),
+            name=data.get("name"),
+            is_shared=data.get("is_shared"),
             best_fitness=data.get("best_fitness"),
             best_solution=data.get("best_solution"),
             num_generations_ran=data.get("num_generations_ran"),
@@ -95,23 +99,30 @@ class Result:
 class CodeUpload:
     """A reusable code blob that submissions can reference by id.
 
-    The model attribute is named `field_name` rather than `field` to
-    avoid shadowing `dataclasses.field` inside the class body.
+    Uploads are role-agnostic: the server stores the source and returns a
+    `code_id`. You choose which role it fills when you reference it from a
+    submission, e.g. `fitness_func_id=upload.code_id`.
     """
 
-    id: str
-    field_name: str = ""
-    size_bytes: Optional[int] = None
+    code_id: str
+    content: Optional[str] = None
+    content_size: Optional[int] = None
+    content_sha256: Optional[str] = None
     created_at: Optional[datetime] = None
+    expires_at: Optional[datetime] = None
+    is_expired: Optional[bool] = None
     raw: Dict[str, Any] = field(default_factory=dict)
 
     @classmethod
     def from_api(cls, data: Dict[str, Any]) -> "CodeUpload":
         return cls(
-            id=str(data.get("id", "")),
-            field_name=str(data.get("field", "") or ""),
-            size_bytes=data.get("size_bytes"),
+            code_id=str(data.get("code_id", "")),
+            content=data.get("content"),
+            content_size=data.get("content_size"),
+            content_sha256=data.get("content_sha256"),
             created_at=_parse_dt(data.get("created_at")),
+            expires_at=_parse_dt(data.get("expires_at")),
+            is_expired=data.get("is_expired"),
             raw=dict(data),
         )
 

{vilvik-0.2.2 → vilvik-0.4.0}/vilvik.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vilvik
-Version: 0.2.2
+Version: 0.4.0
 Summary: Official Python SDK for the Vilvik optimization cloud API.
 Author-email: Vilvik <ahmed.f.gad@gmail.com>
 License: MIT

vilvik-0.2.2/vilvik/_version.py

@@ -1 +0,0 @@
-__version__ = "0.2.2"