disable error raise on users without email in poetry

Author: mustafasoylu

src/somesy/pyproject/models.py

@@ -1,6 +1,7 @@
 """Pyproject models."""
 
 from enum import Enum
+from logging import getLogger
 from pathlib import Path
 from typing import Dict, List, Optional, Set, Union
 
@@ -10,6 +11,7 @@
     EmailStr,
     Field,
     TypeAdapter,
+    ValidationError,
     field_validator,
     model_validator,
 )
@@ -19,6 +21,7 @@
 from somesy.core.types import HttpUrlStr
 
 EMailAddress = TypeAdapter(EmailStr)
+logger = getLogger("somesy")
 
 
 class PoetryConfig(BaseModel):
@@ -81,26 +84,38 @@ def validate_version(cls, v):
     @field_validator("authors", "maintainers")
     @classmethod
     def validate_email_format(cls, v):
-        """Validate email format."""
+        """Validate person format, omit person that is not in correct format, don't raise an error."""
+        if v is None:
+            return []
+        validated = []
         for author in v:
-            if (
-                not isinstance(author, str)
-                or " " not in author
-                or not EMailAddress.validate_python(author.split(" ")[-1][1:-1])
-            ):
-                raise ValueError("Invalid email format")
-        return v
+            try:
+                if not (
+                    not isinstance(author, str)
+                    or " " not in author
+                    or not EMailAddress.validate_python(author.split(" ")[-1][1:-1])
+                ):
+                    validated.append(author)
+                else:
+                    logger.warning(
+                        f"Invalid email format for author/maintainer {author}, omitting."
+                    )
+            except ValidationError:
+                logger.warning(
+                    f"Invalid email format for author/maintainer {author}, omitting."
+                )
+        return validated
 
     @field_validator("readme")
     @classmethod
     def validate_readme(cls, v):
         """Validate readme file(s) by checking whether files exist."""
         if isinstance(v, list):
             if any(not e.is_file() for e in v):
-                raise ValueError("Some file(s) do not exist")
+                logger.warning("Some readme file(s) do not exist")
         else:
             if not v.is_file():
-                raise ValueError("File does not exist")
+                logger.warning("Readme file does not exist")
 
 
 class ContentTypeEnum(Enum):

src/somesy/pyproject/writer.py

@@ -96,6 +96,52 @@ def __init__(self, path: Path):
         """
         super().__init__(path, section=["tool", "poetry"], model_cls=PoetryConfig)
 
+    @property
+    def authors(self) -> List[str]:
+        """Get authors from the pyproject.toml file."""
+        # check if authors can be converted to person, only return valid ones
+        authors = self._get_property("authors")
+        if authors is None:
+            return []
+
+        valid_authors = []
+        for author in authors:
+            try:
+                self._to_person(author)
+                valid_authors.append(author)
+            except (ValueError, AttributeError):
+                logger.warning(f"Invalid author format: {author}")
+        return valid_authors
+
+    @authors.setter
+    def authors(self, authors: List[Person]) -> None:
+        """Set the authors of the project."""
+        authors = [self._from_person(c) for c in authors]
+        self._set_property(self._get_key("authors"), authors)
+
+    @property
+    def maintainers(self) -> List[str]:
+        """Get maintainers from the pyproject.toml file."""
+        # check if maintainers can be converted to person, only return valid ones
+        maintainers = self._get_property("maintainers")
+        if maintainers is None:
+            return []
+
+        valid_maintainers = []
+        for maintainer in maintainers:
+            try:
+                self._to_person(maintainer)
+                valid_maintainers.append(maintainer)
+            except (ValueError, AttributeError):
+                logger.warning(f"Invalid maintainer format: {maintainer}")
+        return valid_maintainers
+
+    @maintainers.setter
+    def maintainers(self, maintainers: List[Person]) -> None:
+        """Set the maintainers of the project."""
+        maintainers = [self._from_person(c) for c in maintainers]
+        self._set_property(self._get_key("maintainers"), maintainers)
+
     @staticmethod
     def _from_person(person: Person):
         """Convert project metadata person object to poetry string for person format "full name <email>."""

tests/output/test_pyproject_writer.py

@@ -77,6 +77,9 @@ def test_from_to_person(person):
     assert p.full_name == person.full_name
     assert p.email == person.email
 
+    with pytest.raises(AttributeError):
+        p = Poetry._to_person("John Doe")
+
     # test for setuptools
     assert SetupTools._from_person(person) == {
         "name": person.full_name,
@@ -165,3 +168,47 @@ def test_person_merge_pyproject(request, writer_class, writer_file_fixture, pers
     assert len(pj.maintainers) == 1
     assert pj.authors[0] == person1c_rep
     assert pj.authors[1] == person3_rep
+
+
+def test_without_email(tmp_path, person):
+    pyproject_str = """
+    [tool.poetry]
+    name = "ttt"
+    version = "0.1.0"
+    description = "asd"
+    authors = ["John Doe"]
+    license = "MIT"
+
+    [tool.poetry.dependencies]
+    python = "^3.10"
+
+
+    [build-system]
+    requires = ["poetry-core"]
+    build-backend = "poetry.core.masonry.api"
+    """
+
+    # save to file
+    pyproject_file = tmp_path / Path("pyproject.toml")
+    pyproject_file.write_text(pyproject_str)
+
+    # load and sync
+    p = Poetry(pyproject_file)
+    assert len(p.authors) == 0
+
+    pm = ProjectMetadata(
+        name="My awesome project",
+        description="Project description",
+        license=LicenseEnum.MIT,
+        version="0.1.0",
+        people=[
+            person.model_copy(
+                update=dict(author=True, publication_author=True, maintainer=True)
+            )
+        ],
+    )
+
+    p.sync(pm)
+
+    assert len(p.authors) == 1
+    assert len(p.maintainers) == 1