Get an entry from the Special sensor log.

        :param index: Index for the sensor log entry to be obtained.
        :return: Response containing the sensor log entry, or None if not found.
1900
async def async_get_sensor_log(self, index: int) -> Optional[SensorLogResponse]:
        

        response = await self._protocol.async_execute(
            GetSensorLogCommand(index))
        if isinstance(response, SensorLogResponse):
            return response
        return None
537976
public function getLog($index = null)
    {
        if (is_null($index)) {
            return $this->log;
        }

        return $this->log[$index];
    }
520846
public MessageArg get(int index) {
    return index < args.size() ? args.get(index) : null;
  }
838512
private Entry find(int index) // throws IndexOutOfBoundsException
    {
        // if (index < 0 || index > size())
        // throw new IndexOutOfBoundsException();

        // System.out.print("find: " + index + " (");
        for (Entry entry = head; entry != null; entry = entry.getNext()) {
            // System.out.print(entry.getIndex() + ":" + entry.getValue() +
            // " ");
            if (entry.getIndex() == index)
                return entry;
        } // end for

        // System.out.print(")\n");
        return null;
    }
263763
def _get_by_index(self, index):
        """"""
        volume_or_disk = self.parser.get_by_index(index)
        volume, disk = (volume_or_disk, None) if not isinstance(volume_or_disk, Disk) else (None, volume_or_disk)
        return volume, disk
616610
def sg_query_streamer(self, index):
        """"""

        resp = self.sensor_graph.query_streamer(index)
        if resp is None:
            return [struct.pack("<L", _pack_sgerror(SensorGraphError.STREAMER_NOT_ALLOCATED))]

        return [struct.pack("<LLLLBBBx", *resp)]
1118340
public Object get(int index)
    {
        if ((index - m_iStartIndex < 0) || (index - m_iStartIndex >= this.size()))
            return null;    // Not in current list
        return super.get(index - m_iStartIndex);
    }
1358334
def read_sensor(self, device_id, sensor_uri):
        """"""
        url = MINUT_DEVICES_URL + "/{device_id}/{sensor_uri}".format(
            device_id=device_id, sensor_uri=sensor_uri)
        res = self._request(url, request_type='GET', data={'limit': 1})
        if not res.get('values'):
            return None
        return res.get('values')[-1].get('value')
1162563
def get_sensors(self):
        
        return {i.name: i.status for i in self.system.sensors}
1077989
def _get_single_index_request(self, index, set_to_value=False, value=None):
        '''
        
        '''
        adjusted_index = index
        # Multiply by step length
        if self.range.step:
            step = self.range.step
            adjusted_index *= self.range.step
        else:
            step = 1

        # Adjust for negative indicies
        adjusted_index = get_non_negative_index(adjusted_index, self._length)
        # Push forward by start length
        if self.range.start != None:
            adjusted_index += self.range.start
        # Push forward by start length
        stop_index = self.range.stop if self.range.stop != None else self._length*step
        if adjusted_index > stop_index:
            raise IndexError(index)
        elem = self._data[adjusted_index]
        # Check if we have further dimension requirements
        # NOTE: if we're given dimensions for non-dimensional data,
        # this will blow up with an IndexError -- user should
        # not define this dimension with any restrictions
        if len(self._dim_ranges) > 1:
            if not has_len(elem):
                # We throw an IndexError instead of an AttributeError
                # because if can be caused by either sublist requests
                # or a bad constructor, and it's usually the former.
                raise IndexError("Element restricted by dimension_ranges "+
                                 str(self._dim_ranges[1:])+" is not subscriptable: "+
                                 "Dimension cannot be applied to elements with no len()")
            return self.builder(elem, *self._dim_ranges[1:])
        else:
            if set_to_value:
                self._data[adjusted_index] = value
            return elem
668036
def get_index_node(self, idx):
        ''''''
        idx = self.node_index.index(idx)
        return self.nodes[idx]
1095162
def get_parameter(self, index):
        
        result = []
        for target in self.targets:
            if target is not None:
                result.append(target.get_parameter(index))

        return result
1367851
def get(self, index):
        
        data = self.data
        index2 = self._split(index)
        for c in index2[:-1]:
            i = int(c) - 1
            data = data[i][4]
        return [index[:-2] or ""] + data[int(index[-1]) - 1]
640903
def get_node(self, index):
        

        index = self.mapToSource(index)
        if not index.isValid():
            return self.sourceModel().root_node

        return index.internalPointer() or self.sourceModel().root_node
1348337
@SuppressWarnings("unchecked")
  public <T extends Entry> T get(long index) {
    Entry entry = buffer[offset(index)];
    return entry != null && entry.getIndex() == index ? (T) entry.acquire() : null;
  }
418043
def get_index(index_name, *partition_indices):  # pragma: no cover
    """"""
    index = partition_indices[0].append(partition_indices[1:])
    index.names = index_name
    return index
1225345
def extract_index(index_data, global_index=False):
    '''
    
    '''
    parsed_data = {}
    keys = []

    for key, value in six.iteritems(index_data):
        for item in value:
            for field, data in six.iteritems(item):
                if field == 'hash_key':
                    parsed_data['hash_key'] = data
                elif field == 'hash_key_data_type':
                    parsed_data['hash_key_data_type'] = data
                elif field == 'range_key':
                    parsed_data['range_key'] = data
                elif field == 'range_key_data_type':
                    parsed_data['range_key_data_type'] = data
                elif field == 'name':
                    parsed_data['name'] = data
                elif field == 'read_capacity_units':
                    parsed_data['read_capacity_units'] = data
                elif field == 'write_capacity_units':
                    parsed_data['write_capacity_units'] = data
                elif field == 'includes':
                    parsed_data['includes'] = data
                elif field == 'keys_only':
                    parsed_data['keys_only'] = True

    if parsed_data['hash_key']:
        keys.append(
            HashKey(
                parsed_data['hash_key'],
                data_type=parsed_data['hash_key_data_type']
            )
        )
    if parsed_data.get('range_key'):
        keys.append(
            RangeKey(
                parsed_data['range_key'],
                data_type=parsed_data['range_key_data_type']
            )
        )
    if (
            global_index and
            parsed_data['read_capacity_units'] and
            parsed_data['write_capacity_units']):
        parsed_data['throughput'] = {
            'read':     parsed_data['read_capacity_units'],
            'write':    parsed_data['write_capacity_units']
        }
    if parsed_data['name'] and keys:
        if global_index:
            if parsed_data.get('keys_only') and parsed_data.get('includes'):
                raise SaltInvocationError('Only one type of GSI projection can be used.')

            if parsed_data.get('includes'):
                return GlobalIncludeIndex(
                    parsed_data['name'],
                    parts=keys,
                    throughput=parsed_data['throughput'],
                    includes=parsed_data['includes']
                )
            elif parsed_data.get('keys_only'):
                return GlobalKeysOnlyIndex(
                    parsed_data['name'],
                    parts=keys,
                    throughput=parsed_data['throughput'],
                )
            else:
                return GlobalAllIndex(
                    parsed_data['name'],
                    parts=keys,
                    throughput=parsed_data['throughput']
                )
        else:
            return AllIndex(
                parsed_data['name'],
                parts=keys
            )