fastgpx 0.2.2__tar.gz → 0.4.0__tar.gz

{fastgpx-0.2.2 → fastgpx-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastgpx
-Version: 0.2.2
+Version: 0.4.0
 Summary: An experimental Python library for parsing GPX files fast.
 Keywords: gpx,parser,fast
 Author: Thomas Thomassen

{fastgpx-0.2.2 → fastgpx-0.4.0}/docs/source/conf.py

@@ -3,9 +3,12 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
+import re
 import os
 import sys
 import tomllib
+import logging as std_logging
+from sphinx.util import logging
 
 PROJECT_ROOT = os.path.abspath('../../')
 
@@ -49,3 +52,43 @@ autosummary_generate = True
 
 html_theme = 'sphinx_rtd_theme'
 html_static_path = ['_static']
+
+
+# -- Adjust formatting for overloaded methods --------------------------------
+
+logger = logging.getLogger(__name__)
+
+
+def format_overloaded_docstring(app, what, name, obj, options, lines):
+    logger.info(f"[fastgpx-doc] Processing docstring for {name}")
+    if not lines:
+        return
+
+    logger.info(f"[fastgpx-doc] First line: {lines[0]}")
+    if lines[0].strip().startswith("Overloaded function"):
+        logger.info(f"[fastgpx-doc] Detected overloaded function in {name}")
+
+        new_lines = [".. rubric:: Overloads", ""]
+
+        for line in lines[1:]:
+            match = re.match(r"^\d+\.\s+(.*)", line.strip())
+            if match:
+                new_lines.extend([
+                    ".. code-block:: python",
+                    "",
+                    f"    {match.group(1)}",
+                    ""
+                ])
+
+        lines.clear()
+        lines.extend(new_lines)
+
+
+def setup(app):
+    if app.verbosity >= 1:
+        logger.setLevel(std_logging.INFO)
+    else:
+        logger.setLevel(std_logging.WARNING)
+
+    logger.info("[fastgpx-doc] Setting up overloaded docstring formatting")
+    app.connect("autodoc-process-docstring", format_overloaded_docstring)

{fastgpx-0.2.2 → fastgpx-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "fastgpx"
-version = "0.2.2"
+version = "0.4.0"
 requires-python = ">=3.11"
 
 description = "An experimental Python library for parsing GPX files fast."

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/cpp/fastgpx/fastgpx.cpp

@@ -43,10 +43,14 @@ std::chrono::system_clock::time_point TimePoint::value() const
 
 bool TimeBounds::IsEmpty() const
 {
-  assert(start_time.has_value() == end_time.has_value());
   return !start_time.has_value() && !end_time.has_value();
 }
 
+bool TimeBounds::IsRange() const
+{
+  return start_time.has_value() && end_time.has_value();
+}
+
 void TimeBounds::Add(const std::chrono::system_clock::time_point time_point)
 {
   if (start_time.has_value())
@@ -380,6 +384,16 @@ Gpx ParseGpx(const std::filesystem::path& path)
   pugi::xml_node root = doc.child("gpx");
   Gpx gpx;
 
+  const auto metadata = root.child("metadata");
+  if (metadata)
+  {
+    const auto name = metadata.child("name");
+    if (name)
+    {
+      gpx.name.emplace(name.text().as_string());
+    }
+  }
+
   // Iterate over each <trk> element
   for (pugi::xml_node track = root.child("trk"); track; track = track.next_sibling("trk"))
   {

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/cpp/fastgpx/fastgpx.hpp

@@ -28,6 +28,7 @@ struct TimeBounds
   std::optional<std::chrono::system_clock::time_point> end_time = std::nullopt;
 
   bool IsEmpty() const;
+  bool IsRange() const;
 
   void Add(std::chrono::system_clock::time_point time_point);
   void Add(const TimeBounds& time_bounds);
@@ -111,6 +112,8 @@ private:
 struct Gpx
 {
   // <metadata>
+  std::optional<std::string> name; // <name>
+
   // <wpt>
   // <tre>
   std::vector<Track> tracks; // <trk>

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/cpp/fastgpx/fastgpx_test.cpp

@@ -33,6 +33,8 @@ TEST_CASE("Parse two-point single segment track", "[parse][simple]")
   REQUIRE(gpx.tracks.size() == 1);
   REQUIRE(gpx.tracks[0].segments.size() == 1);
 
+  CHECK(!gpx.name.has_value());
+
   CHECK_THAT(gpx.tracks[0].segments[0].GetLength2D(), WithinAbs(1.3839, kMETERS_TOL));
   CHECK_THAT(gpx.tracks[0].GetLength2D(), WithinAbs(1.3839, kMETERS_TOL));
   CHECK_THAT(gpx.GetLength2D(), WithinAbs(1.3839, kMETERS_TOL));
@@ -74,6 +76,8 @@ TEST_CASE("Parse time bounds of real world GPX file", "[parse][simple]")
       "gpx/2024 TopCamp/Connected_20240529_091916_Harald_Bothners_Veg_36_7052_Trondheim.gpx";
   const auto gpx = fastgpx::ParseGpx(path);
 
+  CHECK(gpx.name.value() == "Harald Bothners Veg 36, 7052 Trondheim");
+
   REQUIRE(gpx.tracks.size() == 1);
 
   // TimeBounds
@@ -97,6 +101,8 @@ TEST_CASE("Parse bounds of real world GPX file", "[parse][simple]")
       "gpx/2024 TopCamp/Connected_20240529_091916_Harald_Bothners_Veg_36_7052_Trondheim.gpx";
   const auto gpx = fastgpx::ParseGpx(path);
 
+  CHECK(gpx.name.value() == "Harald Bothners Veg 36, 7052 Trondheim");
+
   REQUIRE(gpx.tracks.size() == 1);
 
   const fastgpx::LatLong expected_min(61.841507, 9.090457);

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/cpp/python_fastgpx.cpp

@@ -53,7 +53,13 @@ PYBIND11_MODULE(fastgpx, m)
            py::arg("end_time"))
       .def_readwrite("start_time", &fastgpx::TimeBounds::start_time)
       .def_readwrite("end_time", &fastgpx::TimeBounds::end_time)
-      .def("is_empty", &fastgpx::TimeBounds::IsEmpty);
+      .def("is_empty", &fastgpx::TimeBounds::IsEmpty)
+      .def("is_range", &fastgpx::TimeBounds::IsRange)
+      .def("add",
+           py::overload_cast<std::chrono::system_clock::time_point>(&fastgpx::TimeBounds::Add),
+           py::arg("datetime"))
+      .def("add", py::overload_cast<const fastgpx::TimeBounds&>(&fastgpx::TimeBounds::Add),
+           py::arg("timebounds"));
 
   py::class_<fastgpx::LatLong>(m, "LatLong")
       .def(py::init<>())
@@ -197,6 +203,7 @@ PYBIND11_MODULE(fastgpx, m)
   py::class_<fastgpx::Gpx>(m, "Gpx")
       .def(py::init<>()) // Default constructor
       .def_readwrite("tracks", &fastgpx::Gpx::tracks)
+      .def_readwrite("name", &fastgpx::Gpx::name)
       .def("bounds", &fastgpx::Gpx::GetBounds)
       .def("get_bounds", &fastgpx::Gpx::GetBounds) // gpxpy compatiblity
       .def("time_bounds", &fastgpx::Gpx::GetTimeBounds)

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/cpp/python_utc_chrono.hpp

@@ -27,6 +27,15 @@
 namespace PYBIND11_NAMESPACE {
 namespace detail {
 
+inline std::time_t to_utc_time_t(std::tm* tm)
+{
+#if defined(_WIN32)
+  return _mkgmtime(tm);
+#else
+  return timegm(tm);
+#endif
+}
+
 template<typename type>
 class duration_caster
 {
@@ -195,7 +204,10 @@ public:
       return false;
     }
 
-    value = time_point_cast<Duration>(system_clock::from_time_t(std::mktime(&cal)) + msecs);
+    // HACK: Assume datetime.datetime objects are in UTC, so we use timegm instead of mktime.
+    // value = time_point_cast<Duration>(system_clock::from_time_t(std::mktime(&cal)) + msecs);
+    std::time_t tt = to_utc_time_t(&cal);
+    value = time_point_cast<Duration>(system_clock::from_time_t(tt) + msecs);
     return true;
   }
 

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/fastgpx/__init__.pyi

@@ -9,4 +9,4 @@ from fastgpx.fastgpx import geo
 from fastgpx.fastgpx import parse
 from fastgpx.fastgpx import polyline
 from . import fastgpx
-__all__ = ['Bounds', 'Gpx', 'LatLong', 'Segment', 'TimeBounds', 'Track', 'fastgpx', 'geo', 'parse', 'polyline']
+__all__: list = ['Bounds', 'Gpx', 'LatLong', 'Segment', 'TimeBounds', 'Track', 'geo', 'parse', 'polyline']

{fastgpx-0.2.2 → fastgpx-0.4.0}/src/fastgpx/fastgpx/__init__.pyi

@@ -51,6 +51,7 @@ class Bounds:
     def min_longitude(self, arg1: float) -> None:
         ...
 class Gpx:
+    name: str | None
     tracks: list[Track]
     def __init__(self) -> None:
         ...
@@ -101,8 +102,16 @@ class TimeBounds:
     @typing.overload
     def __init__(self, start_time: datetime.datetime | None, end_time: datetime.datetime | None) -> None:
         ...
+    @typing.overload
+    def add(self, datetime: datetime.datetime) -> None:
+        ...
+    @typing.overload
+    def add(self, timebounds: TimeBounds) -> None:
+        ...
     def is_empty(self) -> bool:
         ...
+    def is_range(self) -> bool:
+        ...
 class Track:
     comment: str | None
     description: str | None

{fastgpx-0.2.2 → fastgpx-0.4.0}/tests/test_fastgpx.py

@@ -1,7 +1,6 @@
 import datetime
 
 import gpxpy
-import gpxpy.gpx
 import pytest
 
 import fastgpx
@@ -53,6 +52,25 @@ def test_segment_length2d(gpx_path: str):
     distance = gpx.tracks[0].segments[0].length_2d()
     assert distance == pytest.approx(17809.2701, abs=METERS_TOL)
 
+# fastgpx.Gpx.name
+
+
+def test_gpx_name_missing():
+    path = 'gpx/test/debug-segment.gpx'
+    gpx = fastgpx.parse(path)
+    assert gpx.name is None
+
+
+def test_gpx_name_empty_string(gpx_path: str):
+    gpx = fastgpx.parse(gpx_path)
+    assert gpx.name == ''
+
+
+def test_gpx_name():
+    path = 'gpx/test/two-points.gpx'
+    gpx = fastgpx.parse(path)
+    assert gpx.name == 'Two Point Segment'
+
 # fastgpx.Gpx.bounds
 
 

fastgpx-0.4.0/tests/test_time_bounds.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+
+import fastgpx
+
+
+class TestTimeBounds:
+
+    def test_init_defaults(self):
+        bounds = fastgpx.TimeBounds()
+        assert bounds.is_empty()
+        assert not bounds.is_range()
+        assert bounds.start_time is None
+        assert bounds.end_time is None
+
+    def test_init_with_start_time(self):
+        start_time = datetime.fromisoformat("2025-06-20 08:07:28+00:00")
+        bounds = fastgpx.TimeBounds(start_time=start_time, end_time=None)
+        assert not bounds.is_empty()
+        assert not bounds.is_range()
+        assert bounds.start_time == start_time
+        assert bounds.end_time is None
+
+    def test_init_with_end_time(self):
+        end_time = datetime.fromisoformat("2025-06-27 13:37:00+00:00")
+        bounds = fastgpx.TimeBounds(start_time=None, end_time=end_time)
+        assert not bounds.is_empty()
+        assert not bounds.is_range()
+        assert bounds.start_time is None
+        assert bounds.end_time == end_time
+
+    def test_init_with_start_and_end_time(self):
+        start_time = datetime.fromisoformat("2025-06-20 08:07:28+00:00")
+        end_time = datetime.fromisoformat("2025-06-27 13:37:00+00:00")
+        bounds = fastgpx.TimeBounds(start_time=start_time, end_time=end_time)
+        assert not bounds.is_empty()
+        assert bounds.is_range()
+        assert bounds.start_time == start_time
+        assert bounds.end_time == end_time
+
+    def test_add_single_time_point(self):
+        bounds = fastgpx.TimeBounds()
+        time_point = datetime.fromisoformat("2025-06-20 08:07:28+00:00")
+        bounds.add(time_point)
+        assert not bounds.is_empty()
+        assert bounds.is_range()
+        assert bounds.start_time == time_point
+        assert bounds.end_time == time_point
+
+    def test_add_second_time_point(self):
+        bounds = fastgpx.TimeBounds()
+        time_point1 = datetime.fromisoformat("2025-06-20 08:07:28+00:00")
+        time_point2 = datetime.fromisoformat("2025-06-27 13:37:00+00:00")
+        bounds.add(time_point1)
+        bounds.add(time_point2)
+        assert not bounds.is_empty()
+        assert bounds.is_range()
+        assert bounds.start_time == time_point1
+        assert bounds.end_time == time_point2
+
+    def test_add_time_bounds(self):
+        bounds1 = fastgpx.TimeBounds(
+            start_time=datetime.fromisoformat("2025-06-20 08:07:28+00:00"),
+            end_time=datetime.fromisoformat("2025-06-27 13:37:00+00:00")
+        )
+        bounds2 = fastgpx.TimeBounds(
+            start_time=datetime.fromisoformat("2025-06-25 10:00:00+00:00"),
+            end_time=datetime.fromisoformat("2025-06-30 15:00:00+00:00")
+        )
+        bounds1.add(bounds2)
+        assert not bounds1.is_empty()
+        assert bounds1.is_range()
+        assert bounds1.start_time == bounds1.start_time
+        assert bounds1.end_time == bounds2.end_time

{fastgpx-0.2.2 → fastgpx-0.4.0}/uv.lock

@@ -97,7 +97,7 @@ wheels = [
 
 [[package]]
 name = "fastgpx"
-version = "0.0.1.dev0"
+version = "0.4.0"
 source = { editable = "." }
 
 [package.dev-dependencies]