bugdantic 0.2.7__tar.gz → 0.3.0__tar.gz

{bugdantic-0.2.7 → bugdantic-0.3.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: bugdantic
-Version: 0.2.7
+Version: 0.3.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.7 → bugdantic-0.3.0}/bugdantic/bugzilla.py

@@ -4,11 +4,11 @@ import json
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Mapping, MutableMapping, Optional, Sequence
+from typing import Any, Mapping, MutableMapping, Optional, Sequence, Self
 from urllib.parse import urljoin
 
 import httpx
-from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import BaseModel, ConfigDict
 
 Json = dict[str, "Json"] | list["Json"] | str | int | float | bool | None
 
@@ -348,7 +348,7 @@ class AttachmentCreate(BaseModel):
     data: str
     file_name: str
     summary: str
-    content_type: Optional[str] = None
+    content_type: str
     comment: Optional[str] = None
     is_markdown: Optional[bool] = None
     is_patch: Optional[bool] = None
@@ -356,16 +356,60 @@ class AttachmentCreate(BaseModel):
     flags: Optional[list[FlagChange]] = None
     bug_flags: Optional[list[FlagChange]] = None
 
-    @field_validator("data", mode="before")
     @classmethod
-    def encode_data(cls, value: bytes | str) -> str:
-        if isinstance(value, bytes):
-            return base64.b64encode(value).decode("ascii")
-        return value
+    def from_raw_data(
+        cls,
+        data: str | bytes,
+        file_name: str,
+        summary: str,
+        content_type: str,
+        ids: Optional[list[int | str]] = None,
+        comment: Optional[str] = None,
+        is_markdown: Optional[bool] = None,
+        is_patch: Optional[bool] = None,
+        is_private: Optional[bool] = None,
+        flags: Optional[list[FlagChange]] = None,
+        bug_flags: Optional[list[FlagChange]] = None,
+    ) -> Self:
+        if isinstance(data, str):
+            data = data.encode("utf8")
+        return cls(
+            ids=ids,
+            data=base64.b64encode(data).decode("ascii"),
+            file_name=file_name,
+            summary=summary,
+            content_type=content_type,
+            comment=comment,
+            is_markdown=is_markdown,
+            is_patch=is_patch,
+            is_private=is_private,
+            flags=flags,
+            bug_flags=bug_flags,
+        )
 
 
 class AttachmentCreateResponse(BaseModel):
-    ids: list[int]
+    attacher: str
+    bug_id: int
+    content_type: str
+    creation_time: datetime
+    creator: str
+    creator_detail: User
+    data: str
+    description: str
+    file_name: str
+    flags: Optional[list[FlagChange]]
+    id: int
+    is_obsolete: bool
+    is_patch: bool
+    is_private: bool
+    last_change_time: datetime
+    size: int
+    summary: str
+
+
+class AttachmentsCreateResponse(BaseModel):
+    attachments: Mapping[str, AttachmentCreateResponse]
 
 
 @dataclass
@@ -573,7 +617,7 @@ class Bugzilla:
 
     def create_attachment(
         self, attachment: AttachmentCreate, bug_id: Optional[int] = None
-    ) -> list[int]:
+    ) -> list[AttachmentCreateResponse]:
         """Add an attachment to one or more bugs"""
         if bug_id is not None:
             id_str = str(bug_id)
@@ -591,7 +635,7 @@ class Bugzilla:
         response = self.request("POST", path, json_body=json_body)
 
         if self.config.allow_writes:
-            create_result = AttachmentCreateResponse.model_validate(response)
-            return create_result.ids
+            create_result = AttachmentsCreateResponse.model_validate(response)
+            return list(create_result.attachments.values())
 
         return []

bugdantic-0.3.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.7 → bugdantic-0.3.0}/bugdantic.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: bugdantic
-Version: 0.2.7
+Version: 0.3.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.7 → bugdantic-0.3.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.7 → bugdantic-0.3.0}/pyproject.toml

@@ -5,10 +5,10 @@ authors = [
   {name = "James Graham", email = "james@hoppipolla.co.uk"}
 ]
 
-version = "0.2.7"
+version = "0.3.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.3.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
+"""
+    )