fix: use correct poetry v2 person format

Author: mustafasoylu

src/somesy/pyproject/models.py

@@ -24,6 +24,13 @@
 logger = getLogger("somesy")
 
 
+class STPerson(BaseModel):
+    """Person model for setuptools."""
+
+    name: Annotated[str, Field(min_length=1)]
+    email: Annotated[Optional[str], Field(min_length=1)] = None
+
+
 class PoetryConfig(BaseModel):
     """Poetry configuration model."""
 
@@ -45,10 +52,13 @@ class PoetryConfig(BaseModel):
         Optional[Union[LicenseEnum, List[LicenseEnum]]],
         Field(description="An SPDX license identifier."),
     ]
-    authors: Annotated[Set[str], Field(description="Package authors")]
+
+    # v1 has str, v2 has STPerson
+    authors: Annotated[List[Union[str, STPerson]], Field(description="Package authors")]
     maintainers: Annotated[
-        Optional[Set[str]], Field(description="Package maintainers")
+        Optional[List[Union[str, STPerson]]], Field(description="Package maintainers")
     ] = None
+
     readme: Annotated[
         Optional[Union[Path, List[Path]]], Field(description="Package readme file(s)")
     ] = None
@@ -90,10 +100,17 @@ def validate_email_format(cls, v):
         validated = []
         for author in v:
             try:
-                if not (
-                    not isinstance(author, str)
-                    or " " not in author
-                    or not EMailAddress.validate_python(author.split(" ")[-1][1:-1])
+                if isinstance(author, STPerson) and author.email:
+                    if not EMailAddress.validate_python(author.email):
+                        logger.warning(
+                            f"Invalid email format for author/maintainer {author}, omitting."
+                        )
+                    else:
+                        validated.append(author)
+                        continue
+
+                if " " in author and EMailAddress.validate_python(
+                    author.split(" ")[-1][1:-1]
                 ):
                     validated.append(author)
                 else:
@@ -150,13 +167,6 @@ def validate_xor(cls, values):
         return values
 
 
-class STPerson(BaseModel):
-    """Person model for setuptools."""
-
-    name: Annotated[str, Field(min_length=1)]
-    email: Annotated[Optional[str], Field(min_length=1)] = None
-
-
 class URLs(BaseModel):
     """URLs model for setuptools."""
 

src/somesy/pyproject/writer.py

@@ -2,7 +2,7 @@
 
 import logging
 from pathlib import Path
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import tomlkit
 import wrapt
@@ -110,25 +110,49 @@ def __init__(
 
         See [somesy.core.writer.ProjectMetadataWriter.__init__][].
         """
+        self._poetry_version = version
+        v2_mappings = {
+            "homepage": ["urls", "homepage"],
+            "repository": ["urls", "repository"],
+            "documentation": ["urls", "documentation"],
+        }
         if version == 1:
-            section = ["tool", "poetry"]
+            super().__init__(
+                path,
+                section=["tool", "poetry"],
+                model_cls=PoetryConfig,
+                pass_validation=pass_validation,
+            )
         else:
-            section = ["project"]
-        super().__init__(
-            path,
-            section=section,
-            model_cls=PoetryConfig,
-            pass_validation=pass_validation,
-        )
+            super().__init__(
+                path,
+                section=["project"],
+                model_cls=PoetryConfig,
+                pass_validation=pass_validation,
+                direct_mappings=v2_mappings,
+            )
 
     @staticmethod
-    def _from_person(person: Union[Person, Entity]):
+    def _from_person(person: Union[Person, Entity], poetry_version: int = 1):
         """Convert project metadata person object to poetry string for person format "full name <email>."""
-        return person.to_name_email_string()
+        if poetry_version == 1:
+            return person.to_name_email_string()
+        else:
+            response = {"name": person.full_name}
+            if person.email:
+                response["email"] = person.email
+            return response
 
     @staticmethod
-    def _to_person(person: str) -> Optional[Union[Person, Entity]]:
+    def _to_person(
+        person: Union[str, Dict[str, str]],
+    ) -> Optional[Union[Person, Entity]]:
         """Convert from free string to person or entity object."""
+        if isinstance(person, dict):
+            temp = str(person["name"])
+            if "email" in person:
+                temp = f"{temp} <{person['email']}>"
+            person = temp
         try:
             return Person.from_name_email_string(person)
         except (ValueError, AttributeError):
@@ -140,6 +164,41 @@ def _to_person(person: str) -> Optional[Union[Person, Entity]]:
             logger.warning(f"Cannot convert {person} to Entity.")
             return None
 
+    def sync(self, metadata: ProjectMetadata) -> None:
+        """Sync metadata with pyproject.toml file."""
+        # Store original _from_person method
+        original_from_person = self._from_person
+
+        # Override _from_person to include poetry_version
+        self._from_person = lambda person: original_from_person(  # type: ignore
+            person, poetry_version=self._poetry_version
+        )
+
+        # Call parent sync method
+        super().sync(metadata)
+
+        # Restore original _from_person method
+        self._from_person = original_from_person  # type: ignore
+
+        # For Poetry v2, convert authors and maintainers from array of tables to inline tables
+        if self._poetry_version == 2:
+            for field in ["authors", "maintainers"]:
+                field_value = self._get_property([field])
+                if field_value:
+                    # Create an inline array of tables
+                    inline_array = tomlkit.array()
+                    inline_array.multiline(False)
+
+                    # Convert each table to an inline table and add to array
+                    for item in field_value:
+                        inline_table = tomlkit.inline_table()
+                        for k, v in item.items():
+                            inline_table[k] = v
+                        inline_array.append(inline_table)
+
+                    # Replace the array of tables with the inline array
+                    self._set_property(field, inline_array)
+
 
 class SetupTools(PyprojectCommon):
     """Setuptools config file handler parsed from setup.cfg."""

tests/data/pyproject2.toml

@@ -2,11 +2,8 @@
 name = "test-package"
 version = "0.1.0"
 description = "This is a test package for demonstration purposes."
-authors = ["John Doe <john.doe@example.com>"]
+authors = [{ "name" = "John Doe", "email" = "john.doe@example.com" }]
 license = "MIT"
-repository = "https://github.com/example/test-package"
-homepage = "https://example.com/test-package"
-documentation = "https://example.com/test-package"
 keywords = ["test", "demo", "example"]
 classifiers = [
     "Operating System :: POSIX :: Linux",
@@ -16,6 +13,11 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Application Frameworks",
 ]
 
+[project.urls]
+homepage = "https://example.com/test-package"
+repository = "https://github.com/example/test-package"
+documentation = "https://example.com/test-package"
+
 [tool.poetry.dependencies]
 python = "^3.8"
 pydantic = "^1.10.2"

tests/output/test_pyproject_writer.py

@@ -166,8 +166,12 @@ def test_person_merge_pyproject(
     pj.save()
 
     # existing author info preserved, order not preserved because no orcid
-    person1b_rep = writer_class._from_person(person1b)
-    person2_rep = writer_class._from_person(person2)
+    if version is not None:
+        person1b_rep = writer_class._from_person(person1b, poetry_version=version)
+        person2_rep = writer_class._from_person(person2, poetry_version=version)
+    else:
+        person1b_rep = writer_class._from_person(person1b)
+        person2_rep = writer_class._from_person(person2)
     assert (pj.authors[0] == person1b_rep) or (pj.authors[1] == person1b_rep)
     assert (pj.authors[0] == person2_rep) or (pj.authors[1] == person2_rep)
 
@@ -181,11 +185,17 @@ def test_person_merge_pyproject(
             "publication_author": True,
         }
     )
-    person3_rep = writer_class._from_person(person3)
+    if version is not None:
+        person3_rep = writer_class._from_person(person3, poetry_version=version)
+    else:
+        person3_rep = writer_class._from_person(person3)
 
     # john has a new email address
     person1c = person1b.model_copy(update={"email": "john.of.us@qualityland.com"})
-    person1c_rep = writer_class._from_person(person1c)
+    if version is not None:
+        person1c_rep = writer_class._from_person(person1c, poetry_version=version)
+    else:
+        person1c_rep = writer_class._from_person(person1c)
 
     # jane 2 is removed from authors, but added to maintainers
     person2.author = False