Return True if someone known has been seen
490072
def someoneKnownSeen(self, home=None, camera=None):
        
        try:
            cam_id = self.cameraByName(camera=camera, home=home)['id']
        except TypeError:
            logger.warning("personSeenByCamera: Camera name or home is unknown")
            return False
        #Check in the last event is someone known has been seen
        if self.lastEvent[cam_id]['type'] == 'person':
            if self.lastEvent[cam_id]['person_id'] in self._knownPersons():
                return True
        return False
1151898
function (username, channel) {
        var list = this.getUserNotifications(username);
        // if we are not tracking the user there is no notifications
        if (list === null) {
            return false;
        }

        // return if the channel is in the users list
        return list.indexOf(channel) >= 0;
    }
622339
def hidden(self):
        """"""
        members = [self.member_info(item["_id"]) for item in self.members()]
        result = []
        for member in members:
            if member['rsInfo'].get('hidden'):
                server_id = member['server_id']
                result.append({
                    '_id': member['_id'],
                    'host': self._servers.hostname(server_id),
                    'server_id': server_id})
        return result
536524
def who_has(self, subid):
        """"""

        answer = []
        for name in self.__map:
            if subid in self.__map[name] and not name in answer:
                answer.append(name)

        return answer
896047
async function isAlreadyFollowing(follower, following) {
    //check
    let followers = await ga.golos.golos.api.getFollowersAsync(following, follower, "blog", 1);
    if(followers && followers.length == 1 && followers[0].follower == follower) {
        info(JSON.stringify(followers[0]));
        return true;
    }
    return false;
}
117094
protected void onVisitFieldInsn(int opcode, String owner, String name, String descriptor) {
        super.visitFieldInsn(opcode, owner, name, descriptor);
    }
527506
def present(self, path, timeout=0):
        """"""

        ret, data = self.sendmess(MSG_PRESENCE, str2bytez(path),
                                  timeout=timeout)
        assert ret <= 0 and not data, (ret, data)
        if ret < 0:
            return False
        else:
            return True
1294162
def is_available(self):
        """"""
        if hasattr(self._viewh.wrapped_func, 'is_available'):
            return self._viewh.wrapped_func.is_available(self._obj)
        return True
299696
private function isVisitorKnown()
    {
        if ( ! $this->session()->has($this->getSessionKey()))
            return false;

        if ($this->getVisitorData('uuid') != $this->getVisitorIdFromSystem())
            return false;

        if ( ! $this->findByUuid($this->getVisitorData('uuid')))
            return false;

        return true;
    }
623560
def isready(self, obj) -> bool:
        """"""
        return vars(obj).get(self.name, False)
460646
def is_following(self, user, obj):
        
        if isinstance(user, AnonymousUser):
            return False        
        return 0 < self.get_follows(obj).filter(user=user).count()
471501
def _visible(self, element):
        
        if element.name in self._disallowed_names:
            return False
        elif re.match(u'<!--.*-->', six.text_type(element.extract())):
            return False
        return True
691894
def viewer_has_liked(self) -> Optional[bool]:
        """"""
        if not self._context.is_logged_in:
            return None
        if 'likes' in self._node and 'viewer_has_liked' in self._node['likes']:
            return self._node['likes']['viewer_has_liked']
        return self._field('viewer_has_liked')
1046473
def get_user_if_exists(strategy, details, user=None, *args, **kwargs):
    """"""
    if user:
        return {'is_new': False}
    try:
        username = details.get('username')

        # Return the user if it exists
        return {
            'is_new': False,
            'user': User.objects.get(username=username)
        }
    except User.DoesNotExist:
        # Fall to the default return value
        pass

    # Nothing to return since we don't have a user
    return {}
193331
def is_hidden(path):
    """"""
    for name in path.split(os.sep):
        if name != '.' and name != '..' and name and name[0] == '.':
            return True
    return False
175743
def has_in_watched(self, watched):
        
        assert isinstance(watched, github.Repository.Repository), watched
        status, headers, data = self._requester.requestJson(
            "GET",
            "/repos/" + watched._identity + "/subscription"
        )
        return status == 200
996847
function isVisible(elem) {
  return elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);
}