Sets the N1QL profile type. Must be one of: 'off', 'phases', 'timings'
        :param value: The profile type to use.
        :return:
199611
def profile(self, value):
        
        if value not in VALID_PROFILES:
            raise TypeError('Profile option must be one of: ' + ', '.join(VALID_PROFILES))

        self._body['profile'] = value
1334909
public void profile(IoEventType type) {
        switch (type) {
            case MESSAGE_RECEIVED :
                profileMessageReceived = true;
                
                if (messageReceivedTimerWorker == null) {
                    messageReceivedTimerWorker = new TimerWorker();
                }
                
                return;
                
            case MESSAGE_SENT :
                profileMessageSent = true;
                
                if (messageSentTimerWorker == null) {
                    messageSentTimerWorker = new TimerWorker();
                }
                
                return;
                
            case SESSION_CREATED :
                profileSessionCreated = true;
                
                if (sessionCreatedTimerWorker == null) {
                    sessionCreatedTimerWorker = new TimerWorker();
                }
                
            case SESSION_OPENED :
                profileSessionOpened = true;
                
                if (sessionOpenedTimerWorker == null) {
                    sessionOpenedTimerWorker = new TimerWorker();
                }
                
            case SESSION_IDLE :
                profileSessionIdle = true;
                
                if (sessionIdleTimerWorker == null) {
                    sessionIdleTimerWorker = new TimerWorker();
                }
                
            case SESSION_CLOSED :
                profileSessionClosed = true;
                
                if (sessionClosedTimerWorker == null) {
                    sessionClosedTimerWorker = new TimerWorker();
                }
        }
    }
432392
async def set(self, key, value):
        
        if not check_dht_value_type(value):
            raise TypeError(
                "Value must be of type int, float, bool, str, or bytes"
            )
        log.info("setting '%s' = '%s' on network", key, value)
        dkey = digest(key)
        return await self.set_digest(dkey, value)
477824
public void stopProfile(IoEventType type) {
        switch (type) {
            case MESSAGE_RECEIVED :
                profileMessageReceived = false;
                return;
                
            case MESSAGE_SENT :
                profileMessageSent = false;
                return;
                
            case SESSION_CREATED :
                profileSessionCreated = false;
                return;

            case SESSION_OPENED :
                profileSessionOpened = false;
                return;

            case SESSION_IDLE :
                profileSessionIdle = false;
                return;

            case SESSION_CLOSED :
                profileSessionClosed = false;
                return;
        }
    }
1052507
def file_type(self, value):
        
        if isinstance(value, FileType):
            self._file_type = value
        else:
            self._file_type = FileType(value)
21949
public void setQuery(Profile<S, C> query) {
		this.query = query;
		queryFuture = null;
		reset();
	}
1275803
public void updateProfile(ProfileFieldValues values) {
		getResourceFactory().getApiResource("/user/profile/")
				.entity(values, MediaType.APPLICATION_JSON_TYPE).put();
	}
1363346
def auto_detect(self, value):
        
        if isinstance(value, bool):
            if self.autodetect is not value:
                self._verify_proxy_type_compatibility(ProxyType.AUTODETECT)
                self.proxyType = ProxyType.AUTODETECT
                self.autodetect = value
        else:
            raise ValueError("Autodetect proxy value needs to be a boolean")
290862
def set_type(self,type):
    
    self.add_var_opt('type',str(type))
    self.__type = str(type)
    self.__set_output()
294099
def _setns(self, value):
        
        if self.conn is not None:
            self.conn.default_namespace = value
        else:
            self.__default_namespace = value
426499
def value_type(value):
    
    try:
        keys = list(value.keys())
    except AttributeError:
        return "simple"
    if keys in [["lookup"], ["re_lookup"], ["interval"]]:
        return keys[0]
    raise ValueError("Type of `value` could not be determined")
1100064
def compliance(self, value):
        """"""
        if (self.api_version < '2.0'):
            self.profile = value
        else:
            try:
                self.profile[0] = value
            except AttributeError:
                # handle case where profile not initialized as array
                self.profile = [value]
267070
def set_clock_type(type):
    
    type = type.upper()
    if type not in CLOCK_TYPES:
        raise YappiError("Invalid clock type:%s" % (type))
        
    _yappi.set_clock_type(CLOCK_TYPES[type])
588103
def set_swimlane(self, value):
        
        value = value or []

        self._initial_value_to_ids_map = defaultdict(list)
        for item in value:
            self._initial_value_to_ids_map[item['value']].append(item['id'])

        return super(ListField, self).set_swimlane([d['value'] for d in value])
1193192
def set(self, value):
        

        if not isinstance(value, byte_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a byte string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._native = value
        self.contents = value
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
523209
def setTableType(self, tableType):
        
        if tableType == self._tableType:
            return
        
        self._initialized = False
        self._tableType = tableType
        self.setQuery(Query())
127104
def set_one_time_boot(self, value):
        
        dic = {'value': value}
        data = self._execute_command(
            'SET_ONE_TIME_BOOT', 'SERVER_INFO', 'write', dic)
        return data