aio_taginfo

10class TaginfoError(Exception):
11    """Base class for taginfo API errors."""

43async def call(
44    key: str,
45    session: ClientSession | None = None,
46) -> Response[list[KeyChronology]]:
47    """
48    Get chronology of key counts.
49
50    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_chronology
51
52    Args:
53        key: tag key
54        session: request client session
55
56    Raises:
57        TaginfoError
58    """
59    return await api_get_json(
60        path="key/chronology",
61        cls=Response[list[KeyChronology]],
62        session=session,
63        params=api_params(_Params, key=key),
64    )

 58async def call(
 59    key: str,
 60    query: str | None = None,
 61    sortname: KeyCombinationSorting = KeyCombinationSorting.TOGETHER_COUNT,
 62    sortorder: SortOrder = SortOrder.DESC,
 63    filter: ObjectType = ObjectType.ALL,  # noqa: A002
 64    page: int = 1,
 65    rp: int = 0,
 66    session: ClientSession | None = None,
 67) -> Response[list[KeyCombination]]:
 68    """
 69    Find keys that are used together with a given key.
 70
 71    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_combinations
 72
 73    Args:
 74        key: tag key
 75        query: only show results where the ``other_key`` matches this query (substring match)
 76        sortname: what field to sort by
 77        sortorder: sort order
 78        filter: can be used to filter only values on tags used on nodes/ways/relations
 79        page: page number (starting at 1)
 80        rp: results per page
 81        session: request client session
 82
 83    Raises:
 84        TaginfoError
 85    """
 86    params = api_params(
 87        _Params,
 88        key=key,
 89        query=query,
 90        sortname=sortname,
 91        sortorder=sortorder,
 92        filter=filter,
 93        page=page,
 94        rp=rp,
 95    )
 96    return await api_get_json(
 97        path="key/combinations",
 98        cls=Response[list[KeyCombination]],
 99        session=session,
100        params=params,
101    )

20async def call(key: str, session: ClientSession | None = None) -> PngResponse:
21    """
22    Get map with distribution of this key in the database (nodes only).
23
24    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_distribution_nodes
25
26    Args:
27        key: tag key
28        session: request client session
29
30    Raises:
31        TaginfoError
32    """
33    params = api_params(_Params, key=key)
34    return await api_get_png(
35        path="/api/4/key/distribution/nodes",
36        session=session,
37        params=params,
38    )

20async def call(key: str, session: ClientSession | None = None) -> PngResponse:
21    """
22    Get map with distribution of this key in the database (ways only).
23
24    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_distribution_ways
25
26    Args:
27        key: tag key
28        session: request client session
29
30    Raises:
31        TaginfoError
32    """
33    params = api_params(_Params, key=key)
34    return await api_get_png(
35        path="/api/4/key/distribution/ways",
36        session=session,
37        params=params,
38    )

28async def call(
29    key: str,
30    session: ClientSession | None = None,
31) -> Response["KeyOverview"]:
32    """
33    Show various data for given key.
34
35    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_overview
36
37    Args:
38        key: tag key
39        session: request client session
40
41    Raises:
42        TaginfoError
43    """
44    return await api_get_json(
45        path="key/overview",
46        cls=Response[KeyOverview],
47        session=session,
48        params=api_params(_Params, key=key),
49    )

41async def call(
42    key: str,
43    min_fraction: float = 0.01,
44    filter: ObjectType = ObjectType.ALL,  # noqa: A002
45    session: ClientSession | None = None,
46) -> Response[list[PrevalentValue]]:
47    """
48    Get most prevalent values used with a given key.
49
50    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_prevalent_values
51
52    Args:
53        key: tag key
54        min_fraction: only return values which are used in at least this percent
55                      of all objects with this key (defaults to 0.01)
56        filter: can be used to filter only values on tags used on nodes/ways/relations
57        session: request client session
58
59    Raises:
60        TaginfoError
61    """
62    params = api_params(_Params, key=key, min_fraction=min_fraction, filter=filter)
63    return await api_get_json(
64        path="key/prevalent_values",
65        cls=Response[list[PrevalentValue]],
66        session=session,
67        params=params,
68    )

 79async def call(
 80    key: str,
 81    query: str | None = None,
 82    sortname: KeyProjectSorting = KeyProjectSorting.PROJECT_NAME,
 83    sortorder: SortOrder = SortOrder.ASC,
 84    filter: ObjectType = ObjectType.ALL,  # noqa: A002
 85    page: int = 1,
 86    rp: int = 0,
 87    session: ClientSession | None = None,
 88) -> Response[list[KeyProject]]:
 89    """
 90    Get projects using a given key.
 91
 92    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_projects
 93
 94    Args:
 95        key: tag key
 96        query: only show results where the project name or tag value matches this query
 97               (substring match)
 98        sortname: what field to sort by
 99        sortorder: sort order
100        filter: can be used to filter only values on tags used on nodes/ways/relations
101        page: page number (starting at 1)
102        rp: results per page
103        session: request client session
104
105    Raises:
106        TaginfoError
107    """
108    params = api_params(
109        _Params,
110        key=key,
111        query=query,
112        sortname=sortname,
113        sortorder=sortorder,
114        filter=filter,
115        page=page,
116        rp=rp,
117    )
118    return await api_get_json(
119        path="key/projects",
120        cls=Response[list[KeyProject]],
121        session=session,
122        params=params,
123    )

55async def call(
56    key: str,
57    query: str | None = None,
58    sortname: SimilarKeySorting = SimilarKeySorting.OTHER_KEY,
59    sortorder: SortOrder = SortOrder.ASC,
60    page: int = 1,
61    rp: int = 0,
62    session: ClientSession | None = None,
63) -> Response[list[SimilarKey]]:
64    """
65    Find keys that are similar to a given key.
66
67    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_similar
68
69    Args:
70        key: tag key
71        query: only show results where the ``other_key`` matches this query (substring match)
72        sortname: what field to sort by
73        sortorder: sort order
74        page: page number (starting at 1)
75        rp: results per page
76        session: request client session
77
78    Raises:
79        TaginfoError
80    """
81    params = api_params(
82        _Params, key=key, query=query, sortname=sortname, sortorder=sortorder, page=page, rp=rp
83    )
84    return await api_get_json(
85        path="key/similar",
86        cls=Response[list[SimilarKey]],
87        session=session,
88        params=params,
89    )

41async def call(
42    key: str,
43    session: ClientSession | None = None,
44) -> Response[list[KeyStats]]:
45    """
46    Show some database statistics for given key.
47
48    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_key_stats
49
50    Args:
51        key: tag key
52        session: request client session
53
54    Raises:
55        TaginfoError
56    """
57    return await api_get_json(
58        path="key/stats",
59        cls=Response[list[KeyStats]],
60        session=session,
61        params=api_params(_Params, key=key),
62    )

 67async def call(
 68    rtype: str,
 69    query: str | None = None,
 70    sortname: RelationProjectSorting = RelationProjectSorting.PROJECT_NAME,
 71    sortorder: SortOrder = SortOrder.ASC,
 72    page: int = 1,
 73    rp: int = 0,
 74    session: ClientSession | None = None,
 75) -> Response[list[RelationProject]]:
 76    """
 77    Get projects using a given relation type.
 78
 79    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_relation_projects
 80
 81    Args:
 82        rtype: Relation type
 83        query: Only show results where the value matches this query (substring match)
 84        sortname: what field to sort by
 85        sortorder: sort order
 86        page: page number (starting at 1)
 87        rp: results per page
 88        session: request client session
 89
 90    Raises:
 91        TaginfoError
 92    """
 93    params = api_params(
 94        _Params,
 95        rtype=rtype,
 96        query=query,
 97        sortname=sortname,
 98        sortorder=sortorder,
 99        page=page,
100        rp=rp,
101    )
102    return await api_get_json(
103        path="relation/projects",
104        cls=Response[list[RelationProject]],
105        session=session,
106        params=params,
107    )

17async def call(session: ClientSession | None = None) -> "SiteConfigGeodistribution":
18    """
19    Get information about the background map for distribution charts.
20
21    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_site_config_geodistribution
22
23    Args:
24        session: request client session
25
26    Raises:
27        TaginfoError
28    """
29    return await api_get_json(
30        path="/api/4/site/config/geodistribution",
31        cls=SiteConfigGeodistribution,
32        session=session,
33    )

 80async def call(
 81    key: str,
 82    value: str,
 83    query: str | None = None,
 84    sortname: TagProjectSorting = TagProjectSorting.PROJECT_NAME,
 85    sortorder: SortOrder = SortOrder.ASC,
 86    filter: ObjectType = ObjectType.ALL,  # noqa: A002
 87    page: int = 1,
 88    rp: int = 0,
 89    session: ClientSession | None = None,
 90) -> Response[list[TagProject]]:
 91    """
 92    Get projects using a given tag.
 93
 94    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_tag_projects
 95
 96    Args:
 97        key: tag key
 98        value: tag value
 99        query: Only show results where the project name matches this query (substring match)
100        sortname: what field to sort by
101        sortorder: sort order
102        filter: can be used to filter only values on tags used on nodes/ways/relations
103        page: page number (starting at 1)
104        rp: results per page
105        session: request client session
106
107    Raises:
108        TaginfoError
109    """
110    params = api_params(
111        _Params,
112        key=key,
113        value=value,
114        query=query,
115        sortname=sortname,
116        sortorder=sortorder,
117        filter=filter,
118        page=page,
119        rp=rp,
120    )
121    return await api_get_json(
122        path="tag/projects",
123        cls=Response[list[TagProject]],
124        session=session,
125        params=params,
126    )

 86async def call(
 87    query: str | None = None,
 88    sortname: PopularTagSorting = PopularTagSorting.COUNT_ALL,
 89    sortorder: SortOrder = SortOrder.DESC,
 90    page: int = 1,
 91    rp: int = 0,
 92    session: ClientSession | None = None,
 93) -> Response[list[PopularTag]]:
 94    """
 95    Get list of most often used tags.
 96
 97    https://taginfo.openstreetmap.org/taginfo/apidoc#api_4_tags_popular
 98
 99    Args:
100        query: only show results where ``key`` or ``value`` matches this query (substring match)
101        sortname: what field to sort by
102        sortorder: sort order
103        page: page number (starting at 1)
104        rp: results per page
105        session: request client session
106
107    Raises:
108        TaginfoError
109    """
110    params = api_params(
111        _Params, query=query, sortname=sortname, sortorder=sortorder, page=page, rp=rp
112    )
113    return await api_get_json(
114        path="tags/popular",
115        cls=Response[list[PopularTag]],
116        session=session,
117        params=params,
118    )