class Meta(ChemblResourceMeta):
queryset = Biotherapeutics.objects.all()
resource_name = 'biotherapeutic'
collection_name = 'biotherapeutics'
detail_uri_name = 'molecule__chembl_id'
serializer = ChEMBLApiSerializer(resource_name, {
collection_name: resource_name,
'biocomponents': 'biocomponent'
})
prefetch_related = [
'bio_component_sequences',
Prefetch('molecule',
queryset=MoleculeDictionary.objects.only('chembl')),
]
fields = (
'molecule_chembl_id',
'description',
'helm_notation',
'biocomponents',
)
filtering = {
'molecule_chembl_id': CHAR_FILTERS,
'helm_notation': CHAR_FILTERS,
'description': FLAG_FILTERS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = MetabolismRefs.objects.all()
excludes = []
resource_name = 'metabolism_ref'
collection_name = 'metabolism_refs'
detail_uri_name = 'metref_id'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = []
fields = (
'ref_type',
'ref_id',
'ref_url',
)
filtering = {
'ref_type': CHAR_FILTERS,
'ref_id': CHAR_FILTERS,
'ref_url': CHAR_FILTERS,
}
ordering = [
field for field in list(filtering.keys())
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = StructuralAlerts.objects.all()
resource_name = 'structural_alert'
collection_name = 'structural_alerts'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [Prefetch('alertset')]
fields = (
'alert_id',
'alert_name',
'smarts',
)
filtering = {
'alert_id': NUMBER_FILTERS,
'alert_name': CHAR_FILTERS,
'smarts': CHAR_FILTERS,
'alert_set': ALL_WITH_RELATIONS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field
or 'canonical_smiles' in field)
]
class Meta(ChemblResourceMeta):
queryset = GoClassification.objects.all()
excludes = []
resource_name = 'go_slim'
collection_name = 'go_slims'
detail_uri_name = 'go_id'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = []
fields = (
'go_id',
'parent_go_id',
'pref_name',
'class_level',
'aspect',
'path',
)
filtering = {
'go_id': NUMBER_FILTERS,
'parent_go_id': NUMBER_FILTERS,
'pref_name': CHAR_FILTERS,
'class_level': NUMBER_FILTERS,
'aspect': CHAR_FILTERS,
'path': NUMBER_FILTERS,
}
ordering = [
field for field in list(filtering.keys())
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = AssayParameters.objects.all()
resource_name = 'assay_parameters'
collection_name = 'assay_parameters'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
filtering = {
'type': CHAR_FILTERS,
'relation': CHAR_FILTERS,
'value': NUMBER_FILTERS,
'units': CHAR_FILTERS,
'standard_type': CHAR_FILTERS,
'standard_relation': CHAR_FILTERS,
'standard_value': CHAR_FILTERS,
'standard_units': CHAR_FILTERS,
'standard_type_fixed': CHAR_FILTERS,
'active': NUMBER_FILTERS,
}
ordering = list(filtering.keys())
fields = (
'type',
'relation',
'value',
'units',
'text_value',
'standard_type',
'standard_relation',
'standard_value',
'standard_units',
'standard_text_value',
'comments',
'standard_type_fixed',
'active',
)
class Meta(ChemblResourceMeta):
queryset = TargetRelations.objects.all()
excludes = ['targrel_id']
resource_name = 'target_relation'
collection_name = 'target_relations'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
detail_uri_name = 'target__chembl_id'
prefetch_related = [
Prefetch('target',
queryset=TargetDictionary.objects.only('chembl')),
Prefetch('related_target',
queryset=TargetDictionary.objects.only('chembl')),
]
fields = ('relationship', )
filtering = {
'target_chembl_id': NUMBER_FILTERS,
'related_target_chembl_id': CHAR_FILTERS,
'relationship': CHAR_FILTERS,
}
ordering = [
field for field in list(filtering.keys())
if not ('comment' in field or 'description' in field
or 'canonical_smiles' in field)
]
class Meta(ChemblResourceMeta):
queryset = CompoundRecords.objects.all().filter(removed=False)
excludes = [
'filename', 'updated_by', 'updated_on', 'removed',
'src_compound_id', 'src_compound_id_version', 'load_date',
'curated', 'ridx', 'cidx', 'job_id', 'log_id', 'molregno_fixed',
'molregno_comment', 'molregno_sv'
]
resource_name = 'compound_record'
collection_name = 'compound_records'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('doc', queryset=Docs.objects.only('chembl')),
Prefetch('molecule',
queryset=MoleculeDictionary.objects.only('chembl')),
]
filtering = {
'compound_key': CHAR_FILTERS,
'compound_name': CHAR_FILTERS,
'molecule_chembl_id': ALL,
'document_chembl_id': ALL,
'curated': FLAG_FILTERS,
'src_id': NUMBER_FILTERS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = TissueDictionary.objects.all()
excludes = ['tissue_id']
resource_name = 'tissue'
collection_name = 'tissues'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
detail_uri_name = 'chembl_id'
prefetch_related = []
fields = (
'uberon_id',
'pref_name',
'efo_id',
'tissue_chembl_id',
'bto_id',
'caloha_id',
)
filtering = {
'tissue_id': NUMBER_FILTERS,
'uberon_id': ALL,
'pref_name': CHAR_FILTERS,
'efo_id': ALL,
'tissue_chembl_id': ALL,
'bto_id': ALL,
'caloha_id': ALL,
}
ordering = [field for field in list(filtering.keys()) if
not ('comment' in field or 'description' in field or 'canonical_smiles' in field)]
class Meta(ChemblResourceMeta):
queryset = AssayClassification.objects.all()
resource_name = 'assay_class'
collection_name = 'assay_classifications'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
filtering = {
'l1': CHAR_FILTERS,
'l2': CHAR_FILTERS,
'l3': CHAR_FILTERS,
'class_type': CHAR_FILTERS,
'bao_id': CHAR_FILTERS,
'source': CHAR_FILTERS,
}
ordering = filtering.keys()
fields = (
'assay_class_id',
'l1',
'l2',
'l3',
'class_type',
'bao_id',
'source',
)
class Meta(ChemblResourceMeta):
fields = [
'accession',
'component_id',
'component_type',
'relationship',
'component_description',
]
filtering = {
'accession': CHAR_FILTERS,
'component_id': NUMBER_FILTERS,
'component_type': CHAR_FILTERS,
'relationship': CHAR_FILTERS,
'component_description': CHAR_FILTERS,
'target_component_synonyms': ALL_WITH_RELATIONS,
}
prefetch_related = [
Prefetch('component',
queryset=ComponentSequences.objects.only(
'accession', 'pk', 'component_type', 'description')),
Prefetch('component__componentsynonyms_set'),
Prefetch('component__componentxref_set'),
]
queryset = TargetComponents.objects.all()
resource_name = 'target_component'
collection_name = 'target_components'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
class Meta(ChemblResourceMeta):
queryset = PaperSimilarity.objects.all()
detail_uri_name = 'doc_1__chembl_id'
resource_name = 'document_similarity'
collection_name = 'document_similarities'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('doc_1', queryset=Docs.objects.only('chembl')),
Prefetch('doc_2', queryset=Docs.objects.only('chembl')),
]
fields = (
'document_1_chembl_id',
'document_2_chembl_id',
'tid_tani',
'mol_tani',
)
filtering = {
'document_1_chembl_id': ALL,
'document_2_chembl_id': ALL,
'tid_tani': NUMBER_FILTERS,
'mol_tani': NUMBER_FILTERS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field
or 'canonical_smiles' in field)
]
class Meta(ChemblResourceMeta):
queryset = TargetPredictions.objects.all()
resource_name = 'target_prediction'
collection_name = 'target_predictions'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('target',
queryset=TargetDictionary.objects.only(
'chembl', 'organism', 'tid', 'tax_id')),
]
filtering = {
'pred_id': ALL,
'molecule_chembl_id': ALL,
'target_chembl_id': ALL,
'target_organism': ALL,
'target_tax_id': ALL,
'target_accession': CHAR_FILTERS,
'probability': NUMBER_FILTERS,
'in_training': FLAG_FILTERS,
'value': NUMBER_FILTERS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = TargetXref.objects.all()
resource_name = 'cross_reference'
collection_name = 'cross_references'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
fields = ('xref_name', 'xref_id', 'xref_src')
class Meta(ChemblResourceMeta):
queryset = OrganismClass.objects.all()
resource_name = 'organism'
collection_name = 'organisms'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('organismsynonyms_set',
queryset=OrganismSynonyms.objects.only(
'pk',
'synonyms',
)),
]
filtering = {
'oc_id': ALL,
'tax_id': ALL,
'l1': CHAR_FILTERS,
'l2': CHAR_FILTERS,
'l3': CHAR_FILTERS,
'l4_synonyms': ALL_WITH_RELATIONS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = Doc2Term.objects.all()
resource_name = 'document_term'
collection_name = 'document_terms'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('term', queryset=DocumentTerms.objects.only('term')),
Prefetch('doc', queryset=Docs.objects.only('chembl')),
]
fields = (
'score',
'term_text',
'document_chembl_id',
)
filtering = {
'term_text': CHAR_FILTERS,
'score': NUMBER_FILTERS,
'document_chembl_id': ALL,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field
or 'canonical_smiles' in field)
]
class Meta(ChemblResourceMeta):
queryset = BioComponentSequences.objects.all()
excludes = ['sequence_md5sum']
resource_name = 'biocomponent'
collection_name = 'biocomponents'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
fields = (
'component_id',
'component_type',
'description',
'sequence',
'tax_id',
'organism',
)
filtering = {
'component_id': NUMBER_FILTERS,
'component_type': CHAR_FILTERS,
# 'description': ALL,
'organism': CHAR_FILTERS,
'tax_id': NUMBER_FILTERS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = CompoundProperties.objects.all()
resource_name = 'molecule_properties'
collection_name = 'molecule_properties'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
fields = (
'cx_logd',
'cx_logp',
'cx_most_apka',
'cx_most_bpka',
'alogp',
'aromatic_rings',
'full_molformula',
'full_mwt',
'hba',
'hbd',
'heavy_atoms',
'med_chem_friendly',
'molecular_species',
'mw_freebase',
'mw_monoisotopic',
'num_ro5_violations',
'psa',
'qed_weighted',
'ro3_pass',
'rtb',
'hba_lipinski',
'hbd_lipinski',
'num_lipinski_ro5_violations',
)
filtering = {
'cx_logd': NUMBER_FILTERS,
'cx_logp': NUMBER_FILTERS,
'cx_most_apka': NUMBER_FILTERS,
'cx_most_bpka': NUMBER_FILTERS,
'alogp': NUMBER_FILTERS,
'aromatic_rings': NUMBER_FILTERS,
'full_molformula': CHAR_FILTERS,
'full_mwt': NUMBER_FILTERS,
'hba': NUMBER_FILTERS,
'hbd': NUMBER_FILTERS,
'heavy_atoms': NUMBER_FILTERS,
'med_chem_friendly': CHAR_FILTERS,
'molecular_species': CHAR_FILTERS,
'mw_freebase': NUMBER_FILTERS,
'mw_monoisotopic': NUMBER_FILTERS,
'num_ro5_violations': NUMBER_FILTERS,
'psa': NUMBER_FILTERS,
'qed_weighted': NUMBER_FILTERS,
'ro3_pass': CHAR_FILTERS,
'rtb': NUMBER_FILTERS,
'hba_lipinski': NUMBER_FILTERS,
'hbd_lipinski': NUMBER_FILTERS,
'num_lipinski_ro5_violations': NUMBER_FILTERS,
}
ordering = list(filtering.keys())
class Meta(ChemblResourceMeta):
queryset = MoleculeBrowseDrugs.objects.all()
excludes = [
'drug_type_text', 'rule_of_five_text', 'first_in_class_text',
'chirality_text', 'prodrug_text', 'oral_text', 'parenteral_text',
'topical_text', 'black_box_text', 'availability_type_text',
'parent_molregno', 'atc_code'
]
resource_name = 'drug'
collection_name = 'drugs'
detail_uri_name = 'chembl_id'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('parent'),
Prefetch('parent__moleculesynonyms_set'),
Prefetch('parent__atcclassification_set'),
Prefetch('parent__biotherapeutics'),
Prefetch('parent__biotherapeutics__bio_component_sequences'),
Prefetch('parent__compoundproperties'),
Prefetch('parent__compoundstructures'),
]
filtering = {
'applicants': CHAR_FILTERS,
'atc_code': CHAR_FILTERS,
'molecule_synonyms': ALL_WITH_RELATIONS,
'atc_code_description': CHAR_FILTERS,
'availability_type': NUMBER_FILTERS,
'black_box': FLAG_FILTERS,
'chirality': NUMBER_FILTERS,
'development_phase': NUMBER_FILTERS,
'drug_type': NUMBER_FILTERS,
'first_approval': NUMBER_FILTERS,
'first_in_class': FLAG_FILTERS,
'indication_class': CHAR_FILTERS,
'molecule_chembl_id': ALL,
'ob_patent': CHAR_FILTERS,
'oral': FLAG_FILTERS,
'parenteral': FLAG_FILTERS,
'prodrug': FLAG_FILTERS,
'research_codes': CHAR_FILTERS,
'rule_of_five': FLAG_FILTERS,
'sc_patent': CHAR_FILTERS,
'synonyms': CHAR_FILTERS,
'topical': FLAG_FILTERS,
'usan_stem': CHAR_FILTERS,
'usan_stem_definition': CHAR_FILTERS,
'usan_stem_substem': CHAR_FILTERS,
'usan_year': NUMBER_FILTERS,
'withdrawn_country': CHAR_FILTERS,
'withdrawn_reason': CHAR_FILTERS,
'withdrawn_year': NUMBER_FILTERS,
'withdrawn_class': CHAR_FILTERS,
}
ordering = [
field for field in list(filtering.keys())
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = Docs.objects.all()
es_join_column = 'chembl_id'
excludes = ['doc_id']
resource_name = 'document'
collection_name = 'documents'
detail_uri_name = 'chembl_id'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
prefetch_related = [
Prefetch('journal_id',
queryset=Journals.objects.only('pk', 'title'))
]
fields = (
'abstract',
'authors',
'doc_type',
'document_chembl_id',
'doi',
'doi_chembl',
'first_page',
'issue',
'journal',
'last_page',
'pubmed_id',
'src_id',
'title',
'volume',
'year',
'patent_id',
'journal_full_title',
)
filtering = {
'abstract': CHAR_FILTERS,
'authors': CHAR_FILTERS,
'doc_type': CHAR_FILTERS,
'document_chembl_id': NUMBER_FILTERS,
'doi': CHAR_FILTERS,
'doi_chembl': CHAR_FILTERS,
'first_page': CHAR_FILTERS,
'issue': CHAR_FILTERS,
'journal': CHAR_FILTERS,
'last_page': CHAR_FILTERS,
'pubmed_id': NUMBER_FILTERS,
'title': CHAR_FILTERS,
'volume': CHAR_FILTERS,
'year': NUMBER_FILTERS,
'patent_id': CHAR_FILTERS,
'journal_full_title': CHAR_FILTERS,
}
ordering = [
field for field in list(filtering.keys())
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = TargetDictionary.objects.all() if 'downgraded' not in available_fields else \
TargetDictionary.objects.filter(downgraded=False)
es_join_column = 'chembl_id'
excludes = ['tid']
resource_name = 'target'
collection_name = 'targets'
serializer = ChEMBLApiSerializer(
resource_name, {
collection_name: resource_name,
'target_components': 'target_component',
'target_component_synonyms': 'target_component_synonym'
})
detail_uri_name = 'chembl_id'
prefetch_related = [
Prefetch('targetcomponents_set',
queryset=TargetComponents.objects.only(
'pk', 'relationship', 'target', 'component')),
Prefetch('targetcomponents_set__component',
queryset=ComponentSequences.objects.only(
'accession', 'pk', 'component_type', 'description')),
Prefetch('targetxref_set',
queryset=TargetXref.objects.only('pk', 'target',
'xref_name', 'xref_id',
'xref_src_db')),
Prefetch('targetxref_set__xref_src_db',
queryset=XrefSource.objects.only('pk')),
Prefetch('targetcomponents_set__component__componentsynonyms_set'),
Prefetch('targetcomponents_set__component__componentxref_set'),
]
fields = (
'organism',
'tax_id',
'pref_name',
'species_group_flag',
'target_chembl_id',
)
filtering = {
'organism': CHAR_FILTERS,
'tax_id': NUMBER_FILTERS,
'pref_name': CHAR_FILTERS,
'target_type': CHAR_FILTERS,
'species_group_flag': FLAG_FILTERS,
'target_chembl_id': ALL,
'target_components': ALL_WITH_RELATIONS,
}
ordering = [
'organism',
'tax_id',
'pref_name',
'target_type',
'species_group_flag',
'target_chembl_id',
]
class Meta(ChemblResourceMeta):
queryset = Source.objects.all()
resource_name = 'source'
collection_name = 'sources'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
filtering = {
'src_description': CHAR_FILTERS,
'src_id': NUMBER_FILTERS,
'src_short_name': CHAR_FILTERS,
}
ordering = [field for field in filtering.keys() if not ('comment' in field or 'description' in field)]
excludes = ['default_doc_id', 'default_loadtype']
class Meta(ChemblResourceMeta):
queryset = MoleculeSynonyms.objects.all()
excludes = ['molsyn_id']
resource_name = 'synonym'
collection_name = 'molecule_synonyms'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
filtering = {
'molecule_synonym': CHAR_FILTERS,
'syn_type': CHAR_FILTERS,
'synonyms': CHAR_FILTERS,
}
class Meta(ChemblResourceMeta):
queryset = LigandEff.objects.all()
resource_name = 'ligand_efficiency'
collection_name = 'ligand_efficiencies'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
filtering = {
'bei': NUMBER_FILTERS,
'sei': NUMBER_FILTERS,
'le': NUMBER_FILTERS,
'lle': NUMBER_FILTERS,
}
ordering = filtering.keys()
class Meta(ChemblResourceMeta):
queryset = ProteinClassification.objects.all()
resource_name = 'protein_classification'
collection_name = 'protein_classifications'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
fields = ('protein_classification_id', )
filtering = {
'protein_classification_id': FLAG_FILTERS,
}
class Meta(ChemblResourceMeta):
excludes = ['site_residues']
queryset = SiteComponents.objects.all()
resource_name = 'site_component'
collection_name = 'site_components'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
filtering = {
'component_id': NUMBER_FILTERS,
'sitecomp_id': NUMBER_FILTERS,
'domain': ALL_WITH_RELATIONS,
}
ordering = filtering.keys()
class Meta(ChemblResourceMeta):
queryset = DrugMechanism.objects.all()
resource_name = 'mechanism'
collection_name = 'mechanisms'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
prefetch_related = [
Prefetch('molecule', queryset=MoleculeDictionary.objects.only('chembl', 'max_phase')),
Prefetch('target', queryset=TargetDictionary.objects.only('chembl')),
Prefetch('mechanismrefs_set'),
Prefetch('molecule__moleculehierarchy'),
Prefetch('molecule__moleculehierarchy__parent_molecule',
queryset=MoleculeDictionary.objects.only('chembl')),
]
fields = (
'action_type',
'binding_site_comment',
'direct_interaction',
'disease_efficacy',
'max_phase',
'mec_id',
'mechanism_comment',
'mechanism_of_action',
'molecular_mechanism',
'molecule_chembl_id',
'record_id',
'selectivity_comment',
'site_id',
'target_chembl_id',
'parent_molecule_chembl_id'
)
filtering = {
'action_type': CHAR_FILTERS,
'binding_site_comment': CHAR_FILTERS,
'direct_interaction': FLAG_FILTERS,
'disease_efficacy': FLAG_FILTERS,
'max_phase': NUMBER_FILTERS,
'mec_id': NUMBER_FILTERS,
'mechanism_comment': CHAR_FILTERS,
'mechanism_of_action': CHAR_FILTERS,
'molecular_mechanism': FLAG_FILTERS,
'molecule_chembl_id': ALL,
'parent_molecule_chembl_id': ALL,
'record_id' : NUMBER_FILTERS,
'selectivity_comment': CHAR_FILTERS,
'site_id': NUMBER_FILTERS,
'target_chembl_id': ALL,
}
ordering = [field for field in list(filtering.keys()) if not ('comment' in field or 'description' in field)]
class Meta(ChemblResourceMeta):
queryset = XrefSource.objects.all()
excludes = []
resource_name = 'xref_source'
collection_name = 'xref_sources'
serializer = ChEMBLApiSerializer(resource_name, {collection_name: resource_name})
filtering = {
'xref_src_db': CHAR_FILTERS,
'xref_src_description': CHAR_FILTERS,
'xref_src_url': CHAR_FILTERS,
'xref_id_url': CHAR_FILTERS,
}
ordering = [field for field in filtering.keys() if not ('comment' in field or 'description' in field)]
class Meta(ChemblResourceMeta):
queryset = OrganismSynonyms.objects.all()
excludes = ['tax_id', 'source']
resource_name = 'organism_synonyms'
collection_name = 'synonyms'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
filtering = {
'synonyms': ALL_WITH_RELATIONS,
}
ordering = [
field for field in filtering.keys()
if not ('comment' in field or 'description' in field)
]
class Meta(ChemblResourceMeta):
queryset = Domains.objects.all()
resource_name = 'domain'
collection_name = 'domains'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
filtering = {
'domain_description': CHAR_FILTERS,
'domain_id': NUMBER_FILTERS,
'domain_name': CHAR_FILTERS,
'domain_type': CHAR_FILTERS,
'source_domain_id': CHAR_FILTERS,
}
ordering = filtering.keys()
class Meta(ChemblResourceMeta):
queryset = CompoundStructures.objects.all()
# excludes = ['molfile']
resource_name = 'molecule_structures'
collection_name = 'molecule_structures'
serializer = ChEMBLApiSerializer(resource_name,
{collection_name: resource_name})
fields = ('standard_inchi', 'standard_inchi_key', 'canonical_smiles',
'molfile')
filtering = {
'canonical_smiles': CHAR_FILTERS,
'standard_inchi_key': CHAR_FILTERS,
}
cairocffi.install_as_pycairo()
cffi = True
import io
import cairo
if not hasattr(cairo, 'HAS_PDF_SURFACE'):
cairo.HAS_PDF_SURFACE = False
if not hasattr(cairo, 'HAS_SVG_SURFACE'):
cairo.HAS_SVG_SURFACE = True
SUPPORTED_ENGINES = ['rdkit', 'indigo']
options = DrawingOptions()
options.useFraction = 1.0
options.dblBondOffset = .13
fakeSerializer = ChEMBLApiSerializer('image')
fakeSerializer.formats = ['png', 'svg', 'json']
available_fields = [f.name for f in MoleculeDictionary._meta.fields]
#-----------------------------------------------------------------------------------------------------------------------
class ImageResource(ChemblModelResource):
#-----------------------------------------------------------------------------------------------------------------------
class Meta(ChemblResourceMeta):
resource_name = 'image'
serializer = fakeSerializer
default_format = 'image/png'
description = {'api_dispatch_detail' : '''