text stringlengths 81 112k |
|---|
Search the ORCID database.
Parameters
----------
:param query: string
Query in line with the chosen method.
:param method: string
One of 'lucene', 'edismax', 'dismax'
:param start: string
Index of the first record requested. Use for pagination... |
Search the ORCID database with a generator.
The generator will yield every result.
Parameters
----------
:param query: string
Query in line with the chosen method.
:param method: string
One of 'lucene', 'edismax', 'dismax'
:param pagination: inte... |
Get a token for searching ORCID records.
Parameters
----------
:param scope: string
/read-public or /read-member
Returns
-------
:returns: string
The token.
def get_search_token_from_orcid(self, scope='/read-public'):
"""Get a token for ... |
Get the token.
Parameters
----------
:param user_id: string
The id of the user used for authentication.
:param password: string
The user password.
:param redirect_uri: string
The redirect uri of the institution.
:param scope: string
... |
Like `get_token`, but using an OAuth 2 authorization code.
Use this method if you run a webserver that serves as an endpoint for
the redirect URI. The webserver can retrieve the authorization code
from the URL that is requested by ORCID.
Parameters
----------
:param red... |
Get the public info about the researcher.
Parameters
----------
:param orcid_id: string
Id of the queried author.
:param request_type: string
For example: 'record'.
See https://members.orcid.org/api/tutorial/read-orcid-records
for possible... |
Add a record to a profile.
Parameters
----------
:param orcid_id: string
Id of the author.
:param token: string
Token received from OAuth 2 3-legged authorization.
:param request_type: string
One of 'activities', 'education', 'employment', 'fu... |
Get the token.
Parameters
----------
:param user_id: string
The id of the user used for authentication.
:param password: string
The user password.
:param redirect_uri: string
The redirect uri of the institution.
:param scope: string
... |
Get the user orcid from authentication process.
Parameters
----------
:param user_id: string
The id of the user used for authentication.
:param password: string
The user password.
:param redirect_uri: string
The redirect uri of the institution... |
Get the member info about the researcher.
Parameters
----------
:param orcid_id: string
Id of the queried author.
:param request_type: string
For example: 'record'.
See https://members.orcid.org/api/tutorial/read-orcid-records
for possible... |
Add a record to a profile.
Parameters
----------
:param orcid_id: string
Id of the author.
:param token: string
Token received from OAuth 2 3-legged authorization.
:param request_type: string
One of 'activities', 'education', 'employment', 'fu... |
Add a record to a profile.
Parameters
----------
:param orcid_id: string
Id of the author.
:param token: string
Token received from OAuth 2 3-legged authorization.
:param request_type: string
One of 'activities', 'education', 'employment', 'fu... |
Remove any duplicates from the entity relationship table
:param apps:
:param schema_editor:
:return:
def remove_duplicates(apps, schema_editor):
"""
Remove any duplicates from the entity relationship table
:param apps:
:param schema_editor:
:return:
"""
# Get the model
Enti... |
From the authorization code, get the "access token" and the "refresh token" from Box.
Args:
authorization_code (str). Authorisation code emitted by Box at the url provided by the function :func:`get_authorization_url`.
Returns:
tuple. (access_token, refresh_token)
Rais... |
Called to unpack a STOMP message into a dictionary.
returned = {
# STOMP Command:
'cmd' : '...',
# Headers e.g.
'headers' : {
'destination' : 'xyz',
'message-id' : 'some event',
:
etc,
}
# Body:
'body' : '...1... |
STOMP acknowledge command.
Acknowledge receipt of a specific message from the server.
messageid:
This is the id of the message we are acknowledging,
what else could it be? ;)
transactionid:
This is the id that all actions in this transaction
will have. If this is not given... |
STOMP send command.
dest:
This is the channel we wish to subscribe to
msg:
This is the message body to be sent.
transactionid:
This is an optional field and is not needed
by default.
def send(dest, msg, transactionid=None):
"""STOMP send command.
dest:
Th... |
Check the cmd is valid, FrameError will be raised if its not.
def setCmd(self, cmd):
"""Check the cmd is valid, FrameError will be raised if its not."""
cmd = cmd.upper()
if cmd not in VALID_COMMANDS:
raise FrameError("The cmd '%s' is not valid! It must be one of '%s' (STOMP v%s)." ... |
Called to create a STOMP message from the internal values.
def pack(self):
"""Called to create a STOMP message from the internal values.
"""
headers = ''.join(
['%s:%s\n' % (f, v) for f, v in sorted(self.headers.items())]
)
stomp_message = "%s\n%s\n%s%s\n" % (self._c... |
Called to extract a STOMP message into this instance.
message:
This is a text string representing a valid
STOMP (v1.0) message.
This method uses unpack_frame(...) to extract the
information, before it is assigned internally.
retuned:
The result of t... |
Called to provide a response to a message if needed.
msg:
This is a dictionary as returned by unpack_frame(...)
or it can be a straight STOMP message. This function
will attempt to determine which an deal with it.
returned:
A message to return or an empt... |
Called to handle an error message received from the server.
This method just logs the error message
returned:
NO_RESPONSE_NEEDED
def error(self, msg):
"""Called to handle an error message received from the server.
This method just logs the error message
returned:... |
Called to handle a receipt message received from the server.
This method just logs the receipt message
returned:
NO_RESPONSE_NEEDED
def receipt(self, msg):
"""Called to handle a receipt message received from the server.
This method just logs the receipt message
r... |
Set up a logger that catches all channels and logs it to stdout.
This is used to set up logging when testing.
def log_init(level):
"""Set up a logger that catches all channels and logs it to stdout.
This is used to set up logging when testing.
"""
log = logging.getLogger()
hdlr =... |
Override this and do some customer message handler.
def ack(self, msg):
"""Override this and do some customer message handler.
"""
print("Got a message:\n%s\n" % msg['body'])
# do something with the message...
# Generate the ack or not if you subscribed with ac... |
This is a decorator that will wrap the decorated method in an atomic transaction and
retry the transaction a given number of times
:param num_retries: How many times should we retry before we give up
:param backoff: How long should we wait after each try
def transaction_atomic_with_retry(num_retries=5, ba... |
A decorator that can be used to defer the syncing of entities until after the method has been run
This is being introduced to help avoid deadlocks in the meantime as we attempt to better understand
why they are happening
def defer_entity_syncing(wrapped, instance, args, kwargs):
"""
A decorator that ca... |
Given model objects organized by content type and a dictionary of all model IDs that need
to be synced, organize all super entity relationships that need to be synced.
Ensure that the model_ids_to_sync dict is updated with any new super entities
that need to be part of the overall entity sync
def _get_sup... |
Given the model IDs to sync, fetch all model objects to sync
def _get_model_objs_to_sync(model_ids_to_sync, model_objs_map, sync_all):
"""
Given the model IDs to sync, fetch all model objects to sync
"""
model_objs_to_sync = {}
for ctype, model_ids_to_sync_for_ctype in model_ids_to_sync.items():
... |
Syncs entities
Args:
model_objs (List[Model]): The model objects to sync. If empty, all entities will be synced
def sync_entities(*model_objs):
"""
Syncs entities
Args:
model_objs (List[Model]): The model objects to sync. If empty, all entities will be synced
"""
# Check if w... |
Syncs entities watching changes of a model instance.
def sync_entities_watching(instance):
"""
Syncs entities watching changes of a model instance.
"""
for entity_model, entity_model_getter in entity_registry.entity_watching[instance.__class__]:
model_objs = list(entity_model_getter(instance))
... |
Given a list of entity kinds ensure they are synced properly to the database.
This will ensure that only unchanged entity kinds are synced and will still return all
updated entity kinds
:param entity_kinds: The list of entity kinds to sync
def upsert_entity_kinds(self, entity_kinds):
"... |
Upsert a list of entities to the database
:param entities: The entities to sync
:param sync: Do a sync instead of an upsert
def upsert_entities(self, entities, sync=False):
"""
Upsert a list of entities to the database
:param entities: The entities to sync
:param sync: D... |
Upsert entity relationships to the database
:param queryset: The base queryset to use
:param entity_relationships: The entity relationships to ensure exist in the database
def upsert_entity_relationships(self, queryset, entity_relationships):
"""
Upsert entity relationships to the datab... |
Returns a tuple for a kind name and kind display name of an entity.
By default, uses the app_label and model of the model object's content
type as the kind.
def get_entity_kind(self, model_obj):
"""
Returns a tuple for a kind name and kind display name of an entity.
By default, ... |
Registers an entity config
def register_entity(self, entity_config):
"""
Registers an entity config
"""
if not issubclass(entity_config, EntityConfig):
raise ValueError('Must register entity config class of subclass EntityConfig')
if entity_config.queryset is None:
... |
Start twisted event loop and the fun should begin...
def start(host='localhost', port=61613, username='', password=''):
"""Start twisted event loop and the fun should begin...
"""
StompClientFactory.username = username
StompClientFactory.password = password
reactor.connectTCP(host, port, StompClien... |
Once I've connected I want to subscribe to my the message queue.
def connected(self, msg):
"""Once I've connected I want to subscribe to my the message queue.
"""
stomper.Engine.connected(self, msg)
self.log.info("Connected: session %s. Beginning say hello." % msg['headers']['session']... |
Send out a hello message periodically.
def send(self):
"""Send out a hello message periodically.
"""
self.log.info("Saying hello (%d)." % self.counter)
f = stomper.Frame()
f.unpack(stomper.send(DESTINATION, 'hello there (%d)' % self.counter))
self.counter += 1
... |
Register with stomp server.
def connectionMade(self):
"""Register with stomp server.
"""
cmd = stomper.connect(self.username, self.password)
self.transport.write(cmd) |
Use stompbuffer to determine when a complete message has been received.
def dataReceived(self, data):
"""Use stompbuffer to determine when a complete message has been received.
"""
self.stompBuffer.appendData(data)
while True:
msg = self.stompBuffer.getOneMessage()
... |
Connection failed
def clientConnectionFailed(self, connector, reason):
"""Connection failed
"""
print('Connection failed. Reason:', reason)
ReconnectingClientFactory.clientConnectionFailed(self, connector, reason) |
Process the message and determine what to do with it.
def ack(self, msg):
"""Process the message and determine what to do with it.
"""
self.log.info("receiverId <%s> Received: <%s> " % (self.receiverId, msg['body']))
#return super(MyStomp, self).ack(msg)
return stomper... |
Register with the stomp server.
def connectionMade(self):
"""Register with the stomp server.
"""
cmd = self.sm.connect()
self.transport.write(cmd) |
Data received, react to it and respond if needed.
def dataReceived(self, data):
"""Data received, react to it and respond if needed.
"""
# print "receiver dataReceived: <%s>" % data
msg = stomper.unpack_frame(data)
returned = self.sm.react(msg)
# print "... |
Find a folder or a file ID from its name, inside a given folder.
Args:
name (str): Name of the folder or the file to find.
parent_folder_id (int): ID of the folder where to search.
Returns:
int. ID of the file or folder found. None if not found.
Raises:
... |
Create a folder
If the folder exists, a BoxError will be raised.
Args:
folder_id (int): Name of the folder.
parent_folder_id (int): ID of the folder where to create the new one.
Returns:
dict. Response from Box.
Raises:
BoxError: An er... |
Delete an existing folder
Args:
folder_id (int): ID of the folder to delete.
recursive (bool): Delete all subfolder if True.
Returns:
dict. Response from Box.
Raises:
BoxError: An error response is returned from Box (status_code >= 400).
... |
Get files and folders inside a given folder
Args:
folder_id (int): Where to get files and folders info.
limit (int): The number of items to return.
offset (int): The item at which to begin the response.
fields_list (list): List of attributes to get. All attrib... |
Upload a file into a folder.
Use function for small file otherwise there is the chunk_upload_file() function
Args::
name (str): Name of the file on your Box storage.
folder_id (int): ID of the folder where to upload the file.
file_path (str): Local path of the fil... |
Upload a new version of a file into a folder.
Use function for small file otherwise there is the chunk_upload_file() function.
Args::
name (str): Name of the file on your Box storage.
folder_id (int): ID of the folder where to upload the file.
file_id (int): ID of... |
Upload a file chunk by chunk.
The whole file is never loaded in memory.
Use this function for big file.
The callback(transferred, total) to let you know the upload progress.
Upload can be cancelled if the callback raise an Exception.
>>> def progress_callback(transferred, tota... |
Copy file to new destination
Args:
file_id (int): ID of the folder.
dest_folder_id (int): ID of parent folder you are copying to.
Returns:
dict. Response from Box.
Raises:
BoxError: An error response is returned from Box (status_code >= 400).
... |
Download a file.
The whole file is never loaded in memory.
The callback(transferred, total) to let you know the download progress.
Download can be cancelled if the callback raise an Exception.
>>> def progress_callback(transferred, total):
... print 'Downloaded %i bytes of ... |
Searches for files/folders
Args:
\*\*kwargs (dict): A dictionary containing necessary parameters
(check https://developers.box.com/docs/#search for
list of parameters)
Returns:
dict. Response from Box.
Raises:
... |
Return a list of values corresponding to the keys in the iterable of
*keys*.
If a key is not present in the collection, its corresponding value will
be :obj:`None`.
.. note::
This method is not implemented by standard Python dictionary
classes.
def getmany(self,... |
Returns a Python dictionary with the same values as this object
(without checking the local cache).
def _data(self, pipe=None):
"""
Returns a Python dictionary with the same values as this object
(without checking the local cache).
"""
pipe = self.redis if pipe is None e... |
Return an iterator over the dictionary's ``(key, value)`` pairs.
def iteritems(self, pipe=None):
"""Return an iterator over the dictionary's ``(key, value)`` pairs."""
pipe = self.redis if pipe is None else pipe
for k, v in self._data(pipe).items():
yield k, self.cache.get(k, v) |
If *key* is in the dictionary, remove it and return its value,
else return *default*. If *default* is not given and *key* is not
in the dictionary, a :exc:`KeyError` is raised.
def pop(self, key, default=__marker):
"""If *key* is in the dictionary, remove it and return its value,
else r... |
Remove and return an arbitrary ``(key, value)`` pair from
the dictionary.
:func:`popitem` is useful to destructively iterate over
a dictionary, as often used in set algorithms. If
the dictionary is empty, calling :func:`popitem` raises
a :exc:`KeyError`.
def popitem(self):
... |
If *key* is in the dictionary, return its value.
If not, insert *key* with a value of *default* and
return *default*. *default* defaults to :obj:`None`.
def setdefault(self, key, default=None):
"""If *key* is in the dictionary, return its value.
If not, insert *key* with a value of *def... |
Update the dictionary with the key/value pairs from *other*,
overwriting existing keys. Return :obj:`None`.
:func:`update` accepts either another dictionary object or
an iterable of key/value pairs (as tuples or other iterables
of length two). If keyword arguments are specified, the
... |
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the given
Redis key.
def copy(self, key=None):
"""
Return a new collection with the same items as this one.
If *key* is specified, create the new collection with the gi... |
Create a new dictionary with keys from *seq* and values set to
*value*.
.. note::
:func:`fromkeys` is a class method that returns a new dictionary.
It is possible to specify additional keyword arguments to be passed
to :func:`__init__` of the new object.
def fromkey... |
Yield each of the ``(key, value)`` pairs from the collection, without
pulling them all into memory.
.. warning::
This method is not available on the dictionary collections provided
by Python.
This method may return the same (key, value) pair multiple times.
... |
Elements are counted from an *iterable* or added-in from another
*mapping* (or counter). Like :func:`dict.update` but adds counts
instead of replacing them. Also, the *iterable* is expected to be
a sequence of elements, not a sequence of ``(key, value)`` pairs.
def update(self, other=None, **kw... |
Elements are subtracted from an *iterable* or from another
*mapping* (or counter). Like :func:`dict.update` but subtracts
counts instead of replacing them.
def subtract(self, other=None, **kwargs):
"""Elements are subtracted from an *iterable* or from another
*mapping* (or counter). Lik... |
Processes the received message. I don't need to
generate an ack message.
def ack(self, msg):
"""Processes the received message. I don't need to
generate an ack message.
"""
self.log.info("senderID:%s Received: %s " % (self.senderID, msg['body']))
return stompe... |
Helper for clear operations.
:param pipe: Redis pipe in case update is performed as a part
of transaction.
:type pipe: :class:`redis.client.StrictPipeline` or
:class:`redis.client.StrictRedis`
def _clear(self, pipe=None):
"""Helper for clear operations.... |
Convert negative indexes into their positive equivalents.
def _normalize_index(self, index, pipe=None):
"""Convert negative indexes into their positive equivalents."""
pipe = self.redis if pipe is None else pipe
len_self = self.__len__(pipe)
positive_index = index if index >= 0 else len... |
Given a :obj:`slice` *index*, return a 4-tuple
``(start, stop, step, fowrward)``. The first three items can be used
with the ``range`` function to retrieve the values associated with the
slice; the last item indicates the direction.
def _normalize_slice(self, index, pipe=None):
"""Given... |
Helper simplifying code within watched transaction.
Takes *fn*, function treated as a transaction. Returns whatever
*fn* returns. ``self.key`` is watched. *fn* takes *pipe* as the
only argument.
:param fn: Closure treated as a transaction.
:type fn: function *fn(pipe)*
... |
Find paths recursively
def recursive_path(pack, path):
"""Find paths recursively"""
matches = []
for root, _, filenames in os.walk(os.path.join(pack, path)):
for filename in filenames:
matches.append(os.path.join(root, filename)[len(pack) + 1:])
return matches |
STOMP negative acknowledge command.
NACK is the opposite of ACK. It is used to tell the server that the client
did not consume the message. The server can then either send the message to
a different client, discard it, or put it in a dead letter queue. The exact
behavior is server specific.
messag... |
STOMP connect command.
username, password:
These are the needed auth details to connect to the
message server.
After sending this we will receive a CONNECTED
message which will contain our session id.
def connect(username, password, host, heartbeats=(0,0)):
"""STOMP connect command.
... |
Called when a MESSAGE has been received.
Override this method to handle received messages.
This function will generate an acknowledge message
for the given message and transaction (if present).
def ack(self, msg):
"""Called when a MESSAGE has been received.
Override this meth... |
I pull one complete message off the buffer and return it decoded
as a dict. If there is no complete message in the buffer, I
return None.
Note that the buffer can contain more than once message. You
should therefore call me in a loop until I return None.
def getOneMessage ( self ):
... |
I examine the data passed to me and return a 2-tuple of the form:
( message_length, header_length )
where message_length is the length in bytes of the first complete
message, if it contains at least one message, or 0 if it
contains no message.
If me... |
I detect and correct corruption in the buffer.
Corruption in the buffer is defined as the following conditions
both being true:
1. The buffer contains at least one newline;
2. The text until the first newline is not a STOMP command.
In this case... |
Once I've connected I want to subscribe to my the message queue.
def connected(self, msg):
"""Once I've connected I want to subscribe to my the message queue.
"""
super(MyStomp, self).connected(msg)
self.log.info("connected: session %s" % msg['headers']['session'])
f = stomper.... |
Defines a signal handler for syncing an individual entity. Called when
an entity is saved or deleted.
def delete_entity_signal_handler(sender, instance, **kwargs):
"""
Defines a signal handler for syncing an individual entity. Called when
an entity is saved or deleted.
"""
if instance.__class__... |
Defines a signal handler for saving an entity. Syncs the entity to
the entity mirror table.
def save_entity_signal_handler(sender, instance, **kwargs):
"""
Defines a signal handler for saving an entity. Syncs the entity to
the entity mirror table.
"""
if instance.__class__ in entity_registry.en... |
Defines a signal handler for a manytomany changed signal. Only listens for the
post actions so that entities are synced once (rather than twice for a pre and post action).
def m2m_changed_entity_signal_handler(sender, instance, action, **kwargs):
"""
Defines a signal handler for a manytomany changed signal... |
Disables all of the signals for syncing entities. By default, everything is turned off. If the user wants
to turn off everything but one signal, for example the post_save signal, they would do:
turn_off_sync(for_post_save=False)
def turn_off_syncing(for_post_save=True, for_post_delete=True, for_m2m_changed=Tr... |
Enables all of the signals for syncing entities. Everything is True by default, except for the post_bulk_operation
signal. The reason for this is because when any bulk operation occurs on any mirrored entity model, it will
result in every single entity being synced again. This is not a desired behavior by the m... |
Add element *value* to the set.
def add(self, value):
"""Add element *value* to the set."""
# Raise TypeError if value is not hashable
hash(value)
self.redis.sadd(self.key, self._pickle(value)) |
Remove element *value* from the set if it is present.
def discard(self, value):
"""Remove element *value* from the set if it is present."""
# Raise TypeError if value is not hashable
hash(value)
self.redis.srem(self.key, self._pickle(value)) |
Return ``True`` if the set has no elements in common with *other*.
Sets are disjoint if and only if their intersection is the empty set.
:param other: Any kind of iterable.
:rtype: boolean
def isdisjoint(self, other):
"""
Return ``True`` if the set has no elements in common wit... |
Remove and return an arbitrary element from the set.
Raises :exc:`KeyError` if the set is empty.
def pop(self):
"""
Remove and return an arbitrary element from the set.
Raises :exc:`KeyError` if the set is empty.
"""
result = self.redis.spop(self.key)
if result i... |
Return a *k* length list of unique elements chosen from the Set.
Elements are not removed. Similar to :func:`random.sample` function
from standard library.
:param k: Size of the sample, defaults to 1.
:rtype: :class:`list`
def random_sample(self, k=1):
"""
Return a *k* ... |
Remove element *value* from the set. Raises :exc:`KeyError` if it
is not contained in the set.
def remove(self, value):
"""
Remove element *value* from the set. Raises :exc:`KeyError` if it
is not contained in the set.
"""
# Raise TypeError if value is not hashable
... |
Yield each of the elements from the collection, without pulling them
all into memory.
.. warning::
This method is not available on the set collections provided
by Python.
This method may return the element multiple times.
See the `Redis SCAN documentatio... |
Update the set, keeping only elements found in it and all *others*.
:param others: Iterables, each one as a single positional argument.
:rtype: None
.. note::
The same behavior as at :func:`difference_update` applies.
def intersection_update(self, *others):
"""
Upd... |
Update the set, adding elements from all *others*.
:param others: Iterables, each one as a single positional argument.
:rtype: None
.. note::
If all *others* are :class:`Set` instances, the operation
is performed completely in Redis. Otherwise, values are retrieved
... |
Update the set, removing elements found in *others*.
:param others: Iterables, each one as a single positional argument.
:rtype: None
.. note::
The same behavior as at :func:`update` applies.
def difference_update(self, *others):
"""
Update the set, removing elemen... |
Remove *member* from the collection, unconditionally.
def discard_member(self, member, pipe=None):
"""
Remove *member* from the collection, unconditionally.
"""
pipe = self.redis if pipe is None else pipe
pipe.zrem(self.key, self._pickle(member)) |
Yield each of the ``(member, score)`` tuples from the collection,
without pulling them all into memory.
.. warning::
This method may return the same (member, score) tuple multiple
times.
See the `Redis SCAN documentation
<http://redis.io/commands/scan#sca... |
Update the collection with items from *other*. Accepts other
:class:`SortedSetBase` instances, dictionaries mapping members to
numeric scores, or sequences of ``(member, score)`` tuples.
def update(self, other):
"""
Update the collection with items from *other*. Accepts other
:c... |
Returns the number of members whose score is between *min_score* and
*max_score* (inclusive).
def count_between(self, min_score=None, max_score=None):
"""
Returns the number of members whose score is between *min_score* and
*max_score* (inclusive).
"""
min_score = float(... |
Remove members whose ranking is between *min_rank* and *max_rank*
OR whose score is between *min_score* and *max_score* (both ranges
inclusive). If no bounds are specified, no members will be removed.
def discard_between(
self,
min_rank=None,
max_rank=None,
min_score=Non... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.