_tree_to_overpassql_recursive() - Code Metrics - Inspection of "Guard trigger against recursion" - Natureshadow/OSMAlchemy - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( da4639...75155f )

by Dominik
created 2016-08-10 20:51 UTC
_tree_to_overpassql_recursive() F

↳ Parent: Project
Complexity

Conditions
Size

Total Lines
109
Duplication

Lines	24
Ratio	22.02 %
Importance

Changes	8
Bugs	0	Features	0
Metric	Value
cc	54
c	8
b	0
f	0
dl	24
loc	109
rs	2
How to fix Long Method Complexity

## ~*~ coding: utf-8 ~*~
#-
# OSMAlchemy - OpenStreetMap to SQLAlchemy bridge
# Copyright (c) 2016 Dominik George <[email protected]>
# Copyright (c) 2016 Eike Tim Jesinghaus <[email protected]>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Alternatively, you are free to use OSMAlchemy under Simplified BSD, The
# MirOS Licence, GPL-2+, LGPL-2.1+, AGPL-3+ or the same terms as Python
# itself.

""" Utility code for OSMAlchemy's overpass code. """

import operator
import overpass
from sqlalchemy.sql.elements import BinaryExpression, BooleanClauseList, BindParameter
from sqlalchemy.sql.annotation import AnnotatedColumn


def _generate_overpass_api(endpoint=None):
    """ Create and initialise the Overpass API object.

    Passing the endpoint argument will override the default
    endpoint URL.
    """

    # Create API object with default settings
    api = overpass.API()

    # Change endpoint if desired
    if endpoint is not None:
        api.endpoint = endpoint

    return api

def _get_single_element_by_id(api, type, id, recurse_down=True):

    """ Retrieves a single OpenStreetMap element by its id.

      api - an initialised Overpass API object
      type - the element type to query, one of node, way or relation
      id - the id of the element to retrieve
      recurse_down - whether to get child nodes of ways and relations
    """

    # Construct query
    q = "%s(%d);%s" % (type, id, "(._;>;);" if recurse_down else "")


    # Run query
    r = api.Get(q, responseformat="xml")


    # Return data
    return r

def _get_elements_by_query(api, query, recurse_down=True):
    """ Runs a query and returns the resulting OSM XML.

      api - an initialised Overpass API object
      query - the OverpassQL query
      recurse_down - whether to get child nodes of ways and relations
    """

    # Run query
    r = api.Get("%s%s" % (query, "(._;>;);" if recurse_down else ""), responseformat="xml")


    # Return data
    return r

# Define operator to string mapping
_ops = {operator.eq: "==",

        operator.ne: "!=",
        operator.lt: "<",
        operator.gt: ">",
        operator.le: "<=",
        operator.ge: ">=",
        operator.and_: "&&",
        operator.or_: "||"}

def _where_to_tree(clause, target):

    """ Transform an SQLAlchemy whereclause to an expression tree.

    This function analyses a Query.whereclause object and turns it
    into a more general data structure.
    """

    if type(clause) is BinaryExpression:

        # This is something like "latitude >= 51.0"
        left = clause.left
        right = clause.right
        op = clause.operator


        # Left part should be a column
        if type(left) is AnnotatedColumn:

            # Get table class and field
            model = left._annotations["parentmapper"].class_
class MyParent:
    def __init__(self):
        self._x = 1;
        self.y = 2;

class MyChild(MyParent):
    def some_method(self):
        return self._x    # Ok, since accessed from a child class

class AnotherClass:
    def some_method(self, instance_of_my_child):
        return instance_of_my_child._x   # Would be flagged as AnotherClass is not
                                         # a child class of MyParent
            field = left

            # Only use if we are looking for this model
            if model is target:
                # Store field name
                left = field.name
            else:
                return None
        else:
            # Right now, we cannot cope with anything but a column on the left
            return None

        # Right part should be a literal value
        if type(right) is BindParameter:

            # Extract literal value
            right = right.value
        else:
            # Right now, we cannot cope with something else here
            return None

        # Look for a known operator
        if op in _ops.keys():
            # Get string representation
            op = _ops[op]

        else:
            # Right now, we cannot cope with other operators
            return None

        # Return polish notation tuple of this clause
        return (op, left, right)
    elif type(clause) is BooleanClauseList:

        # This is an AND or OR operation
        op = clause.operator

        clauses = []

        # Iterate over all the clauses in this operation
        for clause in clause.clauses:
            # Recursively analyse clauses
            res = _where_to_tree(clause, target)
            # None is returned for unsupported clauses or operations
            if res is not None:
                # Append polish notation result to clauses list
                clauses.append(res)

        # Look for a known operator
        if op in _ops.keys():
            # Get string representation
            op = _ops[op]

        else:
            # Right now, we cannot cope with anything else
            return None

        # Return polish notation tuple of this clause
        return (op, clauses)
    else:
        # We hit an unsupported type of clause
        return None

def _trees_to_overpassql(tree_dict):
    """ Transform an expression tree (from _where_to_tree) into OverpassQL. """

    # Called recursively on all subtrees
    def _tree_to_overpassql_recursive(tree, type_, op):

        # Empty result string
        result = ""

        # Test if we got a tree or an atom
        if isinstance(tree[1], list):
            # We are in a subtree

            # Store operation of subtree (conjunction/disjunction)
            op = tree[0]

            

            # Empty bounding box
            bbox = [None, None, None, None]

            # List of genrated set names
            set_names = []


            # Iterate over all elements in the conjunction/disjunction
            for t in tree[1]:

                # Check if element is a tree or an atom
                if isinstance(t[1], list):
                    # Recurse into inner tree
                    result_inner_tree = _tree_to_overpassql_recursive(tree[1], op)

                    # Store resulting query and its name

                    result += "%s" % result_inner_tree[1]
                    set_names.append(result_inner_tree[0])
                else:
                    # Parse atom

                    # latitude and longitude comparisons form a bounding box
                    if t[1] == "latitude" and t[0] == ">":

                        # South edge
                        if bbox[0] is None:
                            bbox[0] = float(t[2])
                        elif op == "&&" and bbox[0] <= t[2]:
                            bbox[0] = float(t[2])
                        elif op == "||" and bbox[0] >= t[2]:
                            bbox[0] = float(t[2])
                    elif t[1] == "latitude" and t[0] == "<":
                        # North edge
                        if bbox[2] is None:
                            bbox[2] = float(t[2])
                        elif op == "&&" and bbox[2] >= t[2]:
                            bbox[2] = float(t[2])
                        elif op == "||" and bbox[2] <= t[2]:
                            bbox[2] = float(t[2])
                    elif t[1] == "longitude" and t[0] == ">":
                        # West edge
                        if bbox[1] is None:
                            bbox[1] = float(t[2])
                        elif op == "&&" and bbox[1] <= t[2]:
                            bbox[1] = float(t[2])
                        elif op == "||" and bbox[1] >= t[2]:
                            bbox[1] = float(t[2])
                    elif t[1] == "longitude" and t[0] == "<":
                        # East edge
                        if bbox[3] is None:
                            bbox[3] = float(t[2])
                        elif op == "&&" and bbox[3] >= t[2]:
                            bbox[3] = float(t[2])
                        elif op == "||" and bbox[3] <= t[2]:
                            bbox[3] = float(t[2])
                    # Query for an element with specific id
                    elif t[1] == "id" and t[0] == "==":
                        # Build query
                        idquery = "%s(%i)" % (type_, t[2])
                        # Store resulting query and its name
                        set_name = "s%i" % id(idquery)
                        result += "%s->.%s;" % (idquery, set_name)
                        set_names.append(set_name)
                    elif t[1] == "id":
                        # We got an id query, but not with equality comparison
                        raise ValueError("id can only be queried with equality")
                    # Everything else must be a tag query
                    else:
                        # Build query
                        tagquery = "%s[\"%s\"=\"%s\"]" % (type_, t[1], t[2])
                        # Store resulting query and its name
                        set_name = "s%i" % id(tagquery)
                        result += "%s->.%s;" % (tagquery, set_name)
                        set_names.append(set_name)

            # Check if any component of the bounding box was set
            if bbox != [None, None, None, None]:
                # Amend minima/maxima
                if bbox[0] is None:
                    bbox[0] = -90.0
                if bbox[1] is None:
                    bbox[1] = -180.0
                if bbox[2] is None:
                    bbox[2] = 90.0
                if bbox[3] is None:
                    bbox[3] = 180.0

                # Build query
                bboxquery = "%s(%s,%s,%s,%s)" % (type_, bbox[0], bbox[1], bbox[2], bbox[3])
                # Store resulting query and its name
                set_name = "s%i" % id(bboxquery)
                result += "%s->.%s;" % (bboxquery, set_name)
                set_names.append(set_name)

            # Build conjunction or disjunction according to current operation
            if op == "&&":
                # Conjunction, build an intersection
                result += "%s." % type_
                result += ".".join(set_names)
            elif op == "||":
                # Disjunction, build a union
                result += "("
                for s in set_names:

                    result += ".%s;" % s
                result += ")"
        else:
            # We got a bare atom

            # latitude and longitude are components of a bounding box query
            if tree[1] == "latitude" and tree[0] == ">":
                # South edge
                result = "%s(%s,-180.0,90.0,180.0)" % (type_, tree[2])
            elif tree[1] == "latitude" and tree[0] == "<":
                # West edge
                result = "%s(-90.0,-180.0,%s,180.0)" % (type_, tree[2])
            elif tree[1] == "longitude" and tree[0] == ">":
                # North edge
                result = "%s(-90.0,%s,-90.0,180.0)" % (type_, tree[2])
            elif tree[1] == "longitude" and tree[0] == "<":
                # East edge
                result = "%s(-90.0,-180.0,-90.0,%s)" % (type_, tree[2])
            # Query for an id
            elif tree[1] == "id" and tree[0] == "==":
                result = "%s(%i)" % (type_, tree[2])
            elif tree[1] == "id":
                # We got an id query, but not with equality comparison
                raise ValueError("id can only be queried with equality")
            # Everything else must be a tag query
            else:
                result = "%s[\"%s\"=\"%s\"]" % (type_, tree[1], tree[2])

        # generate a name for the complete set and return it, along with the query
        set_name = id(result)
        result += "->.s%i;" % set_name
        return (set_name, result)

    # Run tree transformation for each type in the input tree
    results = []
    for type_ in tree_dict.keys():
        # Get real type name (OSMNode→node,…)
        real_type = type_[3:].lower()
        # Do transformation and store query and name
        results.append(_tree_to_overpassql_recursive(tree_dict[type_], real_type, None))

    # Build finally resulting query in a union
    result = ""
    set_names = "("
    for r in results:

        result += r[1]
        set_names += ".s%s; " % r[0]
    set_names = "%s);" % set_names.strip()
    result += set_names

    # Return final query
    return result

Natureshadow / OSMAlchemy

Push — master ( da4639...75155f )

_tree_to_overpassql_recursive() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like
