add type annotations for additional osm functions

Author: lonvia

src/osmium/osm/__init__.py

@@ -1,43 +1,24 @@
-import osmium.osm.mutable
+from typing import Any, Callable, Sequence
+
+from osmium.osm.mutable import create_mutable_node, create_mutable_way, create_mutable_relation
 from ._osm import *
 
-def create_mutable_node(node, **args):
-    """ Create a mutable node replacing the properties given in the
-        named parameters. Note that this function only creates a shallow
-        copy which is still bound to the scope of the original object.
-    """
-    return osmium.osm.mutable.Node(base=node, **args)
-
-def create_mutable_way(way, **args):
-    """ Create a mutable way replacing the properties given in the
-        named parameters. Note that this function only creates a shallow
-        copy which is still bound to the scope of the original object.
-    """
-    return osmium.osm.mutable.Way(base=way, **args)
-
-def create_mutable_relation(rel, **args):
-    """ Create a mutable relation replacing the properties given in the
-        named parameters. Note that this function only creates a shallow
-        copy which is still bound to the scope of the original object.
-    """
-    return osmium.osm.mutable.Relation(base=rel, **args)
-
-Node.replace = create_mutable_node
-Way.replace = create_mutable_way
-Relation.replace = create_mutable_relation
-
-def _make_repr(*attr_list):
+setattr(Node, 'replace', create_mutable_node)
+setattr(Way, 'replace', create_mutable_way)
+setattr(Relation, 'replace', create_mutable_relation)
+
+def _make_repr(*attrs: str) -> Callable[[object], str]:
     fmt_string = 'osmium.osm.{0}('\
-                 + ', '.join([f'{x}={{1.{x}!r}}' for x in attr_list])\
+                 + ', '.join([f'{x}={{1.{x}!r}}' for x in attrs])\
                  + ')'
 
     return lambda o: fmt_string.format(o.__class__.__name__, o)
 
-def _list_repr(obj):
+def _list_repr(obj: Sequence[Any]) -> str:
     return 'osmium.osm.{}([{}])'.format(obj.__class__.__name__,
                                         ', '.join(map(repr, obj)))
 
-def _list_elipse(obj):
+def _list_elipse(obj: Sequence[Any]) -> str:
     objects = ','.join(map(str, obj))
     if len(objects) > 50:
         objects = objects[:47] + '...'

src/osmium/osm/mutable.py

@@ -1,4 +1,21 @@
-class OSMObject(object):
+from typing import Optional, Union, Any, Mapping, Sequence, Tuple, TYPE_CHECKING
+from datetime import datetime
+
+if TYPE_CHECKING:
+    import osmium.osm
+
+    OSMObjectLike = Union['OSMObject', osmium.osm.OSMObject]
+    NodeLike = Union[Node, osmium.osm.Node]
+    WayLike = Union[Way, osmium.osm.Way]
+    RelationLike = Union[Relation, osmium.osm.Relation]
+
+    TagSequence = Union[osmium.osm.TagList, Mapping[str, str], Sequence[Tuple[str, str]]]
+    LocationLike = Union[osmium.osm.Location, Tuple[float, float]]
+    NodeSequence = Union[osmium.osm.NodeRefList, Sequence[Union[osmium.osm.NodeRef, int]]]
+    MemberSequence = Union[osmium.osm.RelationMemberList,
+                       Sequence[Union[osmium.osm.RelationMember, Tuple[str, int, str]]]]
+
+class OSMObject:
     """Mutable version of ``osmium.osm.OSMObject``. It exposes the following
        attributes ``id``, ``version``, ``visible``, ``changeset``, ``timestamp``,
        ``uid`` and ``tags``. Timestamps may be strings or datetime objects.
@@ -9,8 +26,11 @@ class OSMObject(object):
        will be initialised first from the attributes of this base object.
     """
 
-    def __init__(self, base=None, id=None, version=None, visible=None, changeset=None,
-                 timestamp=None, uid=None, tags=None, user=None):
+    def __init__(self, base: Optional['OSMObjectLike'] = None,
+                 id: Optional[int] = None, version: Optional[int] = None,
+                 visible: Optional[bool] = None, changeset: Optional[int] = None,
+                 timestamp: Optional[datetime] = None, uid: Optional[int] = None,
+                 tags: Optional['TagSequence'] = None, user: Optional[str] = None) -> None:
         if base is None:
             self.id = id
             self.version = version
@@ -37,7 +57,9 @@ class Node(OSMObject):
        may either be an `osmium.osm.Location` or a tuple of lon/lat coordinates.
     """
 
-    def __init__(self, base=None, location=None, **attrs):
+    def __init__(self, base: Optional['NodeLike'] = None,
+                 location: Optional['LocationLike'] = None,
+                 **attrs: Any) -> None:
         OSMObject.__init__(self, base=base, **attrs)
         if base is None:
             self.location = location
@@ -52,7 +74,8 @@ class Way(OSMObject):
        ``osmium.osm.NodeRef`` or simple node ids.
     """
 
-    def __init__(self, base=None, nodes=None, **attrs):
+    def __init__(self, base: Optional['WayLike'] = None,
+                 nodes: Optional['NodeSequence'] = None, **attrs: Any) -> None:
         OSMObject.__init__(self, base=base, **attrs)
         if base is None:
             self.nodes = nodes
@@ -67,9 +90,33 @@ class Relation(OSMObject):
        member type should be a single character 'n', 'w' or 'r'.
     """
 
-    def __init__(self, base=None, members=None, **attrs):
+    def __init__(self, base: Optional['RelationLike'] = None,
+                 members: Optional['MemberSequence'] = None, **attrs: Any) -> None:
         OSMObject.__init__(self, base=base, **attrs)
         if base is None:
             self.members = members
         else:
             self.members = members if members is not None else base.members
+
+
+def create_mutable_node(node: 'NodeLike', **args: Any) -> Node:
+    """ Create a mutable node replacing the properties given in the
+        named parameters. Note that this function only creates a shallow
+        copy which is still bound to the scope of the original object.
+    """
+    return Node(base=node, **args)
+
+def create_mutable_way(way: 'WayLike', **args: Any) -> Way:
+    """ Create a mutable way replacing the properties given in the
+        named parameters. Note that this function only creates a shallow
+        copy which is still bound to the scope of the original object.
+    """
+    return Way(base=way, **args)
+
+def create_mutable_relation(rel: 'RelationLike', **args: Any) -> Relation:
+    """ Create a mutable relation replacing the properties given in the
+        named parameters. Note that this function only creates a shallow
+        copy which is still bound to the scope of the original object.
+    """
+    return Relation(base=rel, **args)
+