jageocoder 2.1.7.dev2__tar.gz → 2.1.7rc1__tar.gz

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jageocoder
-Version: 2.1.7.dev2
+Version: 2.1.7rc1
 Summary: A Japanese-address geocoder for Python.
 Home-page: https://github.com/t-sagara/jageocoder/
 License: The MIT License

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/jageocoder/__init__.py

@@ -19,7 +19,7 @@ running the following steps.
     >>> jageocoder.searchNode('<Japanese-address>')
 """
 
-__version__ = '2.1.7.dev2'  # The package version
+__version__ = '2.1.7.rc1'  # The package version
 __dictionary_version__ = '20230927'  # Compatible dictionary version
 __author__ = 'Takeshi Sagara <sagara@info-proto.com>'
 

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/jageocoder/node.py

@@ -70,6 +70,30 @@ class AddressNodeTable(PortableTab.BaseTable):
         node.table = self
         return node
 
+    def search_ids_on(
+        self,
+        attr: str,
+        value: str,
+    ) -> list:
+        """
+        Search id list from the table on the specified attribute.
+
+        Paramters
+        ---------
+        attr: str
+            The name of target attribute.
+        value: str
+            The target value.
+
+        Returns
+        -------
+        List[int]
+            List of node ids.
+        """
+        trie = self.open_trie_on(attr)
+        positions = trie.get(value, [])
+        return [p[0] for p in positions]
+
     def create_indexes(self) -> None:
         """
         Create TRIE index on "name" and "note" columns.
@@ -514,7 +538,7 @@ class AddressNode(object):
         """
         new_node = copy.copy(self)
         for child in self.iter_children():
-            if child.y <= 90.0:
+            if child.has_valid_coordinate_values():
                 new_node.x, new_node.y = child.x, child.y
                 logger.debug((
                     "Node {}({}) has no coordinates. "

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/jageocoder/remote.py

@@ -184,6 +184,30 @@ class RemoteNodeTable(object):
 
         return nodes
 
+    def search_ids_on(
+        self,
+        attr: str,
+        value: str,
+    ) -> list:
+        """
+        Search id from the table on the specified attribute on the remote server.
+
+        Paramters
+        ---------
+        attr: str
+            The name of target attribute.
+        value: str
+            The target value.
+
+        Returns
+        -------
+        List[Record]
+            List of records.
+        """
+        nodes = self.search_records_on(attr, value)
+        ids = [node.id for node in nodes]
+        return ids
+
 
 class RemoteTree(AddressTree):
     """

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/jageocoder/rtree.py

@@ -15,6 +15,16 @@ from jageocoder.node import AddressNode, AddressNodeTable
 logger = getLogger(__name__)
 
 
+class NodeDist(object):
+
+    def __init__(self, dist: float, node: AddressNode) -> None:
+        self.dist = dist
+        self.node = node
+
+    def __repr__(self) -> str:
+        return f"NodeDist({self.dist}, {self.node})"
+
+
 class DelaunayTriangle(ABC):
 
     @classmethod
@@ -131,8 +141,8 @@ class DelaunayTriangle(ABC):
         cls,
         x: float,
         y: float,
-        nodes: List[AddressNode]
-    ) -> List[AddressNode]:
+        nodes: List[NodeDist]
+    ) -> List[NodeDist]:
         """
         Select the 3 nodes that make the smallest triangle
         surrounding the target point.
@@ -143,13 +153,14 @@ class DelaunayTriangle(ABC):
             The longitude of the target point.
         y: float
             The latitude of the target point.
-        nodes: List[AddressNode]
-            The candidate nodes.
+        nodes: List[NodeDist]
+            The candidate list of (distance, node).
 
         Returns
         -------
-        List[AddressNode]
-            Up to 3 nodes surrounding the target point.
+        List[NodeDist]
+            Up to 3 nodes surrounding the target point
+            and their distance.
         """
         def kval(t: Tuple[int, int, int]) -> int:
             sval = sorted(t)
@@ -161,9 +172,9 @@ class DelaunayTriangle(ABC):
                 for p2 in range(p1 + 1, len(nodes)):
                     if cls.p_contained_triangle(
                         (x, y),
-                        (nodes[p0].x, nodes[p0].y),
-                        (nodes[p1].x, nodes[p1].y),
-                        (nodes[p2].x, nodes[p2].y)
+                        (nodes[p0].node.x, nodes[p0].node.y),
+                        (nodes[p1].node.x, nodes[p1].node.y),
+                        (nodes[p2].node.x, nodes[p2].node.y)
                     ):
                         triangle = [p0, p1, p2]
                         break
@@ -187,10 +198,10 @@ class DelaunayTriangle(ABC):
                 continue
 
             if cls.p_contained_circumcircle(
-                (nodes[i].x, nodes[i].y),
-                (nodes[triangle[0]].x, nodes[triangle[0]].y),
-                (nodes[triangle[1]].x, nodes[triangle[1]].y),
-                (nodes[triangle[2]].x, nodes[triangle[2]].y)
+                (nodes[i].node.x, nodes[i].node.y),
+                (nodes[triangle[0]].node.x, nodes[triangle[0]].node.y),
+                (nodes[triangle[1]].node.x, nodes[triangle[1]].node.y),
+                (nodes[triangle[2]].node.x, nodes[triangle[2]].node.y)
             ):
                 new_triangle = None
                 for j in range(3):
@@ -202,9 +213,9 @@ class DelaunayTriangle(ABC):
 
                     if cls.p_contained_triangle(
                         (x, y),
-                        (nodes[tt[0]].x, nodes[tt[0]].y),
-                        (nodes[tt[1]].x, nodes[tt[1]].y),
-                        (nodes[tt[2]].x, nodes[tt[2]].y)
+                        (nodes[tt[0]].node.x, nodes[tt[0]].node.y),
+                        (nodes[tt[1]].node.x, nodes[tt[1]].node.y),
+                        (nodes[tt[2]].node.x, nodes[tt[2]].node.y)
                     ):
                         new_triangle = tt
                         break
@@ -309,6 +320,9 @@ class Index(object):
         node_table: AddressNodeTable = self._tree.address_nodes
 
         max_id = node_table.count_records()
+        registered_coordinates = set()
+
+        logger.info("Building RTree for reverse geocoding...")
         id = AddressNode.ROOT_NODE_ID
         with tqdm(total=max_id, mininterval=0.5, ascii=True) as pbar:
             prev_id = 0
@@ -317,22 +331,70 @@ class Index(object):
                 prev_id = id
 
                 node = node_table.get_record(pos=id)
-                if node.level > AddressLevel.AZA:
-                    id = node.sibling_id
-                    continue
-                elif node.level < AddressLevel.OAZA:
+                if node.level <= AddressLevel.WARD:
+                    registered_coordinates.clear()
                     id += 1
                     continue
-                elif not node.has_valid_coordinate_values():
-                    node = node.add_dummy_coordinates()
+
+                if node.sibling_id == node.id + 1:
+                    # The node has no child nodes
+
                     if not node.has_valid_coordinate_values():
                         id += 1
                         continue
 
-                file_idx.insert(
-                    id=id,
-                    coordinates=(node.x, node.y, node.x, node.y)
-                )
+                    key = (node.x, node.y)
+                    if key in registered_coordinates:
+                        id += 1
+                        continue
+
+                    file_idx.insert(
+                        id=id,
+                        coordinates=(node.x, node.y, node.x, node.y),
+                    )
+                    registered_coordinates.add(key)
+                    id += 1
+                    continue
+
+                # The node has 1 or more child nodes
+                if node.level == AddressLevel.BLOCK:
+                    # Get BDR of child nodes
+                    bdr = None
+                    for child_id in range(node.id + 1, node.sibling_id):
+                        child_node = node_table.get_record(child_id)
+                        if not child_node.has_valid_coordinate_values():
+                            continue
+
+                        if bdr is None:
+                            bdr = (child_node.x, child_node.y,
+                                   child_node.x, child_node.y)
+                        else:
+                            bdr = (
+                                min(child_node.x, bdr[0]),
+                                min(child_node.y, bdr[1]),
+                                max(child_node.x, bdr[2]),
+                                max(child_node.y, bdr[3]),
+                            )
+
+                    if bdr:
+                        file_idx.insert(
+                            id=id,
+                            coordinates=bdr,
+                        )
+                    else:
+                        # All child nodes have invalid coordinate values
+                        key = (node.x, node.y)
+                        if node.has_valid_coordinate_values() and \
+                                key not in registered_coordinates:
+                            file_idx.insert(
+                                id=id,
+                                coordinates=(node.x, node.y, node.x, node.y),
+                            )
+                            registered_coordinates.add(key)
+
+                    id = node.sibling_id
+                    continue
+
                 id += 1
 
         return file_idx
@@ -366,20 +428,28 @@ class Index(object):
         """
         node_table = self._tree.address_nodes
         node = node_table.get_record(pos=node_table.count_records() // 2)
-        while node.level < AddressLevel.OAZA:
-            node = node_table.get_record(pos=node.id + 1)
 
-        while node.level > AddressLevel.AZA:
-            node = node.parent
+        while True:
+            while node.level < AddressLevel.BLOCK:
+                node = node_table.get_record(pos=node.id + 1)
 
-        return node.id in self.idx.nearest((node.x, node.y, node.x, node.y), 2)
+            while node.level > AddressLevel.BLOCK:
+                node = node.parent
+
+            if node.has_valid_coordinate_values():
+                break
+
+            node = node_table.get_record(pos=node.sibling_id)
+
+        results = tuple(self.idx.nearest((node.x, node.y, node.x, node.y), 20))
+        return len(results) > 0 and node.id in results
 
     def _sort_by_dist(
         self,
         lon: float,
         lat: float,
-        id_list: Iterable[int]
-    ) -> List[AddressNode]:
+        nodes: Iterable[AddressNode],
+    ) -> List[NodeDist]:
         """
         Sort nodes by real(projected) distance from the target point.
 
@@ -389,22 +459,24 @@ class Index(object):
             The longitude of the target point.
         lat: float
             The latitude of the target point.
-        id_list: Iterable[int]
-            The list of node-id.
+        nodes: Iterable[AddressNode]
+            The list of candidate node.
 
         Returns
         -------
-        List[AddressNode]
-            The sorted list of address nodes.
+        List[NodeDist]
+            The sorted list of (distance, address node).
         """
         results = []
-        for node_id in id_list:
-            node = self._tree.get_address_node(id=node_id)
+        for node in nodes:
+            if not node.has_valid_coordinate_values():
+                continue
+
             dist = self.distance(node.x, node.y, lon, lat)
-            results.append((node, dist))
+            results.append(NodeDist(dist, node))
 
-        results.sort(key=lambda x: x[1])
-        return [x[0] for x in results]
+        results.sort(key=lambda x: x.dist)
+        return results
 
     def nearest(
         self,
@@ -436,84 +508,43 @@ class Index(object):
         """
         level = level or AddressLevel.AZA
 
-        # Search nodes by Rtree Index
-        nodes = []
-        ancestors = set()
-        max_level = 0
-        for node in self._sort_by_dist(x, y, self.idx.nearest((x, y, x, y), 10)):
-            if node.id in ancestors:
-                continue
-
-            if not node.has_valid_coordinate_values():
-                node = node.add_dummy_coordinates()
-
-            nodes.append(node)
-            max_level = max(max_level, node.level)
-            # Ancestor nodes of registering node are excluded.
-            cur = node.parent
-            while cur is not None:
-                nodes = [node for node in nodes if node.id != cur.id]
-                ancestors.add(cur.id)
-                cur = cur.parent
-
-        if level > max_level:
-            # Search points in the higher levels
-            local_idx = index.Rtree()  # Create local rtree on memory
-            for node in nodes:
-                child_id = node.id
-                while child_id < node.sibling_id:
-                    child_node = self._tree.get_address_node(id=child_id)
-                    if child_node.level > level:
-                        child_id = child_node.parent.sibling_id
-                        continue
-                    elif not child_node.has_valid_coordinate_values():
-                        child_node = child_node.add_dummy_coordinates()
-                        if not child_node.has_valid_coordinate_values():
-                            child_id += 1
-                            continue
-
-                    local_idx.insert(
-                        id=child_id,
-                        coordinates=(
-                            child_node.x, child_node.y,
-                            child_node.x, child_node.y))
-                    child_id += 1
-
-            nodes = []
-            ancestors = set()
-            for node in self._sort_by_dist(x, y, local_idx.nearest((x, y, x, y), 20)):
-                if node.id in ancestors:
-                    continue
-
-                if not node.has_valid_coordinate_values():
-                    node = node.add_dummy_coordinates()
-
-                nodes.append(node)
-                # Ancestor nodes of registering node are excluded.
-                cur = node.parent
-                while cur is not None:
-                    nodes = [node for node in nodes if node.id != cur.id]
-                    ancestors.add(cur.id)
-                    cur = cur.parent
+        # Retrieve top k-nearest nodes using the R-tree index.
+        # If the node registered in the index is an intermediate node,
+        # expand its leaf nodes.
+        candidates = []
+        nearests = self.idx.nearest((x, y, x, y), 20, objects=True)
+        for item in nearests:
+            node = self._tree.get_node_by_id(item.id)
+            if item.bbox[0] == item.bbox[2] and item.bbox[1] == item.bbox[3]:
+                candidates.append(node)
+            else:
+                for child_id in range(node.id + 1, node.sibling_id):
+                    child_node = self._tree.get_node_by_id(child_id)
+                    if child_node.sibling_id == child_id + 1 and \
+                            child_node.has_valid_coordinate_values():
+                        candidates.append(child_node)
+
+        node_dists = self._sort_by_dist(x, y, candidates)
 
         # Select the 3 nodes that make the smallest triangle
         # surrounding the target point
-        if len(nodes) == 0:
+        if len(node_dists) == 0:
             return []
 
-        if self.distance(x, y, nodes[0].x, nodes[0].y) < 1.0e-02:
+        if len(node_dists) <= 3 or node_dists[0].dist < 1.0e-02:
             # If the distance between the nearest point and the search point is
             # less than 1 cm, it returns three points in order of distance.
             # This is because the nearest point may not be included in
             # the search results due to a calculation error.
-            nodes = nodes[0:3]
+            node_dists = node_dists[0:3]
         else:
-            nodes = DelaunayTriangle.select(x, y, nodes)
+            node_dists = DelaunayTriangle.select(x, y, node_dists)
 
         # Convert nodes to the dict format.
         results = []
         registered = set()
-        for node in nodes:
+        for v in node_dists:
+            dist, node = v.dist, v.node
             while node.level > level:
                 node = node.parent
 
@@ -522,11 +553,8 @@ class Index(object):
 
             results.append({
                 "candidate": node.as_dict() if as_dict else node,
-                "dist": self.distance(x, y, node.x, node.y)
+                "dist": dist
             })
             registered.add(node.id)
 
-        # Sort by distance
-        results = sorted(results, key=lambda r: r['dist'])
-
         return results

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/jageocoder/tree.py

@@ -1,17 +1,14 @@
 from collections import OrderedDict
-import csv
-import json
 from logging import getLogger
 import os
 from pathlib import Path
 import re
 import site
 import sys
-from typing import Any, Union, List, Set, NoReturn, Optional, TextIO
+from typing import Any, Union, List, Set, Optional
 
 from deprecated import deprecated
 
-import jageocoder
 from jageocoder.address import AddressLevel
 from jageocoder.aza_master import AzaMaster
 from jageocoder.exceptions import AddressTreeException
@@ -285,11 +282,13 @@ class AddressTree(object):
         node_id: int
             The target node id.
 
-        Return
-        ------
+        Returns
+        -------
         AddressNode
         """
-        return self.address_nodes.get_record(node_id)
+        node = self.address_nodes.get_record(node_id)
+        node.tree = self
+        return node
 
     def search_nodes_by_codes(
             self,
@@ -316,6 +315,31 @@ class AddressTree(object):
 
         return nodes
 
+    def search_ids_by_codes(
+            self,
+            category: str,
+            value: str) -> List[AddressNode]:
+        """
+        Search node ids by category and value.
+
+        Parameters
+        ----------
+        category: str
+            Category name such as 'jisx0402' or 'postcode'.
+        value: str
+            Target value.
+
+        Returns
+        -------
+        List[int]
+        """
+        ids = []
+        pattern = '{}:{}'.format(category, value)
+        ids = self.address_nodes.search_ids_on(
+            attr="note", value=pattern)  # exact match
+
+        return ids
+
     @deprecated("Use 'node.get_fullname()' instead of this method.")
     def get_node_fullname(self, node: Union[AddressNode, int]) -> List[str]:
         if isinstance(node, int):
@@ -825,7 +849,7 @@ class AddressTree(object):
             key = index[0:offset]
             rest_index = index[offset:]
             for node_id in trie_node.nodes:
-                node = self.get_address_node(id=node_id)
+                node = self.get_node_by_id(node_id=node_id)
 
                 if not node.has_valid_coordinate_values() \
                         and self.get_config('require_coordinates'):
@@ -965,6 +989,7 @@ class AddressTree(object):
 
         return results
 
+    @deprecated(reason="Use 'get_node_by_id'.", version="2.1.7")
     def get_address_node(self, id: int) -> AddressNode:
         """
         Get address node from the tree by its id.
@@ -1171,17 +1196,30 @@ class AddressTree(object):
         """
         if len(id) == 12:
             # jisx0402(5digits) + aza_id(7digits)
-            candidates = self.search_nodes_by_codes(
+            citynode = self.search_by_citycode(code=id[0:5])
+            if len(citynode) == 0:
+                return []
+
+            citynode = citynode[0]
+            candidates = self.search_ids_by_codes(
                 category="aza_id",
                 value=id[-7:])
-            nodes = [x for x in candidates if x.get_city_jiscode() == id[0:5]]
+            nodes = [self.address_nodes.get_record(x)
+                     for x in candidates
+                     if x >= citynode.id and x < citynode.sibling_id]
         elif len(id) == 13:
             # lasdec(6digits) + aza_id(7digits)
-            candidates = self.search_nodes_by_codes(
+            citynode = self.search_by_citycode(code=id[0:6])
+            if len(citynode) == 0:
+                return []
+
+            citynode = citynode[0]
+            candidates = self.search_ids_by_codes(
                 category="aza_id",
                 value=id[-7:])
-            nodes = [x for x in candidates
-                     if x.get_city_local_authority_code() == id[0:6]]
+            nodes = [self.address_nodes.get_record(x)
+                     for x in candidates
+                     if x >= citynode.id and x < citynode.sibling_id]
         else:
             nodes = self.search_nodes_by_codes(
                 category="aza_id",

{jageocoder-2.1.7.dev2 → jageocoder-2.1.7rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jageocoder"
-version = "2.1.7.dev2"
+version = "2.1.7.rc1"
 description = "A Japanese-address geocoder for Python."
 authors = ["Takeshi Sagara <sagara@info-proto.com>"]
 repository = "https://github.com/t-sagara/jageocoder/"