def addProtocolToExperiment(self, experiment, protocol):
params = {
"experiment_workflow_id": experiment.id,
"protocol_id": protocol.last_version["id"],
}
return entityRepository.newEntity(experiment.__user__,
ExperimentProtocol, params)
def addSignature(self, statement=None, lock=False):
"""
Add a signature to experiment
Parameters
----------
statement (str)
Statement describing the signature.
lock (boolean)
Whether to lock the experiment against further edits.
Returns
-------
:class:`~labstep.entities.experimentSignature.model.ExperimentSignature`
The signature that has been added
"""
from labstep.generic.entity.repository import entityRepository
params = {
"statement": statement,
"is_lock": int(lock),
"experiment_workflow_id": self.id,
}
return entityRepository.newEntity(self.__user__, ExperimentSignature,
params)
def addDataFieldTo(
self,
entity,
fieldName,
fieldType="default",
value=None,
date=None,
number=None,
unit=None,
filepath=None,
extraParams={},
):
if filepath is not None:
fileId = fileRepository.newFile(entity.__user__, filepath).id
else:
fileId = None
params = {
"metadata_thread_id": entity.metadata_thread["id"],
"type": fieldType,
"label": handleString(fieldName),
"value": handleString(value),
"date": handleDate(date),
"number": number,
"unit": unit,
"file_id": fileId,
**extraParams,
}
dataField = entityRepository.newEntity(
entity.__user__, ProtocolDataField, params)
dataField.protocol_id = entity.id
return dataField
def newOrganization(self, user, name, extraParams={}):
params = {
"name": name,
**extraParams,
}
return entityRepository.newEntity(user, Organization, params)
def newVersion(self):
"""
Start a new version of the Protocol.
Example
-------
::
my_protocol = user.getProtocol(17000)
new_version = my_protocol.newVersion()
"""
from labstep.generic.entity.repository import entityRepository
entityRepository.newEntity(
self.__user__, ProtocolVersion, {"collection_id": self.id}
)
return self.update()
def newExperiment(self, user, name, entry=None, extraParams={}):
params = {"name": name, **extraParams}
experiment = entityRepository.newEntity(user, Experiment, params)
if entry is not None:
experiment = experiment.edit(entry=entry)
return experiment
def newOrderRequest(self,
user,
resource_id=None,
quantity=1,
extraParams={}):
params = {
"resource_id": resource_id,
"quantity": quantity,
**extraParams
}
return entityRepository.newEntity(user, OrderRequest, params)
def newExperimentSignatureRequest(self,
user,
experiment_id,
user_id,
message=None):
fields = {
"experiment_workflow_id": experiment_id,
"message": message,
"user_id": user_id
}
return entityRepository.newEntity(user,
ExperimentSignatureRequest,
fields=fields)
def newProtocolMaterial(self, user, protocol_id, name, resource_id=None, amount=None, units=None, extraParams={}):
params = {
"protocol_id": protocol_id,
"name": name,
"resource_id": resource_id,
"value": amount,
"units": units,
**extraParams,
}
if params["value"] is not None:
params["value"] = str(params["value"])
return entityRepository.newEntity(user, ProtocolMaterial, params)
def setAutosharing(
self, experiment_sharing=None, protocol_sharing=None, resource_sharing=None
):
"""
Parameters
----------
experiment_sharing (str)
Automatically share experiments
you create and own with this workspace. Set to True or False
protocol_sharing (str)
Automatically share protocols
you create and own with this workspace. Set to True or False
resource_sharing (str)
Automatically share resources
you create and own with this workspace. Set to True or False
Returns
-------
:class:`~labstep.entities.autoshare.model.Autoshare`
An object representing the Autosharing policy.
Example
-------
::
# Get an workspace
workspace = user.getWorkspaces(123)
workspace.setAutosharing(experiment_sharing='view')
"""
self.update()
if self.security_policy is None:
from labstep.generic.entity.repository import entityRepository
policy = entityRepository.newEntity(
self.__user__,
Autoshare,
{"user_group_id": self.logged_user_user_group["id"]},
)
else:
policy = Autoshare(self.security_policy, self.__user__)
return policy.edit(
experiment_sharing=experiment_sharing,
protocol_sharing=protocol_sharing,
resource_sharing=resource_sharing,
)
def addComment(self, entity, body, fileId=None, extraParams={}):
if entity.thread is None:
raise Exception('You cannot add a comment to this entity')
threadId = entity.thread["id"]
params = {
"body": handleString(body),
"parent_thread_id": threadId,
"file_id": [[fileId]] if fileId is not None else None,
**extraParams,
}
return entityRepository.newEntity(entity.__user__, Comment, params)
def addMetadataTo(
self,
entity,
fieldName,
fieldType="default",
value=None,
date=None,
number=None,
unit=None,
filepath=None,
extraParams={},
):
if filepath is not None:
fileId = fileRepository.newFile(entity.__user__, filepath).id
else:
fileId = None
if fieldType not in FIELDS:
msg = "Not a supported metadata type '{}'".format(fieldType)
raise ValueError(msg)
allowedFieldsForType = set(ALLOWED_FIELDS[fieldType])
fields = {
"value": value,
"date": date,
"number": number,
"unit": unit,
"file_id": fileId,
}
fields = {k: v for k, v in fields.items() if v}
fields = set(fields.keys())
violations = fields - allowedFieldsForType
if violations:
msg = "Unallowed fields [{}] for type {}".format(
",".join(violations), fieldType)
raise ValueError(msg)
params = {
"metadata_thread_id": entity.metadata_thread["id"],
"type": fieldType,
"label": handleString(fieldName),
"value": handleString(value),
"date": handleDate(date),
"number": number,
"unit": unit,
"file_id": fileId,
**extraParams,
}
return entityRepository.newEntity(entity.__user__, Metadata, params)
def addTable(self, name=None, data=None):
"""
Add a new table to a Protocol within an Experiment.
Parameters
----------
name (str)
The name of the table.
data (json)
The data of the table in json format.
Returns
-------
:class:`~labstep.entities.experimentTable.model.ExperimentTable`
The newly added table entity.
Example
-------
::
data = {
"rowCount": 12,
"columnCount": 12,
"colHeaderData": {},
"data": {
"dataTable": {
0: {
0: {
"value": 'Cell A1'
},
1: {
"value": 'Cell B1'
}
}
}
}
}
experiment = user.getExperiment(17000)
exp_protocol = experiment.getProtocols()[0]
exp_protocol.addTable(name='Calibration', data=data)
"""
from labstep.generic.entity.repository import entityRepository
params = {"experiment_id": self.id, "name": name, "data": data}
return entityRepository.newEntity(self.__user__, ExperimentTable,
params)
def addTable(self, name=None, data=None):
"""
Add a new table to the Protocol.
Parameters
----------
name (str)
The name of the table.
data (json)
The data of the table in json format.
Returns
-------
:class:`~labstep.entities.protocolTable.model.ProtocolTable`
The newly added table entity.
Example
-------
::
data = {
"rowCount": 12,
"columnCount": 12,
"colHeaderData": {},
"data": {
"dataTable": {
0: {
0: {
"value": 'Cell A1'
},
1: {
"value": 'Cell B1'
}
}
}
}
}
protocol = user.getProtocol(17000)
protocol.addTable(name='Calibration', data=data)
"""
from labstep.generic.entity.repository import entityRepository
params = {
"protocol_id": self.last_version["id"], "name": name, "data": data}
return entityRepository.newEntity(self.__user__, ProtocolTable, params)
def newResourceCategory(self, user, name, extraParams={}):
"""
Create a new Labstep ResourceCategory.
Parameters
----------
user (obj)
The Labstep user creating the ResourceCategory.
Must have property 'api_key'. See 'login'.
name (str)
Give your ResourceCategory a name.
Returns
-------
ResourceCategory
An object representing the new Labstep ResourceCategory.
"""
params = {"name": name, **extraParams, "is_template": 1}
return entityRepository.newEntity(user, ResourceCategory, params)
def newResourceItem(
self,
user,
resource_id,
name=None,
availability=None,
quantity_amount=None,
quantity_unit=None,
resource_location_id=None,
extraParams={},
):
params = {
"resource_id": resource_id,
"resource_location_id": resource_location_id,
"name": name,
"status": handleKeyword(availability),
"quantity_amount": quantity_amount,
"quantity_unit": quantity_unit,
**extraParams,
}
return entityRepository.newEntity(user, ResourceItem, params)
def addTimer(self, name=None, hours=None, minutes=None, seconds=None):
"""
Add a new timer to a Protocol within an Experiment.
Parameters
----------
name (str)
The name of the timer.
hours (int)
The hours of the timer.
minutes (int)
The minutes of the timer.
seconds (int)
The seconds of the timer.
Returns
-------
:class:`~labstep.entities.ExperimentTimer.model.ExperimentTimer`
The newly added timer entity.
Example
-------
::
experiment = user.getExperiment(17000)
exp_protocol = experiment.getProtocols()[0]
exp_protocol.addTimer(name='Refluxing', hours='4', minutes='30')
"""
from labstep.generic.entity.repository import entityRepository
params = {
"experiment_id": self.id,
"name": name,
"hours": hours,
"minutes": minutes,
"seconds": seconds,
}
return entityRepository.newEntity(self.__user__, ExperimentTimer,
params)
def newExperimentMaterial(self,
user,
experiment_id,
name,
resource_id=None,
resource_item_id=None,
amount=None,
units=None,
extraParams={}):
params = {
"experiment_id": experiment_id,
"name": name,
"resource_id": resource_id,
"resource_item_id": resource_item_id,
"value": amount,
"units": units,
**extraParams,
}
if params["value"] is not None:
params["value"] = str(params["value"])
return entityRepository.newEntity(user, ExperimentMaterial, params)
def newTag(self, user, name, type, extraParams={}):
"""
Create a new Tag.
Parameters
----------
user (obj)
The Labstep user creating the Tag.
Must have property 'api_key'. See 'login'.
name (str)
Name of the new Tag.
type (str)
Return only tags of a certain type. Options are:
'experiment_workflow', 'protocol_collection',
'resource', 'order_request'.
Returns
-------
tag
An object representing the new Labstep Tag.
"""
params = {"name": name, "type": handleKeyword(type), **extraParams}
return entityRepository.newEntity(user, Tag, params)
def addTimer(self, name=None, hours=None, minutes=None, seconds=None):
"""
Add a new timer to the Protocol.
Parameters
----------
name (str)
The name of the timer.
hours (int)
The hours of the timer.
minutes (int)
The minutes of the timer.
seconds (int)
The seconds of the timer.
Returns
-------
:class:`~labstep.entities.protocolTimer.model.ProtocolTimer`
The newly added timer entity.
Example
-------
::
protocol = user.getProtocol(17000)
protocol.addTimer(name='Refluxing', hours='4', minutes='30')
"""
from labstep.generic.entity.repository import entityRepository
params = {
"protocol_id": self.last_version["id"],
"name": name,
"hours": hours,
"minutes": minutes,
"seconds": seconds,
}
return entityRepository.newEntity(self.__user__, ProtocolTimer, params)
def getSharelink(self, entity):
key = entity.__entityName__.replace("-", "_") + "_id"
return entityRepository.newEntity(entity.__user__,
Sharelink,
fields={key: entity.id})
def newProtocol(self, user, name, extraParams={}):
params = {"name": name, **extraParams}
return entityRepository.newEntity(user, Protocol, params)
def newResource(self, user, name, resource_category_id=None, extraParams={}):
params = {
"name": name,
"template_id": resource_category_id,
**extraParams}
return entityRepository.newEntity(user, Resource, params)
def newCollection(self, user, name, type, extraParams={}):
types = {"experiment": "experiment_workflow", "protocol": "protocol_collection"}
params = {"name": name, "type": types[type], **extraParams}
return entityRepository.newEntity(user, Collection, params)
def newResourceLocation(self, user, name, outer_location_id=None, extraParams={}):
params = {"name": name, "outer_location_id": outer_location_id, **extraParams}
return entityRepository.newEntity(user, ResourceLocation, params)
def newWorkspace(self, user, name, extraParams={}):
params = {"name": name, **extraParams}
return entityRepository.newEntity(user, Workspace, params)
def addData(
self,
fieldName,
fieldType="text",
text=None,
number=None,
unit=None,
filepath=None,
extraParams={},
):
"""
Send new data from the Device.
Parameters
----------
fieldName (str)
The name of the data field being sent.
fieldType (str)
The type of data being sent. Options are: "text", "numeric",
or "file".
text (str)
The text for a field of type 'text'.
number (float)
The number for a field of type 'numeric'.
unit (str)
The unit for a field of type 'numeric'.
filepath (str)
Local path to the file to upload for type 'file'.
Returns
-------
:class:`~labstep.entities.device.model.DeviceData`
An object representing the new Device Data.
Example
-------
::
device = user.getDevice(17000)
data = device.addData("Temperature","numeric",
number=173, unit='K')
"""
from labstep.generic.entity.repository import entityRepository
from labstep.entities.file.repository import fileRepository
if fieldType not in FIELD_TYPES:
msg = "Not a supported data type '{}'".format(fieldType)
raise ValueError(msg)
if filepath is not None:
file_id = fileRepository.newFile(self.__user__, filepath).id
else:
file_id = None
allowedFieldsForType = set(ALLOWED_FIELDS[FIELD_TYPES[fieldType]])
fields = {"value": text, "number": number,
"unit": unit, "file_id": file_id}
fields = {k: v for k, v in fields.items() if v}
fields = set(fields.keys())
violations = fields - allowedFieldsForType
if violations:
msg = "Unallowed fields [{}] for type {}".format(
",".join(violations), fieldType
)
raise ValueError(msg)
params = {
"device_id": self.id,
"type": FIELD_TYPES[fieldType],
"name": fieldName,
"value": text,
"number": number,
"unit": unit,
"file_id": file_id,
**extraParams,
}
return entityRepository.newEntity(self.__user__, DeviceData, params)
def addMember(self, user, workspace_id, user_id):
params = {
"group_id": workspace_id,
"user_id": user_id,
}
return entityRepository.newEntity(user, WorkspaceMember, params)
