docs: def graph_from_point(center_point, distance=1000, distance_type='bbox',
                       network_type='all_private', simplify=True, retain_all=False,
                       truncate_by_edge=False, name='unnamed', timeout=180,
                       memory=None, max_query_area_size=50*1000*50*1000,
                       clean_periphery=True, infrastructure='way["highway"]',
                       custom_filter=None):
      """
      Create a networkx graph from OSM data within some distance of some (lat,
      lon) center point.
  
      Parameters
      ----------
      center_point : tuple
          the (lat, lon) central point around which to construct the graph
      distance : int
          retain only those nodes within this many meters of the center of the
          graph, with distance determined according to distance_type argument
      distance_type : string
          {'network', 'bbox'} if 'bbox', retain only those nodes within a bounding
          box of the distance parameter. if 'network', retain only those nodes
          within some network distance from the center-most node.
      network_type : string
          what type of street network to get
      simplify : bool
          if true, simplify the graph topology
      retain_all : bool
          if True, return the entire graph even if it is not connected
      truncate_by_edge : bool
          if True retain node if it's outside bbox but at least one of node's
          neighbors are within bbox
      name : string
          the name of the graph
      timeout : int
          the timeout interval for requests and to pass to API
      memory : int
          server memory allocation size for the query, in bytes. If none, server
          will use its default allocation size
      max_query_area_size : float
          max size for any part of the geometry, in square degrees: any polygon
          bigger will get divided up for multiple queries to API
      clean_periphery : bool,
          if True (and simplify=True), buffer 0.5km to get a graph larger than
          requested, then simplify, then truncate it to requested spatial extent
      infrastructure : string
          download infrastructure of given type (default is streets (ie, 'way["highway"]') but other
          infrastructures may be selected like power grids (ie, 'way["power"~"line"]'))
      custom_filter : string
          a custom network filter to be used instead of the network_type presets
  
      Returns
      -------
      networkx multidigraph
      """
  
      if distance_type not in ['bbox', 'network']:
          raise InvalidDistanceType('distance_type must be "bbox" or "network"')
  
      # create a bounding box from the center point and the distance in each
      # direction
      north, south, east, west = bbox_from_point(center_point, distance)
  
      # create a graph from the bounding box
      G = graph_from_bbox(north, south, east, west, network_type=network_type, simplify=simplify,
                          retain_all=retain_all, truncate_by_edge=truncate_by_edge, name=name,
                          timeout=timeout, memory=memory, max_query_area_size=max_query_area_size,
                          clean_periphery=clean_periphery, infrastructure=infrastructure,
                          custom_filter=custom_filter)
  
      # if the network distance_type is network, find the node in the graph
      # nearest to the center point, and truncate the graph by network distance
      # from this node
      if distance_type == 'network':
          centermost_node = get_nearest_node(G, center_point)
          G = truncate_graph_dist(G, centermost_node, max_distance=distance)
  
      log('graph_from_point() returning graph with {:,} nodes and {:,} edges'.format(len(list(G.nodes())), len(list(G.edges()))))
      return G