Get the dissertation institution.
776171
def get_institution(self, **kwargs):
        """"""
        qualifier = kwargs.get('qualifier', '')
        content = kwargs.get('content', '')
        if qualifier == 'grantor':
            return content
        return None
168340
def get(self):
        ''''''

        key = self.get_key_from_request()
        result = self.get_storage().get(key)

        return result if result else None
1203635
def get_collection(cls):
        """"""

        # By default the collection returned will be the published collection,
        # however if the `draft` flag has been set against the global context
        # (e.g `g`) then the collection returned will contain draft documents.

        if g.get('draft'):
            return getattr(
                cls.get_db(),
                '{collection}_draft'.format(collection=cls._collection)
                )

        return getattr(cls.get_db(), cls._collection)
129956
def get(self, key, default=None):
        """"""
        if key not in self.table:
            return default

        return self[key]
184108
def get(self, count, offset=0, _options=None):
        '''
        
        '''

        options = _options or {}

        return self.client.post('/institutions/get', {
            'count': count,
            'offset': offset,
            'options': options,
        })
943780
def get(self):
        """"""
        method_name = "_download_" + self.name
        method = getattr(self, method_name)
        return method()
964904
def loan(self):
        
        return '{}{}LOAN{}/{}{}'.format(self.meta, self.version, self.edition_number,
                                        self.loan_start, self.loan_end)
926559
def _get_canonical(self):
        """"""

        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..
        if self.micro == 0:
            ver = "{}.{}".format(self.major, self.minor)
        else:
            ver = "{}.{}.{}".format(self.major, self.minor, self.micro)
        if self._is_pre():
            ver += '{}{}'.format(REL_MAP[self.release], self.pre)
        if self._is_post():
            ver += ".post{}".format(self.post)
        if self._is_dev():
            ver += ".dev{}".format(self.dev)

        return ver
984740
def get_repository(self):
        
        if self._lookup_session is None:
            mgr = get_provider_manager('REPOSITORY', runtime=self._runtime, proxy=self._proxy)
            self._lookup_session = mgr.get_repository_lookup_session(proxy=getattr(self, "_proxy", None))
        return self._lookup_session.get_repository(Id(self._my_map['id']))
578078
def display(self):
        """"""
        if self.degree and self.school:
            disp = self.degree + u' from ' + self.school
        else:
            disp = self.degree or self.school or None
        if disp is not None and self.date_range is not None:
            disp += u' (%d-%d)' % self.date_range.years_range
        return disp or u''
192113
def getSearch(self):
        """"""
        return Search(self.getColumns(), Sitools2Abstract.getBaseUrl(self) + self.getUri())
870175
def get_orga(self, orgaPk):
        """"""
        r = self._request('orga/' + str(orgaPk))
        if r:
            # Set base properties and copy data inside the orga
            o = Orga()
            o.pk = o.id = orgaPk
            o.__dict__.update(r.json())
            return o
        return None
978102
def get(self):
        """"""
        return {k:v for k,v in list(self.options.items()) if k in self._allowed_graphics}
580174
def get(self):
        
        url = "{url_base}/resource/{pid}/scimeta/custom/".format(url_base=self.hs.url_base,
                                                                 pid=self.pid)
        r = self.hs._request('GET', url)
        return json.loads(r.text)
911483
def get_lookup(self, lookup_name):
        """"""
        from protean.core.repository import BaseLookup
        lookup = self._get_lookup(lookup_name)

        # If unable to find Lookup, or if Lookup is the wrong class, raise Error
        if lookup is None or (lookup is not None and not issubclass(lookup, BaseLookup)):
            raise NotImplementedError

        return lookup
1366216
def get_meta(self, key=None):
        """"""
        if self.is_fake:
            return {}

        if key == "tag":
            return self.tag
        elif key is None:
            ret = {}
            for key in self.journal.info.keys():
                ret[key] = self.meta_mappings.map_get(self.journal.info, key)[1]
            return ret
        else:
            key, value = self.meta_mappings.map_get(self.journal.info, key)
            return value
1331238
def Get(self):
    """"""

    args = user_management_pb2.ApiGetGrrUserArgs(username=self.username)
    data = self._context.SendRequest("GetGrrUser", args)
    return GrrUser(data=data, context=self._context)