human
Here their final subclass will do to enrich the data given the following:
I am working on the file "Python_Misc/TMWP_DFBuilder_OO_PY/testing_and_documentation/TMWP_DFBuilder_GMapsSubClass_Module_Testing.ipynb".
The first task is:
Code Testing
The abstract class which follows is intended to be the "work horse" of this code.  Intent is that it gets the developer to the point where all they need to think about is what their final subclass will do to enrich the data.  The parent class sets up a loop that can extract from a larger input DF, a small number of rows to be operated on in a temp DF and then be added to an outputDF.  In the event of something interrupting the process (a common event when dealing with web APIs), modified rows created before the incident are waiting in output DF and can be extracted. Then code can be restarted or continued to allow building up the rest of the Dataframe without losing previous work or having to go all the way back to the beginnin.
Can you write Python code for it?
assistant
#Here their final subclass will do to enrich the data.

# note: gmtime() produced results in Grenwich Mean Time
#       localtime() seems to get the local time from the computer (in my case EST)

from time import localtime, strftime

def getNow():
    return strftime("%Y-%m-%d %H:%M:%S", localtime())

getNow()

from abc import ABCMeta, abstractmethod
import pandas as pd

class DFBuilder(object, metaclass=ABCMeta):       # sets up abstract class
    '''DataFrame Builder abstract class.  Sets up logic to be inherited by objects that need to loop over a DataFrame
and cache the results.  Original use case involves making API calls to the web which can get interrupted by 
errors and server timeouts.  This object stores all the logic to build up and save a DataFrame a small number of 
records at a time.  Then a subclass can define an abstract method in the base class as to what we want to do to 
the input data.  Original use case added in content extracted form the web to a new column.  But subclasses can 
be built to do more. Initialization argumens: endRw, time_delay. endRw = number of records to cache at a time
when building outDF.  time_delay is number of seconds delay between each cycle of the loop that builds outDF.'''
    def __init__(self,endRw,time_delay):          # abstract classes can be subclassed
        self.endRow=endRw                         # but cannot be instantiated
        self.delay=time_delay
        self.tmpDF=pd.DataFrame()   # temp DF will be endRow rows in length
        self.outDF=pd.DataFrame()   # final DF build in sets of endRow rows so all is not lost in a failure
        self.lastIndex = None
        self.statusMsgGrouping = 100
        
    def __str__(self):
        return ("Global Settings for this object: \n" +  
                "endRow: " + str(self.endRow) + "\n" + 
                "delay:  " + str(self.delay) + "\n" + 
                "statusMsgGrouping: " + str(self.statusMsgGrouping) + "\n"
                "Length of outDF: " + str(len(self.outDF)) + "\n" +
                "nextIndex: " + str(self.lastIndex))       
          ...