Fetch whether unloading is restricted

        :returns: True, if unloading is restricted
        :rtype: :class:`bool`
        :raises: None
179686
def fetch_replace_restriction(self, ):
        
        inter = self.get_refobjinter()
        restricted = self.status() is None
        return restricted or inter.fetch_action_restriction(self, 'replace')
145684
def fetch(self, is_dl_forced=False):
        
        self.get_files(is_dl_forced)

        # load and tag a list of OMIM IDs with types
        self.omim_type = self.find_omim_type()

        return
996810
def _is_permitted(self, identifiers, permission_s):
        

        for realm in self.realms:
            # the realm's is_permitted returns a generator
            yield from realm.is_permitted(identifiers, permission_s)
373362
def is_suspended(self):
        
        self.open()
        susp = lvm_lv_is_suspended(self.__lvh)
        self.close()
        return bool(susp)
1147230
def _limit_is_valid_or_none(self, params):
        
        if not "limit" in params or not params["limit"]:
            return True
        if not isinstance(params["limit"], int) or params["limit"] < 1:
            return False
        if not "order_by" in params:
            return False
        return True
252027
def isPeBounded(self):
        
        boundImportsDir = self.ntHeaders.optionalHeader.dataDirectory[consts.BOUND_IMPORT_DIRECTORY]
        if boundImportsDir.rva.value and boundImportsDir.size.value:
            return True
        return False
627027
def can_fetch(self, request: Request, file=None) -> bool:
        '''
        '''
        try:
            return self.can_fetch_pool(request)
        except NotInPoolError:
            pass

        yield from self.fetch_robots_txt(request, file=file)

        return self.can_fetch_pool(request)
1267052
def is_rate_limited(response):
        
        if (response.status_code == codes.too_many_requests and 'Retry-After' in response.headers and
                int(response.headers['Retry-After']) >= 0):
            return True

        return False
629352
def no_constraints(cls, callback):
        
        cls._constraints = False

        results = callback()

        cls._constraints = True

        return results
1015074
def isAuthorized(self, request):
        
        restrictions = self.get_view_restrictions()
        if restrictions and request is None:
            return False
        else:
            return all(restriction.accept_request(request)
                       for restriction in restrictions)
1149001
def has_unsent(self):
        """"""
        for tp in list(self._batches.keys()):
            with self._tp_locks[tp]:
                dq = self._batches[tp]
                if len(dq):
                    return True
        return False
1250262
def is_restricted(self):
        
        return (
            not hasattr(self.choices, 'queryset') or
            self.choices.queryset.count() > settings.FOREIGN_KEY_MAX_SELECBOX_ENTRIES
        )
239021
def triggered(self):
        
        if self.stop is not None and not self.stop_reached:
            return False

        if self.limit is not None and not self.limit_reached:
            return False

        return True
1080362
def is_locked(self):
        
        if not self.__locked__:
            return False
        elif self.get_parent():
            return self.get_parent().is_locked()

        return True
571483
private boolean isRestricted(Permission permission) {
        for (Permission restrictedPermission : restrictablePermissions) {
            if (restrictedPermission.implies(permission)) {
                return true;
            }
        }
        return false;
    }
165702
def can_fetch(self, url_info: URLInfo, user_agent: str):
        ''''''
        key = self.url_info_key(url_info)

        parser = self._parsers[key]
        return parser.is_allowed(user_agent, url_info.url)
206345
def fetch(self):
        
        self.limit.set_request_args(self.kwargs)
        data = self.connection.call(*self.args, **self.kwargs)
        self.limit.post_fetch(data)
        self.last_evaluated_key = data.get('LastEvaluatedKey')
        if self.last_evaluated_key is None:
            self.kwargs.pop('ExclusiveStartKey', None)
        else:
            self.kwargs['ExclusiveStartKey'] = self.last_evaluated_key
        self._update_capacity(data)
        if 'consumed_capacity' in data:
            self.consumed_capacity += data['consumed_capacity']
        for raw_item in data['Items']:
            item = self.connection.dynamizer.decode_keys(raw_item)
            if self.limit.accept(item):
                yield item