docs: def graph_from_address(address, distance=1000, distance_type='bbox',
                         network_type='all_private', simplify=True, retain_all=False,
                         truncate_by_edge=False, return_coords=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 address.
  
      Parameters
      ----------
      address : string
          the address to geocode and use as the central point around which to
          construct the graph
      distance : int
          retain only those nodes within this many meters of the center of the
          graph
      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
      return_coords : bool
          optionally also return the geocoded coordinates of the address
      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 or tuple
          multidigraph or optionally (multidigraph, tuple)
      """
  
      # geocode the address string to a (lat, lon) point
      point = geocode(query=address)
  
      # then create a graph from this point
      G = graph_from_point(point, distance, distance_type, 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)
      log('graph_from_address() returning graph with {:,} nodes and {:,} edges'.format(len(list(G.nodes())), len(list(G.edges()))))
  
      if return_coords:
          return G, point
      else:
          return G