Exemple #1
0
class MyFarmware():

    def get_input_env(self):
        prefix = self.farmwarename.lower().replace('-','_')
        
        self.input_title = os.environ.get(prefix+"_title", '-')
        self.input_id = os.environ.get(prefix+"_id", '*')
        self.input_pointname = os.environ.get(prefix+"_pointname", '*')
        self.input_openfarm_slug = os.environ.get(prefix+"_openfarm_slug", '*')
        self.input_age_min_day = int(os.environ.get(prefix+"_age_min_day", -1))
        self.input_age_max_day = int(os.environ.get(prefix+"_age_max_day", 36500))
        self.input_filter_meta_key = os.environ.get(prefix+"_filter_meta_key", 'None')
        self.input_filter_meta_value = os.environ.get(prefix+"_filter_meta_value", 'None')
        self.input_filter_min_x = os.environ.get(prefix+"_filter_min_x", 'None')
        self.input_filter_max_x = os.environ.get(prefix+"_filter_max_x", 'None')
        self.input_filter_min_y = os.environ.get(prefix+"_filter_min_y", 'None')
        self.input_filter_max_y = os.environ.get(prefix+"_filter_max_y", 'None')
        self.input_save_name = os.environ.get(prefix+"_save_name", 'None')
        self.input_remove_all_metadata = os.environ.get(prefix+"_remove_all_metadata", 'No')
        self.input_save_meta_key = os.environ.get(prefix+"_save_meta_key", 'None')
        self.input_save_meta_value = os.environ.get(prefix+"_save_meta_value", 'None')
        self.input_save_date = os.environ.get(prefix+"_save_date", 'None')
        self.input_debug = int(os.environ.get(prefix+"_debug", 1))

        if self.input_debug >= 1:
            log('title: {}'.format(self.input_title), message_type='debug', title=self.farmwarename)
            log('id: {}'.format(self.input_id), message_type='debug', title=self.farmwarename)
            log('pointname: {}'.format(self.input_pointname), message_type='debug', title=self.farmwarename)
            log('openfarm_slug: {}'.format(self.input_openfarm_slug), message_type='debug', title=self.farmwarename)
            log('age_min_day: {}'.format(self.input_age_min_day), message_type='debug', title=self.farmwarename)
            log('age_max_day: {}'.format(self.input_age_max_day), message_type='debug', title=self.farmwarename)
            log('filter_meta_key: {}'.format(self.input_filter_meta_key), message_type='debug', title=self.farmwarename)
            log('filter_meta_value: {}'.format(self.input_filter_meta_value), message_type='debug', title=self.farmwarename)
            log('filter_min_x: {}'.format(self.input_filter_min_x), message_type='debug', title=self.farmwarename)
            log('filter_max_x: {}'.format(self.input_filter_max_x), message_type='debug', title=self.farmwarename)
            log('filter_min_y: {}'.format(self.input_filter_min_y), message_type='debug', title=self.farmwarename)
            log('filter_max_y: {}'.format(self.input_filter_max_y), message_type='debug', title=self.farmwarename)
            log('save_name: {}'.format(self.input_save_name), message_type='debug', title=self.farmwarename)
            log('remove_all_metadata: {}'.format(self.input_remove_all_metadata), message_type='debug', title=self.farmwarename)
            log('save_meta_key: {}'.format(self.input_save_meta_key), message_type='debug', title=self.farmwarename)
            log('save_meta_value: {}'.format(self.input_save_meta_value), message_type='debug', title=self.farmwarename)
            log('save_date: {}'.format(self.input_save_date), message_type='debug', title=self.farmwarename)
            log('debug: {}'.format(self.input_debug), message_type='debug', title=self.farmwarename)
        
    def __init__(self,farmwarename):
        self.farmwarename = farmwarename
        self.get_input_env()
        self.api = API(self)
        self.points = []

    def apply_filters(self, points, point_id='*', point_name='*', openfarm_slug='*', age_min_day=0, age_max_day=36500, meta_key='', meta_value='', min_x='none', max_x='none', min_y='none', max_y='none', pointer_type='Plant'):
        if self.input_debug >= 1: log(points, message_type='debug', title=str(self.farmwarename) + ' : load_points')
        filtered_points = []
        now = datetime.datetime.utcnow()
        for p in points:
            if p['pointer_type'].lower() == pointer_type.lower():
                b_meta = False
                age_day = (now - datetime.datetime.strptime(p['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ')).days
                if str(meta_key).lower() != 'none':
                    try:
                        b_meta = ((p['meta'][meta_key]).lower() == meta_value.lower())
                    except Exception as e:
                        b_meta = False
                else:
                    b_meta = True
                if str(min_x).lower() == 'none' or str(min_y).lower() == 'none' or str(max_x).lower() == 'none' or str(max_y).lower() == 'none':
                    b_coordinate = True
                else:
                    if int(min_x) <= int(p['x']) <= int(max_x) and int(min_y) <= int(p['y']) <= int(max_y):
                        b_coordinate = True
                    else:
                        b_coordinate = False
                if  (p['id'] == point_id or point_id == '*') and (p['name'].lower() == point_name.lower() or point_name == '*') and (p['openfarm_slug'].lower() == openfarm_slug.lower() or openfarm_slug == '*') and (age_min_day <= age_day <= age_max_day) and b_meta==True and b_coordinate :
                    filtered_points.append(p.copy())
        return filtered_points

    def load_points_with_filters(self):
        self.points = self.apply_filters(
            points=self.api.api_get('points'),
            point_id=self.input_id,
            point_name=self.input_pointname,
            openfarm_slug=self.input_openfarm_slug,
            age_min_day=self.input_age_min_day,
            age_max_day=self.input_age_max_day,
            meta_key=self.input_filter_meta_key,
            meta_value=self.input_filter_meta_value,
            min_x=self.input_filter_min_x,
            min_y=self.input_filter_min_y,
            max_x=self.input_filter_max_x,
            max_y=self.input_filter_max_y,
            pointer_type='Plant')
        if self.input_debug >= 1: log(self.points, message_type='debug', title=str(self.farmwarename) + ' : load_points_with_filters')
        

    def sort_points(self):
        self.points = sorted(self.points , key=lambda elem: (int(elem['x']), int(elem['y'])))
        if self.input_debug >= 1: log(self.points, message_type='debug', title=str(self.farmwarename) + ' : sort_points')
        #self.points, self.tab_id = Get_Optimal_Way(self.points)

    def save_data(self,point):
            log('Before : ' + str(point) , message_type='info', title=str(self.farmwarename) + ' : save_data')            
            if str(self.input_remove_all_metadata).lower() == 'yes':
                point['meta'] = {}
            if str(self.input_save_meta_key).lower() != 'none':
                point['meta'][self.input_save_meta_key]=self.input_save_meta_value
            if str(self.input_save_name).lower() != 'none':
                point['name']=self.input_save_name
            if str(self.input_save_date).lower() != 'none':
                if str(self.input_save_date).lower() == '#now#':
                    now = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%fZ')
                    point['created_at']= now
                    point['updated_at']= now
                else:
                    d = datetime.datetime.strptime(self.input_save_date, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%dT%H:%M:%S.%fZ')
                    point['created_at']= d
                    point['updated_at']= d
            if self.input_debug < 2 :    
                endpoint = 'points/{}'.format(point['id'])
                self.api.api_put(endpoint=endpoint, data=point)
            log('After : ' + str(point) , message_type='info', title=str(self.farmwarename) + ' : save_data')

    def loop_points(self):
        for p in self.points:
            self.save_data(p)
    
    
    def run(self):
        self.load_points_with_filters()
        self.sort_points()
        if len(self.points) > 0 : self.loop_points()
        
        
class MyFarmware():
    def get_input_env(self):
        prefix = self.farmwarename.lower().replace('-', '_')

        self.input_title = os.environ.get(prefix + "_title", '-')
        self.input_pointname = os.environ.get(prefix + "_pointname", '*')
        self.input_openfarm_slug = os.environ.get(prefix + "_openfarm_slug",
                                                  '*')
        self.input_age_min_day = int(
            os.environ.get(prefix + "_age_min_day", -1))
        self.input_age_max_day = int(
            os.environ.get(prefix + "_age_max_day", 36500))
        self.input_plant_stage = os.environ.get(prefix + "_plant_stage", '*')
        self.input_filter_meta_key = os.environ.get(
            prefix + "_filter_meta_key", 'None')
        self.input_filter_meta_value = os.environ.get(
            prefix + "_filter_meta_value", 'None')
        self.input_sequence_init = os.environ.get(prefix + "_sequence_init",
                                                  'None')
        self.input_sequence_beforemove = os.environ.get(
            prefix + "_sequence_beforemove", 'None')
        self.input_sequence_aftermove = os.environ.get(
            prefix + "_sequence_aftermove", 'None')
        self.input_sequence_end = os.environ.get(prefix + "_sequence_end",
                                                 'None')
        self.input_save_meta_key = os.environ.get(prefix + "_save_meta_key",
                                                  'None')
        self.input_save_meta_value = os.environ.get(
            prefix + "_save_meta_value", 'None')
        self.input_default_z = int(os.environ.get(prefix + "_default_z", 0))
        self.input_default_speed = int(
            os.environ.get(prefix + "_default_speed", 800))
        self.input_debug = int(os.environ.get(prefix + "_debug", 1))

        if self.input_debug >= 1:
            log('title: {}'.format(self.input_title),
                message_type='debug',
                title=self.farmwarename)
            log('pointname: {}'.format(self.input_pointname),
                message_type='debug',
                title=self.farmwarename)
            log('openfarm_slug: {}'.format(self.input_openfarm_slug),
                message_type='debug',
                title=self.farmwarename)
            log('age_min_day: {}'.format(self.input_age_min_day),
                message_type='debug',
                title=self.farmwarename)
            log('age_max_day: {}'.format(self.input_age_max_day),
                message_type='debug',
                title=self.farmwarename)
            log('filter_meta_key: {}'.format(self.input_filter_meta_key),
                message_type='debug',
                title=self.farmwarename)
            log('filter_meta_value: {}'.format(self.input_filter_meta_value),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_init: {}'.format(self.input_sequence_init),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_beforemove: {}'.format(
                self.input_sequence_beforemove),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_aftermove: {}'.format(self.input_sequence_aftermove),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_end: {}'.format(self.input_sequence_end),
                message_type='debug',
                title=self.farmwarename)
            log('save_meta_key: {}'.format(self.input_save_meta_key),
                message_type='debug',
                title=self.farmwarename)
            log('save_meta_value: {}'.format(self.input_save_meta_value),
                message_type='debug',
                title=self.farmwarename)
            log('default_z: {}'.format(self.input_default_z),
                message_type='debug',
                title=self.farmwarename)
            log('default_speed: {}'.format(self.input_default_speed),
                message_type='debug',
                title=self.farmwarename)
            log('debug: {}'.format(self.input_debug),
                message_type='debug',
                title=self.farmwarename)

    def __init__(self, farmwarename):
        self.farmwarename = farmwarename
        self.get_input_env()
        self.api = API(self)
        self.points = []

    def check_celerypy(self, ret):
        try:
            status_code = ret.status_code
        except:
            status_code = -1
        try:
            text = ret.text[:100]
        except expression as identifier:
            text = ret
        if status_code == -1 or status_code == 200:
            if self.input_debug >= 1:
                log("{} -> {}".format(status_code, text),
                    message_type='debug',
                    title=self.farmwarename + ' check_celerypy')
        else:
            log("{} -> {}".format(status_code, text),
                message_type='error',
                title=self.farmwarename + ' check_celerypy')
            raise

    def apply_filters(self,
                      points,
                      point_name='',
                      openfarm_slug='',
                      plant_stage='',
                      age_min_day=0,
                      age_max_day=36500,
                      meta_key='',
                      meta_value='',
                      pointer_type='Plant'):
        if self.input_debug >= 1:
            log(points,
                message_type='debug',
                title=str(self.farmwarename) + ' : load_points')
        filtered_points = []
        now = datetime.datetime.utcnow()
        for p in points:
            if p['pointer_type'].lower() == pointer_type.lower():
                b_meta = False
                age_day = (now - datetime.datetime.strptime(
                    p['created_at'], '%Y-%m-%dT%H:%M:%S.%fZ')).days
                if str(meta_key).lower() != 'none':
                    try:
                        b_meta = ((
                            p['meta'][meta_key]).lower() == meta_value.lower())
                    except Exception as e:
                        b_meta = False
                else:
                    b_meta = True
                if (p['name'].lower() == point_name.lower()
                        or point_name == '*'
                    ) and (p['openfarm_slug'].lower() == openfarm_slug.lower()
                           or openfarm_slug == '*') and (
                               p['plant_stage'].lower() == plant_stage.lower()
                               or plant_stage
                               == '*') and (age_min_day <= age_day <=
                                            age_max_day) and b_meta == True:
                    filtered_points.append(p.copy())
        return filtered_points

    def load_points_with_filters(self):
        self.points = self.apply_filters(
            points=self.api.api_get('points'),
            point_name=self.input_pointname,
            openfarm_slug=self.input_openfarm_slug,
            age_min_day=self.input_age_min_day,
            age_max_day=self.input_age_max_day,
            plant_stage=self.input_plant_stage,
            meta_key=self.input_filter_meta_key,
            meta_value=self.input_filter_meta_value,
            pointer_type='Plant')
        if self.input_debug >= 1:
            log(self.points,
                message_type='debug',
                title=str(self.farmwarename) + ' : load_points_with_filters')

    def sort_points(self):
        self.points = sorted(self.points,
                             key=lambda elem: (int(elem['x']), int(elem['y'])))
        if self.input_debug >= 1:
            log(self.points,
                message_type='debug',
                title=str(self.farmwarename) + ' : sort_points')
        #self.points, self.tab_id = Get_Optimal_Way(self.points)

    def load_sequences_id(self):
        self.sequences = self.api.api_get('sequences')
        self.input_sequence_init_id = -1
        self.input_sequence_beforemove_id = -1
        self.input_sequence_aftermove_id = -1
        self.input_sequence_end_id = -1
        for s in self.sequences:
            if str(s['name']).lower() == self.input_sequence_init.lower():
                self.input_sequence_init_id = int(s['id'])
            if str(s['name']).lower() == self.input_sequence_beforemove.lower(
            ):
                self.input_sequence_beforemove_id = int(s['id'])
            if str(s['name']).lower() == self.input_sequence_aftermove.lower():
                self.input_sequence_aftermove_id = int(s['id'])
            if str(s['name']).lower() == self.input_sequence_end.lower():
                self.input_sequence_end_id = int(s['id'])
        if self.input_debug >= 1:
            log('init: ' + self.input_sequence_init + ' id:' +
                str(self.input_sequence_init_id),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('before: ' + self.input_sequence_beforemove + ' id:' +
                str(self.input_sequence_beforemove_id),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('after: ' + self.input_sequence_aftermove + ' id:' +
                str(self.input_sequence_aftermove_id),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('end: ' + self.input_sequence_end + ' id:' +
                str(self.input_sequence_end_id),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')

    def execute_sequence_init(self):
        if self.input_sequence_init_id != -1:
            if self.input_debug >= 1:
                log('Execute Sequence: ' + self.input_sequence_init + ' id:' +
                    str(self.input_sequence_init_id),
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_init')
            if self.input_debug < 2:
                self.check_celerypy(
                    execute_sequence(sequence_id=self.input_sequence_init_id))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_init')

    def execute_sequence_before(self):
        if self.input_sequence_beforemove_id != -1:
            if self.input_debug >= 1:
                log('Execute Sequence: ' + self.input_sequence_beforemove +
                    ' id:' + str(self.input_sequence_beforemove_id),
                    message_type='debug',
                    title=str(self.farmwarename) +
                    ' : execute_sequence_before')
            if self.input_debug < 2:
                self.check_celerypy(
                    execute_sequence(
                        sequence_id=self.input_sequence_beforemove_id))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) +
                    ' : execute_sequence_before')

    def execute_sequence_after(self):
        if self.input_sequence_aftermove_id != -1:
            if self.input_debug >= 1:
                log('Execute Sequence: ' + self.input_sequence_aftermove +
                    ' id:' + str(self.input_sequence_aftermove_id),
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_after')
            if self.input_debug < 2:
                self.check_celerypy(
                    execute_sequence(
                        sequence_id=self.input_sequence_aftermove_id))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_after')

    def execute_sequence_end(self):
        if self.input_sequence_end_id != -1:
            if self.input_debug >= 1:
                log('Execute Sequence: ' + self.input_sequence_end + ' id:' +
                    str(self.input_sequence_end_id),
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_end')
            if self.input_debug < 2:
                self.check_celerypy(
                    execute_sequence(sequence_id=self.input_sequence_end_id))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_end')

    def move_absolute_point(self, point):
        if self.input_debug >= 1:
            log('Move absolute: ' + str(point),
                message_type='debug',
                title=str(self.farmwarename) + ' : move_absolute_point')
        if self.input_debug < 2:
            self.check_celerypy(
                move_absolute(
                    location=[point['x'], point['y'], self.input_default_z],
                    offset=[0, 0, 0],
                    speed=self.input_default_speed))

    def save_meta(self, point):
        if str(self.input_save_meta_key).lower() != 'none':
            if self.input_debug >= 1:
                log('Save Meta Information: ' + str(point['id']),
                    message_type='debug',
                    title=str(self.farmwarename) + ' : save_meta')
            if self.input_debug < 2:
                point['meta'][
                    self.input_save_meta_key] = self.input_save_meta_value
                endpoint = 'points/{}'.format(point['id'])
                self.api.api_put(endpoint=endpoint, data=point)

    def loop_points(self):
        for p in self.points:
            self.execute_sequence_before()
            self.move_absolute_point(p)
            self.execute_sequence_after()
            self.save_meta(p)

    def run(self):
        self.load_points_with_filters()
        self.sort_points()
        if len(self.points) > 0: self.load_sequences_id()
        if len(self.points) > 0: self.execute_sequence_init()
        if len(self.points) > 0: self.loop_points()
        if len(self.points) > 0: self.execute_sequence_end()
class MyFarmware():
    def get_input_env(self):
        prefix = self.farmwarename.lower().replace('-', '_')

        self.input_title = os.environ.get(prefix + "_title", '-')
        self.input_pointname = os.environ.get(prefix + "_pointname", '*')
        self.input_openfarm_slug = os.environ.get(prefix + "_openfarm_slug",
                                                  '*')
        self.input_age_min_day = int(
            os.environ.get(prefix + "_age_min_day", -1))
        self.input_age_max_day = int(
            os.environ.get(prefix + "_age_max_day", 36500))
        self.input_filter_meta_key = os.environ.get(
            prefix + "_filter_meta_key", 'None')
        self.input_filter_meta_op = os.environ.get(prefix + "_filter_meta_op",
                                                   'None')
        self.input_filter_meta_value = os.environ.get(
            prefix + "_filter_meta_value", 'None')
        self.input_filter_plant_stage = os.environ.get(
            prefix + "_filter_plant_stage", 'None')
        self.input_filter_min_x = os.environ.get(prefix + "_filter_min_x",
                                                 'None')
        self.input_filter_max_x = os.environ.get(prefix + "_filter_max_x",
                                                 'None')
        self.input_filter_min_y = os.environ.get(prefix + "_filter_min_y",
                                                 'None')
        self.input_filter_max_y = os.environ.get(prefix + "_filter_max_y",
                                                 'None')
        self.input_sequence_init = os.environ.get(prefix + "_sequence_init",
                                                  'None').split(",")
        self.input_sequence_beforemove = os.environ.get(
            prefix + "_sequence_beforemove", 'None').split(",")
        self.input_sequence_aftermove = os.environ.get(
            prefix + "_sequence_aftermove", 'None').split(",")
        self.input_sequence_end = os.environ.get(prefix + "_sequence_end",
                                                 'None').split(",")
        self.input_save_meta_key = os.environ.get(prefix + "_save_meta_key",
                                                  'None')
        self.input_save_meta_value = os.environ.get(
            prefix + "_save_meta_value", 'None')
        self.input_save_plant_stage = os.environ.get(
            prefix + "_save_plant_stage", 'None')
        self.input_offset_x = int(os.environ.get(prefix + "_offset_x", 0))
        self.input_offset_y = int(os.environ.get(prefix + "_offset_y", 0))
        self.input_default_z = int(os.environ.get(prefix + "_default_z", 0))
        self.input_default_speed = int(
            os.environ.get(prefix + "_default_speed", 800))
        self.input_debug = int(os.environ.get(prefix + "_debug", 2))

        if self.input_debug >= 1:
            log('title: {}'.format(self.input_title),
                message_type='debug',
                title=self.farmwarename)
            log('pointname: {}'.format(self.input_pointname),
                message_type='debug',
                title=self.farmwarename)
            log('openfarm_slug: {}'.format(self.input_openfarm_slug),
                message_type='debug',
                title=self.farmwarename)
            log('age_min_day: {}'.format(self.input_age_min_day),
                message_type='debug',
                title=self.farmwarename)
            log('age_max_day: {}'.format(self.input_age_max_day),
                message_type='debug',
                title=self.farmwarename)
            log('filter_meta_key: {}'.format(self.input_filter_meta_key),
                message_type='debug',
                title=self.farmwarename)
            log('filter_meta_op: {}'.format(self.input_filter_meta_op),
                message_type='debug',
                title=self.farmwarename)
            log('filter_meta_value: {}'.format(self.input_filter_meta_value),
                message_type='debug',
                title=self.farmwarename)
            log('filter_plant_stage: {}'.format(self.input_filter_plant_stage),
                message_type='debug',
                title=self.farmwarename)
            log('filter_min_x: {}'.format(self.input_filter_min_x),
                message_type='debug',
                title=self.farmwarename)
            log('filter_max_x: {}'.format(self.input_filter_max_x),
                message_type='debug',
                title=self.farmwarename)
            log('filter_min_y: {}'.format(self.input_filter_min_y),
                message_type='debug',
                title=self.farmwarename)
            log('filter_max_y: {}'.format(self.input_filter_max_y),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_init: {}'.format(self.input_sequence_init),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_beforemove: {}'.format(
                self.input_sequence_beforemove),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_aftermove: {}'.format(self.input_sequence_aftermove),
                message_type='debug',
                title=self.farmwarename)
            log('sequence_end: {}'.format(self.input_sequence_end),
                message_type='debug',
                title=self.farmwarename)
            log('save_meta_key: {}'.format(self.input_save_meta_key),
                message_type='debug',
                title=self.farmwarename)
            log('save_meta_value: {}'.format(self.input_save_meta_value),
                message_type='debug',
                title=self.farmwarename)
            log('save_plant_stage: {}'.format(self.input_save_plant_stage),
                message_type='debug',
                title=self.farmwarename)
            log('offset_x: {}'.format(self.input_offset_x),
                message_type='debug',
                title=self.farmwarename)
            log('offset_y: {}'.format(self.input_offset_y),
                message_type='debug',
                title=self.farmwarename)
            log('default_z: {}'.format(self.input_default_z),
                message_type='debug',
                title=self.farmwarename)
            log('default_speed: {}'.format(self.input_default_speed),
                message_type='debug',
                title=self.farmwarename)
            log('debug: {}'.format(self.input_debug),
                message_type='debug',
                title=self.farmwarename)

    def __init__(self, farmwarename):
        self.farmwarename = farmwarename
        self.get_input_env()
        self.api = API(self)
        self.points = []

    def check_celerypy(self, ret):
        try:
            status_code = ret.status_code
        except:
            status_code = -1
        try:
            text = ret.text[:100]
        except:
            text = ret
        if status_code == -1 or status_code == 200:
            if self.input_debug >= 1:
                log("{} -> {}".format(status_code, text),
                    message_type='debug',
                    title=self.farmwarename + ' check_celerypy')
        else:
            log("{} -> {}".format(status_code, text),
                message_type='error',
                title=self.farmwarename + ' check_celerypy')
            raise

    def apply_filters(self,
                      points,
                      point_name='',
                      openfarm_slug='',
                      age_min_day=0,
                      age_max_day=36500,
                      meta_key='',
                      meta_value='',
                      min_x='none',
                      max_x='none',
                      min_y='none',
                      max_y='none',
                      pointer_type='Plant',
                      plant_stage='none'):
        if self.input_debug >= 1:
            log(points,
                message_type='debug',
                title=str(self.farmwarename) + ' : load_points')
        filtered_points = []
        now = datetime.datetime.utcnow()
        for p in points:
            if p['pointer_type'].lower() == pointer_type.lower():
                b_meta = False
                if str(p['planted_at']).lower() == 'none' or str(
                        p['planted_at']).lower() == None:
                    ref_date = p['created_at']
                else:
                    ref_date = p['planted_at']
                age_day = (now - datetime.datetime.strptime(
                    ref_date, '%Y-%m-%dT%H:%M:%S.%fZ')).days
                if str(meta_key).lower() != 'none':
                    try:
                        if self.input_filter_meta_op.lower(
                        ) == "none" or self.input_filter_meta_op.lower(
                        ) == "==":
                            b_meta = ((p['meta'][meta_key]
                                       ).lower() == meta_value.lower())
                        elif self.input_filter_meta_op == ">=":
                            b_meta = ((p['meta'][meta_key]) >= meta_value)
                        elif self.input_filter_meta_op == "<=":
                            b_meta = ((p['meta'][meta_key]) <= meta_value)
                        elif self.input_filter_meta_op == "<":
                            b_meta = ((p['meta'][meta_key]) < meta_value)
                        elif self.input_filter_meta_op == ">":
                            b_meta = ((p['meta'][meta_key]) > meta_value)
                        elif self.input_filter_meta_op == "!=":
                            b_meta = ((p['meta'][meta_key]).lower() !=
                                      meta_value.lower())
                        elif self.input_filter_meta_op.lower() == "regex":
                            b_meta = bool(
                                re.compile(meta_value).match(
                                    p['meta'][meta_key]))
                        elif self.input_filter_meta_op.lower() == "daysmax":
                            b_meta = bool(
                                (datetime.datetime.utcnow() -
                                 datetime.datetime.strptime(
                                     p['meta'][meta_key],
                                     '%Y-%m-%d %H:%M:%S.%f')).total_seconds() /
                                86400 <= int(meta_value))
                        elif self.input_filter_meta_op.lower() == "minutesmax":
                            b_meta = bool(
                                (datetime.datetime.utcnow() -
                                 datetime.datetime.strptime(
                                     p['meta'][meta_key],
                                     '%Y-%m-%d %H:%M:%S.%f')).total_seconds() /
                                60 <= int(meta_value))
                        elif self.input_filter_meta_op.lower() == "daysmin":
                            b_meta = bool(
                                (datetime.datetime.utcnow() -
                                 datetime.datetime.strptime(
                                     p['meta'][meta_key],
                                     '%Y-%m-%d %H:%M:%S.%f')).total_seconds() /
                                86400 >= int(meta_value))
                        elif self.input_filter_meta_op.lower() == "minutesmin":
                            b_meta = bool(
                                (datetime.datetime.utcnow() -
                                 datetime.datetime.strptime(
                                     p['meta'][meta_key],
                                     '%Y-%m-%d %H:%M:%S.%f')).total_seconds() /
                                60 >= int(meta_value))
                        else:
                            b_meta = False
                    except Exception as e:
                        if self.input_debug >= 1:
                            log(e,
                                message_type='error',
                                title=str(self.farmwarename) +
                                ' : exception filter_meta')
                        b_meta = False
                else:
                    b_meta = True
                if str(min_x).lower() == 'none' or str(
                        max_x).lower() == 'none':
                    b_coordinate_x = True
                else:
                    if int(min_x) <= int(p['x']) <= int(max_x):
                        b_coordinate_x = True
                    else:
                        b_coordinate_x = False
                if str(min_y).lower() == 'none' or str(
                        max_y).lower() == 'none':
                    b_coordinate_y = True
                else:
                    if int(min_y) <= int(p['y']) <= int(max_y):
                        b_coordinate_y = True
                    else:
                        b_coordinate_y = False
                if plant_stage.lower() == 'none':
                    b_plantstage = True
                else:
                    try:
                        if plant_stage.lower() == p['plant_stage'].lower():
                            b_plantstage = True
                        else:
                            b_plantstage = False
                    except Exception as e:
                        b_plantstage = True
                if (p['name'].lower() == point_name.lower(
                ) or point_name == '*') and (p['openfarm_slug'].lower(
                ) == openfarm_slug.lower() or openfarm_slug == '*') and (
                        age_min_day <= age_day <= age_max_day
                ) and b_meta == True and b_coordinate_x and b_coordinate_y and b_plantstage:
                    filtered_points.append(p.copy())
        return filtered_points

    def load_points_with_filters(self):
        self.points = self.apply_filters(
            points=self.api.api_get('points'),
            point_name=self.input_pointname,
            openfarm_slug=self.input_openfarm_slug,
            age_min_day=self.input_age_min_day,
            age_max_day=self.input_age_max_day,
            meta_key=self.input_filter_meta_key,
            meta_value=self.input_filter_meta_value,
            min_x=self.input_filter_min_x,
            min_y=self.input_filter_min_y,
            max_x=self.input_filter_max_x,
            max_y=self.input_filter_max_y,
            pointer_type='Plant',
            plant_stage=self.input_filter_plant_stage)
        if self.input_debug >= 1:
            log(self.points,
                message_type='debug',
                title=str(self.farmwarename) + ' : load_points_with_filters')

    def sort_points(self):
        self.points = sorted(self.points,
                             key=lambda elem: (int(elem['x']), int(elem['y'])))
        if self.input_debug >= 1:
            log(self.points,
                message_type='debug',
                title=str(self.farmwarename) + ' : sort_points')
        #self.points, self.tab_id = Get_Optimal_Way(self.points)

    def load_sequences_id(self):
        self.sequences = self.api.api_get('sequences')
        self.input_sequence_init_dic = {}
        self.input_sequence_beforemove_dic = {}
        self.input_sequence_aftermove_dic = {}
        self.input_sequence_end_dic = {}
        for s in self.sequences:
            for e in self.input_sequence_init:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_init_dic[s['name']] = int(s['id'])
            for e in self.input_sequence_beforemove:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_beforemove_dic[s['name']] = int(
                        s['id'])
            for e in self.input_sequence_aftermove:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_aftermove_dic[s['name']] = int(s['id'])
            for e in self.input_sequence_end:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_end_dic[s['name']] = int(s['id'])
        if self.input_debug >= 1:
            log('init: {}'.format(self.input_sequence_init_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('before: {}'.format(self.input_sequence_beforemove_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('after: {}'.format(self.input_sequence_aftermove_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('end: {}'.format(self.input_sequence_end_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')

    def execute_sequence_init(self):
        if len(self.input_sequence_init_dic) != 0:
            for s in self.input_sequence_init_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_init_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_init')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_init_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_init')

    def execute_sequence_before(self):
        if len(self.input_sequence_beforemove_dic) != 0:
            for s in self.input_sequence_beforemove_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_beforemove_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_before')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_beforemove_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) +
                    ' : execute_sequence_before')

    def execute_sequence_after(self):
        if len(self.input_sequence_aftermove_dic) != 0:
            for s in self.input_sequence_aftermove_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_aftermove_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_after')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_aftermove_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_after')

    def execute_sequence_end(self):
        if len(self.input_sequence_end_dic) != 0:
            for s in self.input_sequence_end_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_end_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_end')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_end_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_end')

    def move_absolute_point(self, point):
        if self.input_debug >= 1:
            log('Move absolute: ' + str(point),
                message_type='debug',
                title=str(self.farmwarename) + ' : move_absolute_point')
        if self.input_debug < 2:
            self.check_celerypy(
                move_absolute(
                    location=[point['x'], point['y'], self.input_default_z],
                    offset=[self.input_offset_x, self.input_offset_y, 0],
                    speed=self.input_default_speed))

    def save_meta(self, point):
        if str(self.input_save_meta_key).lower() != 'none':
            if (self.input_save_meta_value.lower() == "#now#"):
                point['meta'][self.input_save_meta_key] = str(
                    datetime.datetime.utcnow())
            else:
                point['meta'][
                    self.input_save_meta_key] = self.input_save_meta_value
            if self.input_debug >= 1:
                log('Save Meta Information: ' + str(point),
                    message_type='debug',
                    title=str(self.farmwarename) + ' : save_meta')
            if self.input_debug < 2:
                endpoint = 'points/{}'.format(point['id'])
                self.api.api_put(endpoint=endpoint, data=point)

    def save_plant_stage(self, point):
        if str(self.input_save_plant_stage).lower() != 'none':
            if str(self.input_save_plant_stage).lower() == 'planned' or str(
                    self.input_save_plant_stage).lower() == 'planted' or str(
                        self.input_save_plant_stage
                    ).lower() == 'sprouted' or str(
                        self.input_save_plant_stage).lower() == 'harvested':
                point['plant_stage'] = str(self.input_save_plant_stage).lower()
                if str(self.input_save_plant_stage).lower() == 'planted':
                    point['planted_at'] = str(datetime.datetime.utcnow())
                if self.input_debug >= 1:
                    log('Save Plant Stage: ' + str(point),
                        message_type='debug',
                        title=str(self.farmwarename) + ' : save_plant_stage')
                if self.input_debug < 2:
                    endpoint = 'points/{}'.format(point['id'])
                    self.api.api_put(endpoint=endpoint, data=point)
            else:
                log('Save Plant Stage: wrong value :' + str(point),
                    message_type='error',
                    title=str(self.farmwarename) + ' : save_plant_stage')
        else:
            if self.input_debug >= 1:
                log('Plant Stage: Nothing to save',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : save_plant_stage')

    def loop_points(self):
        for p in self.points:
            self.execute_sequence_before()
            self.move_absolute_point(p)
            self.execute_sequence_after()
            self.save_meta(p)
            self.save_plant_stage(p)

    def run(self):
        self.load_points_with_filters()
        self.sort_points()
        if len(self.points) > 0: self.load_sequences_id()
        if len(self.points) > 0: self.execute_sequence_init()
        if len(self.points) > 0: self.loop_points()
        if len(self.points) > 0: self.execute_sequence_end()
class MyFarmware():
    def log_input(self):
        log('title: {}'.format(self.input_title),
            message_type='info',
            title=self.farmwarename)
        log('filter_min_x: {}'.format(self.input_filter_min_x),
            message_type='info',
            title=self.farmwarename)
        log('filter_max_x: {}'.format(self.input_filter_max_x),
            message_type='info',
            title=self.farmwarename)
        log('filter_min_y: {}'.format(self.input_filter_min_y),
            message_type='info',
            title=self.farmwarename)
        log('filter_max_y: {}'.format(self.input_filter_max_y),
            message_type='info',
            title=self.farmwarename)
        log('sequence_init: {}'.format(self.input_sequence_init),
            message_type='info',
            title=self.farmwarename)
        log('sequence_beforemove: {}'.format(self.input_sequence_beforemove),
            message_type='info',
            title=self.farmwarename)
        log('sequence_aftermove: {}'.format(self.input_sequence_aftermove),
            message_type='info',
            title=self.farmwarename)
        log('sequence_end: {}'.format(self.input_sequence_end),
            message_type='info',
            title=self.farmwarename)
        log('offset_x: {}'.format(self.input_offset_x),
            message_type='info',
            title=self.farmwarename)
        log('offset_y: {}'.format(self.input_offset_y),
            message_type='info',
            title=self.farmwarename)
        log('default_z: {}'.format(self.input_default_z),
            message_type='info',
            title=self.farmwarename)
        log('default_speed: {}'.format(self.input_default_speed),
            message_type='info',
            title=self.farmwarename)
        log('debug: {}'.format(self.input_debug),
            message_type='info',
            title=self.farmwarename)

    def __init__(self, farmwarename):
        self.farmwarename = farmwarename
        self.input_sequence_init_dic = {}
        self.input_sequence_beforemove_dic = {}
        self.input_sequence_aftermove_dic = {}
        self.input_sequence_end_dic = {}
        self.input_title = get_config_value(self.farmwarename,
                                            'title',
                                            value_type=str)
        self.input_filter_min_x = get_config_value(self.farmwarename,
                                                   'filter_min_x',
                                                   value_type=str)
        self.input_filter_max_x = get_config_value(self.farmwarename,
                                                   'filter_max_x',
                                                   value_type=str)
        self.input_filter_min_y = get_config_value(self.farmwarename,
                                                   'filter_min_y',
                                                   value_type=str)
        self.input_filter_max_y = get_config_value(self.farmwarename,
                                                   'filter_max_y',
                                                   value_type=str)
        self.input_sequence_init = get_config_value(self.farmwarename,
                                                    'sequence_init',
                                                    value_type=str).split(",")
        self.input_sequence_beforemove = get_config_value(
            self.farmwarename, 'sequence_beforemove',
            value_type=str).split(",")
        self.input_sequence_aftermove = get_config_value(
            self.farmwarename, 'sequence_aftermove', value_type=str).split(",")
        self.input_sequence_end = get_config_value(self.farmwarename,
                                                   'sequence_end',
                                                   value_type=str).split(",")
        self.input_offset_x = get_config_value(self.farmwarename,
                                               'offset_x',
                                               value_type=int)
        self.input_offset_y = get_config_value(self.farmwarename,
                                               'offset_y',
                                               value_type=int)
        self.input_default_z = get_config_value(self.farmwarename,
                                                'default_z',
                                                value_type=int)
        self.input_default_speed = get_config_value(self.farmwarename,
                                                    'default_speed',
                                                    value_type=int)
        self.input_debug = get_config_value(self.farmwarename,
                                            'debug',
                                            value_type=int)
        self.api = API(self.input_debug)

    def check_celerypy(self, ret):
        try:
            status_code = ret.status_code
        except:
            status_code = -1
        try:
            text = ret.text[:100]
        except:
            text = ret
        if status_code == -1 or status_code == 200:
            if self.input_debug >= 1:
                log("{} -> {}".format(status_code, text),
                    message_type='debug',
                    title=self.farmwarename + ' check_celerypy')
        else:
            log("{} -> {}".format(status_code, text),
                message_type='error',
                title=self.farmwarename + ' check_celerypy')
            raise

    @staticmethod
    def get_weeds_in_range(points,
                           min_x='none',
                           max_x='none',
                           min_y='none',
                           max_y='none'):
        weeds = filter(lambda point: point['name'].lower() == 'weed', points)
        weeds_in_range = filter(
            lambda point: MyFarmware.filter_coordinates(
                point, min_x, max_x, min_y, max_y), weeds)
        return weeds_in_range

    @staticmethod
    def filter_coordinates(point,
                           min_x='none',
                           max_x='none',
                           min_y='none',
                           max_y='none'):
        within_x_min = str(min_x).lower() == 'none' or int(min_x) <= int(
            point['x'])
        within_x_max = str(max_x).lower() == 'none' or int(max_x) >= int(
            point['x'])

        within_y_min = str(min_y).lower() == 'none' or int(min_y) <= int(
            point['y'])
        within_y_max = str(max_y).lower() == 'none' or int(max_y) >= int(
            point['y'])
        return within_x_max and within_x_min and within_y_min and within_y_max

    def load_weeds(self):
        return MyFarmware.get_weeds_in_range(points=self.api.api_get('points'),
                                             min_x=self.input_filter_min_x,
                                             min_y=self.input_filter_min_y,
                                             max_x=self.input_filter_max_x,
                                             max_y=self.input_filter_max_y)

    @staticmethod
    def sort_points(points):
        return sorted(points,
                      key=lambda elem: (int(elem['x']), int(elem['y'])))

    def load_sequences_id(self):
        sequences = self.api.api_get('sequences')

        for s in sequences:
            for e in self.input_sequence_init:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_init_dic[s['name']] = int(s['id'])
            for e in self.input_sequence_beforemove:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_beforemove_dic[s['name']] = int(
                        s['id'])
            for e in self.input_sequence_aftermove:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_aftermove_dic[s['name']] = int(s['id'])
            for e in self.input_sequence_end:
                if str(s['name']).lower() == e.lower():
                    self.input_sequence_end_dic[s['name']] = int(s['id'])
        if self.input_debug >= 1:
            log('init: {}'.format(self.input_sequence_init_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('before: {}'.format(self.input_sequence_beforemove_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('after: {}'.format(self.input_sequence_aftermove_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')
            log('end: {}'.format(self.input_sequence_end_dic),
                message_type='debug',
                title=str(self.farmwarename) + ' : load_sequences_id')

    def execute_sequence_init(self):
        if len(self.input_sequence_init_dic) != 0:
            for s in self.input_sequence_init_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_init_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_init')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_init_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_init')

    def execute_sequence_before(self):
        if len(self.input_sequence_beforemove_dic) != 0:
            for s in self.input_sequence_beforemove_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_beforemove_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_before')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_beforemove_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) +
                    ' : execute_sequence_before')

    def execute_sequence_after(self):
        if len(self.input_sequence_aftermove_dic) != 0:
            for s in self.input_sequence_aftermove_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_aftermove_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_after')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_aftermove_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_after')

    def execute_sequence_end(self):
        if len(self.input_sequence_end_dic) != 0:
            for s in self.input_sequence_end_dic:
                if self.input_debug >= 1:
                    log('Execute Sequence: {} id: {}'.format(
                        s, self.input_sequence_end_dic[s]),
                        message_type='debug',
                        title=str(self.farmwarename) +
                        ' : execute_sequence_end')
                if self.input_debug < 2:
                    self.check_celerypy(
                        execute_sequence(
                            sequence_id=self.input_sequence_end_dic[s]))
        else:
            if self.input_debug >= 1:
                log('Sequence Not Found',
                    message_type='debug',
                    title=str(self.farmwarename) + ' : execute_sequence_end')

    def move_absolute_point(self, point):
        if self.input_debug >= 1:
            log('Move absolute: ' + str(point),
                message_type='debug',
                title=str(self.farmwarename) + ' : move_absolute_point')
        if self.input_debug < 2:
            self.check_celerypy(
                move_absolute(
                    location=[point['x'], point['y'], self.input_default_z],
                    offset=[self.input_offset_x, self.input_offset_y, 0],
                    speed=self.input_default_speed))

    def loop_points(self, points):
        for p in points:
            self.execute_sequence_before()
            self.move_absolute_point(p)
            self.execute_sequence_after()

    def run(self):
        self.log_input()
        weeds = self.load_weeds()
        if self.input_debug >= 1:
            log(weeds,
                message_type='debug',
                title=str(self.farmwarename) + ' weeds')
        sorted_weeds = MyFarmware.sort_points(weeds)
        if self.input_debug >= 1:
            log(sorted_weeds,
                message_type='debug',
                title=str(self.farmwarename) + ' : sorted_weeds')

        if len(sorted_weeds) > 0: self.load_sequences_id()
        if len(sorted_weeds) > 0: self.execute_sequence_init()
        if len(sorted_weeds) > 0: self.loop_points(sorted_weeds)
        if len(sorted_weeds) > 0: self.execute_sequence_end()
Exemple #5
0
class MyFarmware():
    def get_input_env(self):
        prefix = self.farmwarename.lower().replace('-', '_')

        self.input_title = os.environ.get(prefix + "_title", '-')
        self.input_tool = os.environ.get(prefix + "_tool", 'BACKUP_USERENV')
        self.input_debug = int(os.environ.get(prefix + "_debug", 1))

        if self.input_debug >= 1:
            log('title: {}'.format(self.input_title),
                message_type='debug',
                title=self.farmwarename)
            log('tool: {}'.format(self.input_tool),
                message_type='debug',
                title=self.farmwarename)
            log('debug: {}'.format(self.input_debug),
                message_type='debug',
                title=self.farmwarename)

    def __init__(self, farmwarename):
        self.farmwarename = farmwarename
        self.get_input_env()
        self.api = API(self)
        self.points = []

    def check_celerypy(self, ret):
        try:
            status_code = ret.status_code
        except:
            status_code = -1
        try:
            text = ret.text[:100]
        except expression as identifier:
            text = ret
        if status_code == -1 or status_code == 200:
            if self.input_debug >= 1:
                log("{} -> {}".format(status_code, text),
                    message_type='debug',
                    title=self.farmwarename + ' check_celerypy')
        else:
            log("{} -> {}".format(status_code, text),
                message_type='error',
                title=self.farmwarename + ' check_celerypy')
            raise

    def get_toolslot(self,
                     points,
                     tools,
                     tool_name='',
                     pointer_type='ToolSlot'):
        for t in tools:
            if t['name'].lower() == tool_name.lower():
                for p in points:
                    if p['pointer_type'].lower() == pointer_type.lower():
                        if p['tool_id'] == t['id']:
                            return p.copy()

        return

    def backup_bot_state(self):
        self.botstate = get_bot_state()
        if self.input_debug >= 1:
            log('botstate: {}'.format(self.botstate),
                message_type='debug',
                title=self.farmwarename)
        self.toolslot = self.get_toolslot(points=self.api.api_get('points'),
                                          tools=self.api.api_get('tools'),
                                          tool_name=self.input_tool)
        if self.input_debug >= 1:
            log('toolslot Before: {}'.format(self.toolslot),
                message_type='debug',
                title=self.farmwarename)
        self.toolslot['meta'] = self.botstate["user_env"]
        if self.input_debug < 2:
            endpoint = 'points/{}'.format(self.toolslot['id'])
            self.api.api_put(endpoint=endpoint, data=self.toolslot)
        self.toolslot = self.get_toolslot(points=self.api.api_get('points'),
                                          tools=self.api.api_get('tools'),
                                          tool_name=self.input_tool)
        if self.input_debug >= 1:
            log('toolslot After: {}'.format(self.toolslot),
                message_type='debug',
                title=self.farmwarename)

    def restore_bot_state(self):
        self.botstate = get_bot_state()
        if self.input_debug >= 1:
            log('botstate Before: {}'.format(self.botstate),
                message_type='debug',
                title=self.farmwarename)
        self.toolslot = self.get_toolslot(points=self.api.api_get('points'),
                                          tools=self.api.api_get('tools'),
                                          tool_name=self.input_tool)
        if self.input_debug >= 1:
            log('toolslot: {}'.format(self.toolslot),
                message_type='debug',
                title=self.farmwarename)
        for e in self.toolslot['meta']:
            if self.input_debug >= 1:
                log('set_user_env: {} => {}'.format(e,
                                                    self.toolslot['meta'][e]),
                    message_type='debug',
                    title=self.farmwarename)
            if self.input_debug < 2:
                self.check_celerypy(set_user_env(e, self.toolslot['meta'][e]))

    def run(self):
        if "restore" in self.farmwarename.lower(): self.restore_bot_state()
        if "backup" in self.farmwarename.lower(): self.backup_bot_state()