コード例 #1
0
    def __init__(
        self,
        table_name,
        required_insert_names,
        return_col_names=[],
        optional_insert_names=[],
        default_insert_values={},
        *args,
        **kwargs
    ):
        """
        ~Params
            table_name (str): name of the table to insert to
            required_insert_names (list): list of names (str) of the table columns which must be included on every requested insert
            return_col_names (list): list of names (str) of columns whose values should be returned on completion of the insert
            optional_insert_names (list): list of names (str) of columns which the user may specify on an insert request, but which may be omitted
            default_insert_values (dict): dictionary of {column_names: values} to serve as defaults when inserting, any values provided explicitly on the insert request will override these values
        ~Params
        """
        Endpoint.__init__(self, *args, **kwargs)

        self._table_name = table_name
        self._return_names = return_col_names
        self._required_insert_names = required_insert_names
        self._optional_insert_names = optional_insert_names
        self._default_insert_dict = default_insert_values
 def __init__(self,
              conditional_insert_field,
              spectrum_field,
              sensor_name_mean,
              sensor_name_std,
              do_upsert=False,
              *args,
              **kwargs):
     '''
     do_upsert (bool): indicates if conflicting inserts should then update
     conditional_insert_field (string): name of an input kwarg field on inserts to cast to bool and determine if a log should be inserted
                                        default is true if the field is missing
     spectrum_field (string): name of an input kwarg field on inserts which contains an iterable of values for which moments will be calculated
     sensor_name_mean (string): name of the sensor to log with the mean of the spectrum
     sensor_name_std (string): name of the sensor to log with the STD of the spectrum
     '''
     if not 'sqlalchemy' in globals():
         raise ImportError(
             'SQLAlchemy not found, required for SQLTable class')
     self.conditional_insert_field = conditional_insert_field
     self.spectrum_field = spectrum_field
     self.sensor_name_mean = sensor_name_mean
     self.sensor_name_std = sensor_name_std
     Endpoint.__init__(self, *args, **kwargs)
     SQLTable.__init__(self, *args, **kwargs)
     self.do_upsert = do_upsert
コード例 #3
0
 def __init__(self,
              table_name,
              schema=None,
              required_insert_names=[],
              return_col_names=[],
              optional_insert_names=[],
              default_insert_values={},
              *args,
              **kwargs):
     '''
     table_name (str): name of the table within the database
     schema (str): name of the schema where the table is located
     required_insert_names (list): list of names (str||dict) of the table columns which must be included on every requested insert (if dict: keys are 'column' and 'payload_key', if string it is assumed that both are that value)
     return_col_names (list): list of names (str) of columns whose values should be returned on completion of the insert
     optional_insert_names (list): list of names (str||dict) of columns which the user may specify on an insert request, but which may be omitted (if dict: keys are 'column' and 'payload_key', if string it is assumed that both are that value)
     default_insert_values (dict): dictionary of {column_names: values} to serve as defaults when inserting, any values provided explicitly on the insert request will override these values
     '''
     if not 'sqlalchemy' in globals():
         raise ImportError(
             'SQLAlchemy not found, required for SQLTable class')
     Endpoint.__init__(self, *args, **kwargs)
     self.table = None
     self.table_name = table_name
     self.schema = schema
     self._return_names = return_col_names
     self._column_map = {}
     self._required_insert_names = self._ensure_col_key_map(
         required_insert_names)
     self._optional_insert_names = self._ensure_col_key_map(
         optional_insert_names)
     self._default_insert_dict = default_insert_values
コード例 #4
0
ファイル: alert_spammer.py プロジェクト: project8/dragonfly
    def __init__(self,broker=None,sleep_time = 10,*args, **kwargs):

        Endpoint.__init__(self,**kwargs)

        # setting the interface
        self.connection_to_alert = dripline.core.Service(broker=broker, exchange='alerts',keys='status_message.p8_alerts.dripline')

        #sending a welcome message
        self.this_channel = 'p8_alerts'
        self.username = self.name
        self.sleep_time = sleep_time
コード例 #5
0
 def __init__(self, do_upsert=False, ignore_keys=[], *args, **kwargs):
     '''
     do_upsert (bool): indicates if conflicting inserts should then update
     ignore_keys (list of strings): list of names of payload keys which should not be mapped to columns on an insert, even if present
     '''
     if not 'sqlalchemy' in globals():
         raise ImportError(
             'SQLAlchemy not found, required for SQLTable class')
     self.ignore_keys = ignore_keys
     Endpoint.__init__(self, *args, **kwargs)
     SQLTable.__init__(self, *args, **kwargs)
     self.do_upsert = do_upsert
コード例 #6
0
ファイル: multido.py プロジェクト: project8/dragonfly
    def __init__(self, targets=[], **kwargs):
        '''
        targets (list): list of dictionaries which must provide a value for 'target', other optional fields:
          default_set: always set endpoint to this value
          payload_field (str): return payload field to get (value_cal, value_raw, or values)
          units (str): display units for 'calibrated' return value
          formatter (str): special formatting for 'calibrated' return string
          tolerance: check tolerance
          no_check (bool): disable set_and_check; necessary for set-only endpoints!
          get_target (str): endpoint to get for check (default is 'target')
          target_value: alternate value to check against
        '''
        Endpoint.__init__(self, **kwargs)
        self._targets = []
        for a_target in targets:
            these_details = {}
            ## SET options
            if 'default_set' in a_target:
                these_details.update({'default_set':a_target['default_set']})
            ## GET options
            if 'payload_field' in a_target:
                these_details.update({'payload_field':a_target['payload_field']})
            else:
                these_details.update({'payload_field':'value_cal'})
            if 'units' in a_target and 'formatter' in a_target:
                raise exceptions.DriplineValueError('may not specify both "units" and "formatter"')
            if 'formatter' in a_target:
                these_details['formatter'] = a_target['formatter']
            elif 'units' in a_target:
                these_details['formatter'] = '{} -> {} [{}]'.format(a_target['target'], '{}', a_target['units'])
            else:
                these_details['formatter'] = '{} -> {}'.format(a_target['target'], '{}')
            ## CHECK options
            if 'tolerance' in a_target:
                these_details.update({'tolerance':a_target['tolerance']})
            else:
                these_details.update({'tolerance': 1.})
            if 'no_check' in a_target:
                these_details.update({'no_check':a_target['no_check']})
            else:
                these_details.update({'no_check':False})
            if 'get_target' in a_target:
                these_details.update({'get_name':a_target['get_target']})
            else:
                these_details.update({'get_name':a_target['target']})
            if 'target_value' in a_target:
                these_details.update({'target_value':a_target['target_value']})

            self._targets.append([a_target['target'], these_details])
コード例 #7
0
ファイル: step_attenuator.py プロジェクト: project8/dragonfly
 def __init__(self, file_name="/tmp/step_atten.txt", **kwargs):
     self.file_name=file_name
     Endpoint.__init__(self, **kwargs)