bugdantic 0.2.8__tar.gz → 0.4.0__tar.gz

{bugdantic-0.2.8 → bugdantic-0.4.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: bugdantic
-Version: 0.2.8
+Version: 0.4.0
 Summary: Bugzilla client based on pydantic
 Author-email: James Graham <james@hoppipolla.co.uk>
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+License-Expression: MPL-2.0
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.11

{bugdantic-0.2.8 → bugdantic-0.4.0}/bugdantic/bugzilla.py

@@ -4,10 +4,21 @@ import json
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Mapping, MutableMapping, Optional, Sequence, Self
+from typing import (
+    Any,
+    Generic,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Self,
+    TypeVar,
+    cast,
+)
 from urllib.parse import urljoin
 
 import httpx
+import pydantic
 from pydantic import BaseModel, ConfigDict
 
 Json = dict[str, "Json"] | list["Json"] | str | int | float | bool | None
@@ -412,6 +423,13 @@ class AttachmentsCreateResponse(BaseModel):
     attachments: Mapping[str, AttachmentCreateResponse]
 
 
+class ErrorResponse(BaseModel):
+    code: int
+    message: str
+    error: bool
+    documentation: str
+
+
 @dataclass
 class BugzillaConfig:
     base_url: str
@@ -422,6 +440,20 @@ class BugzillaConfig:
     max_retries: int = 1
 
 
+BugType = TypeVar("BugType", bound=BaseModel)
+
+
+class BugSearchGeneric(BaseModel, Generic[BugType]):
+    bugs: Optional[list[BugType]] = None
+    faults: Optional[list[Any]] = None
+
+
+def bug_search_model(bug_type: type[BugType]) -> type[BugSearchGeneric[BugType]]:
+    return cast(
+        type[BugSearchGeneric[BugType]], BugSearchGeneric.__class_getitem__(bug_type)
+    )
+
+
 class Bugzilla:
     def __init__(self, config: BugzillaConfig):
         self.config = config
@@ -491,13 +523,27 @@ class Bugzilla:
 """)
             return {}
 
-    def bug(
-        self, bug_id: int, include_fields: Optional[list[str]] = None
-    ) -> Optional[Bug]:
+    def check_error(self, data: Mapping[str, Json]) -> Mapping[str, Json]:
+        try:
+            err = ErrorResponse.model_validate(data)
+            if err.error:
+                raise BugzillaError(err.message)
+        except pydantic.ValidationError:
+            pass
+        return data
+
+    def _bug(
+        self,
+        bug_id: int,
+        bug_type: type[BugType],
+        include_fields: Optional[list[str]] = None,
+    ) -> Optional[BugType]:
         """Get a single bug specified by id"""
-        search_result = BugSearch.model_validate(
+
+        data = self.check_error(
             self.request("GET", f"bug/{bug_id}", include_fields=include_fields)
         )
+        search_result = bug_search_model(bug_type).model_validate(data)
         if search_result.faults:
             raise BugzillaError(search_result.faults)
         bugs = search_result.bugs
@@ -506,6 +552,15 @@ class Bugzilla:
         assert len(bugs) == 1
         return bugs[0]
 
+    def bug(
+        self, bug_id: int, include_fields: Optional[list[str]] = None
+    ) -> Optional[Bug]:
+        return self._bug(bug_id, Bug, include_fields)
+
+    def bug_as(self, bug_id: int, bug_type: type[BugType]) -> Optional[BugType]:
+        include_fields = list(bug_type.model_fields.keys())
+        return self._bug(bug_id, bug_type, include_fields)
+
     def bugs(
         self,
         bug_ids: Sequence[int],
@@ -525,6 +580,25 @@ class Bugzilla:
             )
         return results
 
+    def bugs_as(
+        self,
+        bug_ids: Sequence[int],
+        bug_type: type[BugType],
+        page_size: int = 100,
+    ) -> list[Bug]:
+        """Get multiple bugs specified by id"""
+        results: list[Bug] = []
+        for bug_ids_chunk in [
+            bug_ids[n : n + page_size] for n in range(0, len(bug_ids), page_size)
+        ]:
+            results.extend(
+                self.search_as(
+                    {"id": ",".join(str(id) for id in bug_ids_chunk)},
+                    bug_type,
+                )
+            )
+        return results
+
     def bug_history(
         self, bug_id: int, new_since: Optional[datetime] = None
     ) -> BugHistory:
@@ -532,9 +606,10 @@ class Bugzilla:
         params = {}
         if new_since is not None:
             params["new_since"] = new_since.strftime("%Y-%m-%dT%H:%M:%SZ")
-        query_result = BugsHistory.model_validate(
+        data = self.check_error(
             self.request("GET", f"bug/{bug_id}/history", params=params)
         )
+        query_result = BugsHistory.model_validate(data)
         if query_result.faults:
             raise BugzillaError(query_result.faults)
         bugs = query_result.bugs
@@ -543,13 +618,15 @@ class Bugzilla:
         assert len(bugs) == 1
         return bugs[0]
 
-    def search(
+    def _search(
         self,
+        bug_type: type[BugType],
         query: QueryParams,
         include_fields: Optional[list[str]] = None,
         page_size: int = 100,
-    ) -> list[Bug]:
+    ) -> list[BugType]:
         """Search for bugs using the bugzilla query API"""
+
         query = {**query}
         paginate = False
         offset = 0
@@ -558,12 +635,12 @@ class Bugzilla:
             query["offset"] = "0"
             paginate = True
 
-        results: list[Bug] = []
+        results: list[BugType] = []
         while True:
-            response = self.request(
-                "GET", "bug", params=query, include_fields=include_fields
+            response = self.check_error(
+                self.request("GET", "bug", params=query, include_fields=include_fields)
             )
-            search_result = BugSearch.model_validate(response)
+            search_result = bug_search_model(bug_type).model_validate(response)
             if search_result.faults:
                 raise BugzillaError(search_result.faults)
             if search_result.bugs is not None:
@@ -581,6 +658,20 @@ class Bugzilla:
 
         return results
 
+    def search(
+        self,
+        query: QueryParams,
+        include_fields: Optional[list[str]] = None,
+        page_size: int = 100,
+    ) -> list[Bug]:
+        return self._search(Bug, query, include_fields, page_size)
+
+    def search_as(
+        self, query: QueryParams, bug_type: type[BugType], page_size: int = 100
+    ):
+        include_fields = list(bug_type.model_fields.keys())
+        return self._search(bug_type, query, include_fields, page_size)
+
     def update_bugs(
         self, update_params: BugUpdate, bug_id: Optional[int] = None
     ) -> list[BugUpdateResponse]:
@@ -600,7 +691,7 @@ class Bugzilla:
 
         json_body = update_params.model_dump(exclude_none=True)
 
-        response = self.request("PUT", path, json_body=json_body)
+        response = self.check_error(self.request("PUT", path, json_body=json_body))
 
         if self.config.allow_writes:
             update_result = BugsUpdateResponse.model_validate(response)
@@ -632,7 +723,7 @@ class Bugzilla:
         if not json_body.get("ids"):
             json_body["ids"] = [bug_id]
 
-        response = self.request("POST", path, json_body=json_body)
+        response = self.check_error(self.request("POST", path, json_body=json_body))
 
         if self.config.allow_writes:
             create_result = AttachmentsCreateResponse.model_validate(response)

bugdantic-0.4.0/bugdantic/userstory.py

@@ -0,0 +1,130 @@
+"""Utility functions for working with cf_user_story fields that
+are used to store key: value pair data"""
+
+from collections import defaultdict
+from enum import IntEnum
+from dataclasses import dataclass
+
+import re
+from typing import Iterator, Optional, Mapping, Self
+
+
+def parse(
+    user_story: str,
+) -> Iterator[tuple[str, Optional[str], Optional[str]]]:
+    """Parse the user story assuming it's lines of the form key: value.
+
+    If there isn't a colon in the line we simply set value to the full line."""
+    user_story_re = re.compile(r"^\s*([^\s]+)\s*:\s*(.*)")
+    for line in user_story.splitlines():
+        key = None
+        value = None
+        m = user_story_re.match(line)
+        if m is not None:
+            maybe_key, maybe_value = m.groups()
+            if maybe_value:
+                key = maybe_key
+                value = maybe_value
+        yield line, key, value
+
+
+def parse_as_dict(user_story: str) -> Mapping[str, str | list[str]]:
+    rv: dict[str, str | list[str]] = {}
+    for _, key, value in parse(user_story):
+        if key is not None and value is not None:
+            if key in rv:
+                current_value = rv[key]
+                if isinstance(current_value, list):
+                    current_value.append(value)
+                else:
+                    rv[key] = [current_value, value]
+            else:
+                rv[key] = value
+    return rv
+
+
+class UserStoryChangeType(IntEnum):
+    APPEND = 1
+    REPLACE = 2
+    DELETE = 3
+
+
+@dataclass(frozen=True)
+class UserStoryChange:
+    field: str
+    type: UserStoryChangeType
+    # In case of replace changes, the current value to replace or delete
+    old_value: Optional[str] = None
+    # In case of append or replace changes the new value to set
+    new_value: Optional[str] = None
+
+    @classmethod
+    def append(cls, field: str, new_value: str) -> Self:
+        return cls(field, UserStoryChangeType.APPEND, None, new_value)
+
+    @classmethod
+    def replace(cls, field: str, old_value: str, new_value: str) -> Self:
+        return cls(field, UserStoryChangeType.REPLACE, old_value, new_value)
+
+    @classmethod
+    def delete(cls, field: str, old_value: str) -> Self:
+        return cls(field, UserStoryChangeType.DELETE, old_value, None)
+
+
+def update(user_story: str, changes: list[UserStoryChange]) -> Optional[str]:
+    new_user_story = []
+    user_story_updates = defaultdict(list)
+    for change in changes:
+        user_story_updates[change.field].append(change)
+
+    has_updates = False
+    applied_changes = set()
+
+    for line, key, value in parse(user_story):
+        if key is None or value is None:
+            new_user_story.append(line)
+            continue
+
+        output_line: Optional[tuple[str, str]] = (key, value)
+        if key in user_story_updates:
+            changes = user_story_updates[key]
+            current_value = value.strip()
+            for change in changes:
+                if change in applied_changes:
+                    continue
+                if current_value == change.old_value:
+                    applied_changes.add(change)
+                    if change.type == UserStoryChangeType.DELETE:
+                        output_line = None
+                        has_updates = True
+                    elif change.type == UserStoryChangeType.REPLACE:
+                        assert change.new_value is not None
+                        output_line = (key, change.new_value)
+                        has_updates = True
+                elif (
+                    change.type == UserStoryChangeType.APPEND
+                    and current_value == change.new_value
+                ):
+                    # If we are going to append a value that's already there
+                    # do nothing
+                    applied_changes.add(change)
+        if output_line is not None:
+            new_user_story.append(f"{output_line[0]}:{output_line[1]}")
+
+    for changes in user_story_updates.values():
+        for change in changes:
+            if change not in applied_changes:
+                if change.type == UserStoryChangeType.DELETE:
+                    # Tried to delete a key that doesn't exist, do nothing
+                    pass
+                elif change.type == UserStoryChangeType.REPLACE:
+                    # Tried to replace a key that doesn't exist, do nothing
+                    pass
+                elif change.type == UserStoryChangeType.APPEND:
+                    new_user_story.append(f"{change.field}:{change.new_value}")
+                    has_updates = True
+
+    if has_updates:
+        return "\n".join(new_user_story) + "\n"
+
+    return None

{bugdantic-0.2.8 → bugdantic-0.4.0}/bugdantic.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: bugdantic
-Version: 0.2.8
+Version: 0.4.0
 Summary: Bugzilla client based on pydantic
 Author-email: James Graham <james@hoppipolla.co.uk>
-Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+License-Expression: MPL-2.0
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.11

{bugdantic-0.2.8 → bugdantic-0.4.0}/bugdantic.egg-info/SOURCES.txt

@@ -4,9 +4,11 @@ pyproject.toml
 bugdantic/__init__.py
 bugdantic/bugzilla.py
 bugdantic/py.typed
+bugdantic/userstory.py
 bugdantic.egg-info/PKG-INFO
 bugdantic.egg-info/SOURCES.txt
 bugdantic.egg-info/dependency_links.txt
 bugdantic.egg-info/requires.txt
 bugdantic.egg-info/top_level.txt
-test/test_bugzilla.py
+test/test_bugzilla.py
+test/test_userstory.py

{bugdantic-0.2.8 → bugdantic-0.4.0}/pyproject.toml

@@ -5,10 +5,10 @@ authors = [
   {name = "James Graham", email = "james@hoppipolla.co.uk"}
 ]
 
-version = "0.2.8"
+version = "0.4.0"
 requires-python = ">=3.11"
+license = "MPL-2.0"
 classifiers = [
-    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]

{bugdantic-0.2.8 → bugdantic-0.4.0}/test/test_bugzilla.py

@@ -1,6 +1,8 @@
 import pytest
+from pydantic import BaseModel
 
 from bugdantic import Bugzilla, BugzillaConfig
+from bugdantic.bugzilla import BugComment
 
 
 @pytest.fixture
@@ -26,7 +28,7 @@ def test_bug_history_full(bugzilla):
     assert result.id == 1886129
 
 
-def test_serach_include_history(bugzilla):
+def test_search_include_history(bugzilla):
     bugs = [423488, 1749533]
     result = bugzilla.search({"id": bugs}, include_fields=["id", "history"])
     for expected_id, bug in zip(bugs, sorted(result, key=lambda x: x.id)):
@@ -43,3 +45,27 @@ def test_search_include_comments_and_attachments(bugzilla):
         assert bug.id == expected_id
         assert isinstance(bug.comments, list)
         assert isinstance(bug.attachments, list)
+
+
+def test_bug_as(bugzilla):
+    class BugData(BaseModel):
+        id: int
+        cf_user_story: str
+
+    result = bugzilla.bug_as(975444, BugData)
+    assert isinstance(result, BugData)
+    assert result.id == 975444
+    assert result.cf_user_story is not None
+
+
+def test_search_as(bugzilla):
+    class BugData(BaseModel):
+        id: int
+        comments: list[BugComment]
+
+    bugs = [423488, 1749533]
+    result = bugzilla.search_as({"id": bugs}, BugData)
+    for expected_id, bug in zip(bugs, sorted(result, key=lambda x: x.id)):
+        assert isinstance(bug, BugData)
+        assert bug.id == expected_id
+        assert isinstance(bug.comments, list)

bugdantic-0.4.0/test/test_userstory.py

@@ -0,0 +1,59 @@
+from bugdantic import userstory
+
+
+def test_parse_user_story():
+    user_story = """
+foo:bar
+abcde:
+  foo : baz
+some long line: with a colon
+key-:value
+"""
+    assert list(userstory.parse(user_story)) == [
+        ("", None, None),
+        ("foo:bar", "foo", "bar"),
+        ("abcde:", None, None),
+        ("  foo : baz", "foo", "baz"),
+        ("some long line: with a colon", None, None),
+        ("key-:value", "key-", "value"),
+    ]
+
+    assert userstory.parse_as_dict(user_story) == {
+        "foo": ["bar", "baz"],
+        "key-": "value",
+    }
+
+
+def test_update_user_story():
+    user_story = """
+foo:bar
+abcde:
+  foo : baz
+some long line: with a colon
+key-:value
+key:value
+"""
+
+    changes = [
+        userstory.UserStoryChange.replace("foo", "bar", "foobar"),
+        userstory.UserStoryChange.delete("key-", "value"),
+        userstory.UserStoryChange.append("foo", "new"),
+        userstory.UserStoryChange.append("new_key", "new_value"),
+        # These ones shouldn't do anything
+        userstory.UserStoryChange.replace("foo", "missing", "fail"),
+        userstory.UserStoryChange.replace("missing", "missing", "fail"),
+        userstory.UserStoryChange.delete("key", "missing"),
+        userstory.UserStoryChange.delete("missing", "missing"),
+    ]
+    assert (
+        userstory.update(user_story, changes)
+        == """
+foo:foobar
+abcde:
+foo:baz
+some long line: with a colon
+key:value
+foo:new
+new_key:new_value
+"""
+    )