def get_designs(
self,
name: Optional[str] = None,
gql_filter: Optional[dict] = None,
) -> List[dict]:
"""Retrieves a list of designs summary.
Args:
name (str, optional): Design's name to filter query. Defaults to None.
gql_filter (dict, optional): GraphicQL filter dictionary. May be used to add additional filter \
conditions. See api-docs. Defaults to None.
Returns:
List[dict]: A list of designs info. Each dict in the list contains name and id of each design.
"""
# Prepare parameters
args: Dict[str, Any] = {'gqlFilter': {}}
if name is not None:
args['gqlFilter']['name'] = name
if gql_filter is not None:
args['gqlFilter'].update(gql_filter)
# Param gqlFilter should be a json string
args['gqlFilter'] = json.dumps(args['gqlFilter'])
# Make request and process output
response = get(url=self.get_designs_url,
headers=self.headers,
params=args)
out = json.loads(response['content'])
# Remove useless key
for el in out:
el.pop('__typename')
return out
def rbs_calculator_organisms(
self,
as_dataframe: bool = True,
) -> Union[pd.DataFrame, Dict[str, Any]]:
"""Fetches all available organisms or host supported by the RBS Calculator tools.
Args:
as_dataframe(bool): Whether to return the response as a dataframe.
Returns:
List[Dict[str, str]]: A list of all the available organisms/hosts with their names and NCBI Accession IDs.
"""
try:
result = get(
url=self.rbs_calculator_organisms_url,
headers=self.headers,
)
except Exception as e:
return {
'error': e,
}
result = json.loads(result['content'])
result = pd.DataFrame(result) if as_dataframe else result
return result
def get_codon_optimization_job_results(
self,
job_id,
):
response = get(url=f'{self.get_codon_op_result}/{job_id}',
headers=self.headers)
# params=args)
return json.loads(response['content'])
def get_current_user(self): # -> CurrentUser
"""Gets the current user based on the header token.
Returns:
( ): The current user.
"""
# TODO : implement a method to get the expiration date of the current token
response = get(url=self.auth_url, headers=self.headers)
response['content'] = json.loads(response['content'])
return response
def get_multi_objective_optimization(
self,
taskId: TaskID, # noqa: N803
) -> Any:
response = get(
url=self.get_multi_objective_optimization_url.format(taskId),
headers=self.headers,
)
response['content'] = json.loads(response['content'])
return response['content']
def get_plates(
self,
pageNumber: str | int = '1', # noqa: N803,
pageSize: str | int = DEFAULT_PAGE_SIZE,
sort: str = '-updatedAt',
gqlFilter: str = '',
) -> List[PlateLibraryRecord]:
"""This paged entrypoint returns sets of plates.
Args:
pageNumber (str): 1 based paging parameter. Default: `"1"`.
pageSize (str): Number of records to return in a page. Default: `"100"`.
sort (str): sort column, default is id. Default: `"-updatedAt"`.
gqlFilter (str): A `graphql` filter to apply to the data. Example:
```GraphQL
{ "name" : ["Plate1", "Plate2"] } or { "id": ["1", "10", "22"]}
```
Returns:
List[PlateLibraryRecord]: List of plate records.
Example:
>>> # To query results by a specific field such as an `id`, use the `gqlFilter` parameter.
>>> import json
>>> plate_id: PlateID = "...." # NOTE: Replace with a valid id.
>>> gqlFilter: str = json.dumps({'id': str(plate_id)})
...
>>> # To query results by a specific field such as an `name`, use the `gqlFilter` parameter.
>>> import json
>>> plate_name: str = 'my_plate' # NOTE: Replace with a valid name.
>>> gqlFilter: str = json.dumps({'name': str(plate_name)})
...
"""
params: GetPlatesQueryParams = {
'pageNumber': str(pageNumber),
'pageSize': str(pageSize),
'sort': sort,
'gqlFilter': gqlFilter,
}
response = get(
url=self.plates_url,
headers=self.headers,
params=params,
)
assert response['content'] is not None, 'No content in response'
return cast(List[PlateLibraryRecord], json.loads(response['content']))
def get_laboratories(self) -> List[Laboratory]:
"""Get all available laboratories for the current user.
Returns :
(List[Laboratory]): A list of laboratories objects.
"""
response = get(url=self.labs_url, headers=self.headers)
# response["content"] = [{"id" : str, "name": str}, ...]
response['content'] = json.loads(response['content'])
return response['content']
def get_server_status(self) -> str:
"""Gets the current Server Status.
Returns:
str: The current Server Status.
"""
# NOTE: Response Schema is text/html
response = get(
url=self.status_url,
params=None,
headers=self.headers,
)
return response['content']
def rbs_calculator_status(self) -> dict:
"""Checks the status of the RBS Calculator Integration API.
Returns:
dict: {authenticated: boolean, success: boolean}
"""
try:
result = get(url=self.rbs_calculator_status_url,
headers=self.headers)
except Exception as e:
return {
'error': e,
}
return result['content']
def get_aliquots(
self,
pageNumber: str | int = '1', # noqa: N803
pageSize: str | int = DEFAULT_PAGE_SIZE,
sort: str = '-updatedAt',
gqlFilter: str = '',
) -> List[AliquotRecord]:
"""This is a paged entrypoint for returning many aliquot records.
Args:
pageNumber (str): 1 based paging parameter. Default: `"1"`.
pageSize (str): size of each page returned. Default: `"100"`.
sort (str): field to sort on, default is id. Default: `"-updatedAt"`.
gqlFilter (str): A `graphql` filter to apply to the data. Example:
```GraphQL
{ "sample.material.name" : ["PCR53.1", "Sequence2"] } or { "id": ["1", "10", "22"] }
```
Returns:
List[AliquotRecord]: List of aliquot records.
Example:
>>> # To query results by a specific field such as an `id`, use the `gqlFilter` parameter.
>>> import json
>>> aliquot_id: AliquotID = 1 # NOTE: Replace with a valid id.
>>> gqlFilter: str = json.dumps({'id': str(aliquot_id)})
...
"""
params: GetAliquotsQueryParams = {
'pageNumber': str(pageNumber),
'pageSize': str(pageSize),
'sort': str(sort),
'gqlFilter': str(gqlFilter),
}
response = get(
url=self.aliquots_url,
headers=self.headers,
params=params,
)
assert response['content'] is not None, 'No content in response'
return cast(List[AliquotRecord], json.loads(response['content']))
def get_aliquot(
self,
aliquot_id: AliquotID,
) -> AliquotRecord:
"""This function returns a single aliquot record.
Args:
aliquot_id (str): The id of the aliquot record you want to retrieve.
Returns:
AliquotRecord: Aliquot record.
Raises:
AliquotNotFoundError: If the aliquot record is not found.
"""
output_aliquot: AliquotRecord | None = None
try:
url: str = self.aliquot_url.format(str(aliquot_id))
response: ResponseDict = get(
url=url,
headers=self.headers,
)
assert response['content'] is not None # noqa: S101
output_aliquot = cast(AliquotRecord,
json.loads(response['content']))
except Exception as _exc:
# fallback to bruteforce if an error occurs
# NOTE: Since when using a method to get a single record, the user only have control over the id parameter,
# we can't use the same parameters as for the method to get many records. So, we choose to use the
# default parameters for the method to get many records.
# Except for the `gqlFilter` parameter, which is used for efficient querying.
get_records = wrapped_partial(self.get_aliquots,
gqlFilter=json.dumps(
{'id': str(aliquot_id)}))
output_aliquot = get_record(
get_records=get_records,
record_id=aliquot_id,
)
if output_aliquot is None:
raise AliquotNotFoundError(
f'Aliquot {aliquot_id} not found.') from _exc
return output_aliquot
def _design_crispr_grnas_get_result(
self,
task_id: TaskID,
):
"""Gets results from a design_crispr_grnas process.
Args:
task_id (TaskID): Process id
Returns:
dict: status of the process and, if finished, guides information as described in `design_crispr_grnas`.
"""
response = get(url=self.crispr_guide_rnas_result_url.format(task_id),
headers=self.headers)
return json.loads(response['content'])
def get_dna_sequences(
self,
name: str,
) -> List[dict]:
"""Get all sequences which names matches a string.
Args:
name (str): name of sequences to download
Returns:
List[dict]: List of dicts with sequence data.
"""
args = {'name': name}
response = get(url=self.export_dna_sequences_url,
headers=self.headers,
params=args)
return json.loads(response['content'])
def get_task(
self,
task_id: TaskID,
) -> Any:
"""Returns the status of a task based on the Task ID.
Args:
task_id (TaskID): The task id that wants to be canceled.
Returns: A task object with task metadata including its ID and status.
"""
response = get(
url=self.get_task_url.format(task_id),
headers=self.headers,
)
return json.loads(response['content'])
def get_design(
self,
design_id: Union[int, str],
) -> dict:
"""Retrieves the design with specified id.
Raises error if design_id is not found
Args:
design_id (str, int): Design's id
Returns:
dict: A dict containing designs information
"""
response = get(url=f'{self.get_design_url}/{design_id}',
headers=self.headers)
# params=args)
return json.loads(response['content'])
def get_dna_sequence(
self,
seq_id: int,
out_format: str = 'json',
out_filepath: Optional[str] = None,
) -> Union[str, dict]:
"""Gets full sequence record from its ID.
Args:
seq_id (int): Sequence id (can be found within the sequence detail url at UI)
out_format (str, optional): Output format. Use 'json' and the method will return a dict and 'fasta', or \
'genbank' to return a string based on those formats. This also determines the output format when \
writing an output file. Defaults to 'json'.
out_filepath (Optional[str], optional): Path to output file. If None it will not create any file. \
Defaults to None.
Raises:
ValueError: If format not available
Returns:
Union[str, dict]: A dict object with json data or a string if another format is chosen.
"""
if out_format not in self.ALLOWED_SEQ_FORMATS:
raise ValueError(
f'Format {out_format} not in {self.ALLOWED_SEQ_FORMATS}')
url = urljoin(self.export_dna_sequence_url, f'{out_format}/{seq_id}')
response = get(url=url, headers=self.headers)
# Write output file
if out_filepath is not None:
with open(out_filepath, 'w') as f:
f.write(response['content'])
# Parse json
if out_format == 'json':
response['content'] = json.loads(response['content'])
# Finish
return response['content']
def get_api_info(self) -> str:
"""Gets the current info about CLI API.
NOTE : To get the info, the client should be already authorized.
Returns:
(str): The current info about API.
"""
try:
response = get(
url=self.info_url,
headers=self.headers,
)
except Exception as e:
# TODO: Verify if we need to raise an exception.
response = ParsedJSONResponse(
url=self.info_url,
content=str(e),
status=False,
)
return response['content']
def get_plate(self, plate_id: str) -> PlateRecord:
"""This function returns a single plate by id.
Args:
plate_id (PlateID): The id of the plate to return.
Returns:
PlateRecord: Plate record.
Raises:
RecordNotFoundError: If the plate record is not found.
"""
output_plate: PlateRecord | None = None
url: str = self.plate_url.format(plate_id)
response: ResponseDict = get(
url=url,
headers=self.headers,
)
assert response['content'] is not None # noqa: S101
output_plate = cast(PlateRecord, json.loads(response['content']))
return output_plate
def rbs_calculator_get_jobs(
self,
job_id: str = None,
) -> dict:
"""Fetches an RBS Calculator Job with the provided job_id.
Args:
job_id (str): ID of an RBS Calculator Job
Returns:
dict: {authenticated: boolean, success: boolean}
"""
try:
result = get(
url=self.rbs_calculator_job_url.format(job_id)
if job_id is not None else self.rbs_calculator_jobs_url,
headers=self.headers,
)
except Exception as e:
return {
'error': e,
}
return result['content']
def export_aa_sequence(
self,
aa_sequence_id: str,
format: str = 'JSON',
):
"""This functions exports one amino acid sequence from TeselaGen DESIGN Module.
It requires the TeselaGen amino acid sequence ID.
Args:
aa_sequence_id(int): This is an integer ID corresponding to the TeselaGen amino acid sequence ID.
format(str): This is the format in which the amino acid sequence will be parsed into.
Available formats are:
- JSON (teselagen specific)
- FASTA
- GENBANK
Returns:
(Any): Amino acid sequence information depending on the format chosen. The 'JSON' format will provide the following properties:
- id: Amino acid sequence DESIGN ID.
- name: Amino acid sequence name.
- size: Number of residues for the amino acid sequence.
- molecularWeight: Teselagen calculated molecular weight of the amino acid sequence.
- extinctioCoefficient: Teselagen calculated extinction coefficient of the amino acid sequence.
- proteinSequence: String with the amino acid sequence.
- createdAt: Date in which the amino acid sequence record was created in TeselaGen.
- createdAt: Date in which the amino acid sequence record was last updated in TeselaGen.
- regionAnnotations: Teselagen region annotations (optional).
- isoPoint: Sequence isoelectric point (optional).
- uniprotId: UniProt ID for the amino acid sequence (optional).
- tags: any TeselaGen tags with which the amino acid sequence has been tagged (optional).
"""
if not isinstance(aa_sequence_id, str):
raise ValueError(
f"Argument 'aa_sequence_id' must be of type 'str', but received type '{type(aa_sequence_id)}'."
)
if format not in SUPPORTED_AA_EXPORT_FORMATS:
raise ValueError(
"Argument 'format' can only be one of this three strings: JSON, FASTA or GENBANK."
)
try:
result = get(url=self.export_aa_url.format(format, aa_sequence_id),
headers=self.headers)
except Exception as e:
return e
if format == 'JSON':
parsed_response = json.loads(result['content'])
formatted_response = {
'id':
parsed_response['id'],
'name':
parsed_response['name'],
'isoPoint':
parsed_response['isoPoint'],
'uniprotId':
parsed_response['uniprotId'],
'size':
parsed_response['size'],
'molecularWeight':
parsed_response['molecularWeight'],
'extinctionCoefficient':
parsed_response['extinctionCoefficient'],
'proteinSequence':
parsed_response['proteinSequence'],
'regionAnnotations':
parsed_response['regionAnnotations'],
'tags':
list(
map(
lambda x: {
'id': x['tag']['id'],
'name': x['tag']['name'],
}, parsed_response['taggedItems'])),
'createdAt':
parsed_response['createdAt'],
'updatedAt':
parsed_response['updatedAt'],
}
else:
formatted_response = result['content']
return formatted_response