1.0.0 release candidate 2

.github/workflows/run-all-tests.yml

@@ -2,7 +2,7 @@
 # run tests and lint with a variety of Python versions
 ---
 name: Tests
 on: [push, pull_request]
 
 jobs:
   cpython:
@@ -46,7 +46,7 @@
           pytest tests --cov=fastkml --cov=tests --cov-fail-under=95 --cov-report=xml
       - name: "Upload coverage to Codecov"
         if: ${{ matrix.python-version==3.11 }}
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           fail_ci_if_error: true
           verbose: true

fastkml/about.py

@@ -19,6 +19,6 @@
 The only purpose of this module is to provide a version number for the package.
 """
 
-__version__ = "1.0.0rc1"
+__version__ = "1.0.0rc2"
 
 __all__ = ["__version__"]

fastkml/base.py

@@ -189,20 +189,16 @@ def to_string(
                 str,
                 config.etree.tostring(
                     element,
-                    encoding="UTF-8",
+                    encoding="unicode",
                     pretty_print=prettyprint,
-                ).decode(
-                    "UTF-8",
                 ),
             )
         except TypeError:
             return cast(
                 str,
                 config.etree.tostring(
                     element,
-                    encoding="UTF-8",
-                ).decode(
-                    "UTF-8",
+                    encoding="unicode",
                 ),
             )
 

fastkml/helpers.py

@@ -1092,23 +1092,24 @@ def datetime_subelement_kwarg(
     kwarg: str,
     classes: Tuple[Type[object], ...],
     strict: bool,
-) -> Dict[str, List["KmlDateTime"]]:
+) -> Dict[str, "KmlDateTime"]:
     """Extract a KML datetime from a subelement of an XML element."""
     cls = classes[0]
     node = element.find(f"{ns}{node_name}")
     if node is None:
         return {}
     node_text = node.text.strip() if node.text else ""
     if node_text:
-        if kdt := cls.parse(node_text):  # type: ignore[attr-defined]
-            return {kwarg: kdt}
-        handle_error(
-            error=ValueError(f"Invalid DateTime value: {node_text}"),
-            strict=strict,
-            element=element,
-            node=node,
-            expected="DateTime",
-        )
+        try:
+            return {kwarg: cls.parse(node_text)}  # type: ignore[attr-defined]
+        except ValueError as exc:
+            handle_error(
+                error=exc,
+                strict=strict,
+                element=element,
+                node=node,
+                expected="DateTime",
+            )
     return {}
 
 

fastkml/kml.py

@@ -27,6 +27,7 @@
 """
 
 import logging
+import zipfile
 from pathlib import Path
 from typing import IO
 from typing import Any
@@ -244,6 +245,48 @@ def parse(
             element=root,
         )
 
+    def write(
+        self,
+        file_path: Path,
+        *,
+        prettyprint: bool = True,
+        precision: Optional[int] = None,
+        verbosity: Verbosity = Verbosity.normal,
+    ) -> None:
+        """
+        Write KML to a file.
+
+        Args:
+        ----
+            file_path: The file name where to save the file.
+                Can be any string value
+            prettyprint : bool, default=True
+                Whether to pretty print the XML.
+            precision (Optional[int]): The precision used for floating-point values.
+            verbosity (Verbosity): The verbosity level for generating the KML element.
+
+        """
+        element = self.etree_element(precision=precision, verbosity=verbosity)
+
+        try:
+            xml_content = config.etree.tostring(
+                element,
+                encoding="unicode",
+                pretty_print=prettyprint,
+            )
+        except TypeError:
+            xml_content = config.etree.tostring(
+                element,
+                encoding="unicode",
+            )
+
+        if file_path.suffix == ".kmz":
+            with zipfile.ZipFile(file_path, "w", zipfile.ZIP_DEFLATED) as kmz:
+                kmz.writestr("doc.kml", xml_content)
+        else:
+            with file_path.open("w", encoding="UTF-8") as file:
+                file.write(xml_content)
+
 
 registry.register(
     KML,

fastkml/times.py

@@ -45,7 +45,7 @@
 
 # regular expression to parse a gYearMonth string
 # year and month may be separated by an optional dash
-# year is always 4 digits, month is always 2 digits
+# year is always 4 digits, month, day is always 2 digits
 year_month_day = re.compile(
     r"^(?P<year>\d{4})(?:-)?(?P<month>\d{2})?(?:-)?(?P<day>\d{2})?$",
 )
@@ -205,10 +205,8 @@ def parse(cls, datestr: str) -> Optional["KmlDateTime"]:
                 resolution = DateTimeResolution.year_month
             if year_month_day_match.group("month") is None:
                 resolution = DateTimeResolution.year
-        elif len(datestr) > 10:  # noqa: PLR2004
-            dt = arrow.get(datestr).datetime
-            resolution = DateTimeResolution.datetime
-        return cls(dt, resolution) if dt else None
+            return cls(dt, resolution)
+        return cls(arrow.get(datestr).datetime, DateTimeResolution.datetime)
 
     @classmethod
     def get_ns_id(cls) -> str:

fastkml/utils.py

@@ -30,6 +30,32 @@ def has_attribute_values(obj: object, **kwargs: Any) -> bool:
         return False
 
 
+def get_all_attrs(obj: object) -> Generator[object, None, None]:
+    """
+    Get all attributes of an object.
+
+    Args:
+    ----
+        obj: The object to get attributes from.
+
+    Returns:
+    -------
+        An iterable of all attributes of the object or, if the attribute itself is
+            iterable, iterate over the attribute values.
+
+    """
+    try:
+        attrs = (attr for attr in obj.__dict__ if not attr.startswith("_"))
+    except AttributeError:
+        return
+    for attr_name in attrs:
+        attr = getattr(obj, attr_name)
+        try:
+            yield from attr
+        except TypeError:
+            yield attr
+
+
 def find_all(
     obj: object,
     *,
@@ -55,17 +81,9 @@ def find_all(
         **kwargs,
     ):
         yield obj
-    try:
-        attrs = (attr for attr in obj.__dict__ if not attr.startswith("_"))
-    except AttributeError:
-        return
-    for attr_name in attrs:
-        attr = getattr(obj, attr_name)
-        try:
-            for item in attr:
-                yield from find_all(item, of_type=of_type, **kwargs)
-        except TypeError:
-            yield from find_all(attr, of_type=of_type, **kwargs)
+
+    for attr in get_all_attrs(obj):
+        yield from find_all(attr, of_type=of_type, **kwargs)
 
 
 def find(

tests/atom_test.py

@@ -25,11 +25,9 @@ class TestStdLibrary(StdLibrary):
     """Test with the standard library."""
 
     def test_atom_link_ns(self) -> None:
-        ns = "{http://www.opengis.net/kml/2.2}"
-        link = atom.Link(ns=ns)
-        assert link.ns == ns
+        link = atom.Link()
         assert link.to_string().startswith(
-            '<kml:link xmlns:kml="http://www.opengis.net/kml/2.2"',
+            '<atom:link xmlns:atom="http://www.w3.org/2005/Atom"',
         )
 
     def test_atom_link(self) -> None: