icat.entities — Provide classes corresponding to the ICAT schema

Provide the classes corresponding to the entities in the ICAT schema.

Entity classes defined in this module are derived from the abstract base class icat.entity.Entity. They override the class attributes icat.entity.Entity.BeanName, icat.entity.Entity.Constraint, icat.entity.Entity.InstAttr, icat.entity.Entity.InstRel, icat.entity.Entity.InstMRel, icat.entity.Entity.AttrAlias, and icat.entity.Entity.SortAttrs as appropriate.

class icat.entities.Parameter(client, instance, **kwargs)

Bases: icat.entity.Entity

Abstract base class for icat.entities.DatafileParameter, icat.entities.DatasetParameter, icat.entities.InvestigationParameter, icat.entities.SampleParameter, and icat.entities.DataCollectionParameter.

InstAttr = frozenset(['numericValue', 'rangeBottom', 'rangeTop', 'dateTimeValue', 'error', 'stringValue', 'id'])

InstRel = frozenset(['type'])

class icat.entities.Application(client, instance, **kwargs)

Bases: icat.entity.Entity

Some piece of software.

BeanName = 'Application'

Constraint = ('name', 'version')

InstAttr = frozenset(['version', 'id', 'name'])

InstMRel = frozenset(['jobs'])

class icat.entities.Application43(client, instance, **kwargs)

Bases: icat.entities.Application

Some piece of software.

Constraint = ('facility', 'name', 'version')

InstRel = frozenset(['facility'])

class icat.entities.DataCollection(client, instance, **kwargs)

Bases: icat.entity.Entity

A set of Datafiles and Datasets which can span investigations and facilities. Note that it has no constraint fields. It is expected that a DataCollection would be identified by its DataCollectionParameters or its relationship to a Job.

BeanName = 'DataCollection'

InstMRel = frozenset(['dataCollectionParameters', 'dataCollectionDatasets', 'jobsAsOutput', 'dataCollectionDatafiles', 'jobsAsInput'])

AttrAlias = {'parameters': 'dataCollectionParameters'}

SortAttrs = ['dataCollectionDatasets', 'dataCollectionDatafiles']

class icat.entities.DataCollection431(client, instance, **kwargs)

Bases: icat.entities.DataCollection

A set of Datafiles and Datasets which can span investigations and facilities. Note that it has no constraint fields. It is expected that a DataCollection would be identified by its parameters or its relationship to a Job.

InstMRel = frozenset(['dataCollectionDatasets', 'jobsAsOutput', 'parameters', 'dataCollectionDatafiles', 'jobsAsInput'])

AttrAlias = {'dataCollectionParameters': 'parameters'}

class icat.entities.DataCollectionDatafile(client, instance, **kwargs)

Bases: icat.entity.Entity

Represents a many-to-many relationship between a DataCollection and its Datafiles.

BeanName = 'DataCollectionDatafile'

Constraint = ('dataCollection', 'datafile')

InstRel = frozenset(['dataCollection', 'datafile'])

SortAttrs = ['datafile']

class icat.entities.DataCollectionDataset(client, instance, **kwargs)

Bases: icat.entity.Entity

Represents a many-to-many relationship between a DataCollection and its datasets.

BeanName = 'DataCollectionDataset'

Constraint = ('dataCollection', 'dataset')

InstRel = frozenset(['dataCollection', 'dataset'])

SortAttrs = ['dataset']

class icat.entities.DataCollectionParameter(client, instance, **kwargs)

Bases: icat.entities.Parameter

A parameter associated with a DataCollection.

BeanName = 'DataCollectionParameter'

Constraint = ('dataCollection', 'type')

InstRel = frozenset(['dataCollection', 'type'])

class icat.entities.Datafile(client, instance, **kwargs)

Bases: icat.entity.Entity

A data file.

BeanName = 'Datafile'

Constraint = ('name', 'location', 'dataset')

InstAttr = frozenset(['doi', 'description', 'checksum', 'name', 'location', 'datafileCreateTime', 'id', 'datafileModTime', 'fileSize'])

InstRel = frozenset(['datafileFormat', 'dataset'])

InstMRel = frozenset(['outputDatafiles', 'destDatafiles', 'sourceDatafiles', 'parameters', 'inputDatafiles'])

class icat.entities.Datafile43(client, instance, **kwargs)

Bases: icat.entities.Datafile

A data file.

Constraint = ('dataset', 'name')

InstMRel = frozenset(['destDatafiles', 'dataCollectionDatafiles', 'parameters', 'sourceDatafiles'])

class icat.entities.DatafileFormat(client, instance, **kwargs)

Bases: icat.entity.Entity

A data file format.

BeanName = 'DatafileFormat'

Constraint = ('facility', 'name', 'version')

InstAttr = frozenset(['description', 'version', 'type', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['datafiles'])

class icat.entities.DatafileParameter(client, instance, **kwargs)

Bases: icat.entities.Parameter

A parameter associated with a data file.

BeanName = 'DatafileParameter'

Constraint = ('datafile', 'type')

InstRel = frozenset(['datafile', 'type'])

class icat.entities.Dataset(client, instance, **kwargs)

Bases: icat.entity.Entity

A collection of data files and part of an investigation.

BeanName = 'Dataset'

Constraint = ('sample', 'investigation', 'name', 'type')

InstAttr = frozenset(['startDate', 'doi', 'endDate', 'description', 'location', 'complete', 'id', 'name'])

InstRel = frozenset(['sample', 'investigation', 'type'])

InstMRel = frozenset(['inputDatasets', 'datafiles', 'outputDatasets', 'parameters'])

class icat.entities.Dataset43(client, instance, **kwargs)

Bases: icat.entities.Dataset

A collection of data files and part of an investigation.

Constraint = ('investigation', 'name')

InstMRel = frozenset(['dataCollectionDatasets', 'datafiles', 'parameters'])

class icat.entities.DatasetParameter(client, instance, **kwargs)

Bases: icat.entities.Parameter

A parameter associated with a data set.

BeanName = 'DatasetParameter'

Constraint = ('dataset', 'type')

InstRel = frozenset(['type', 'dataset'])

class icat.entities.DatasetType(client, instance, **kwargs)

Bases: icat.entity.Entity

A type of data set.

BeanName = 'DatasetType'

Constraint = ('facility', 'name')

InstAttr = frozenset(['description', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['datasets'])

class icat.entities.Facility(client, instance, **kwargs)

Bases: icat.entity.Entity

An experimental facility.

BeanName = 'Facility'

Constraint = ('name',)

InstAttr = frozenset(['daysUntilRelease', 'description', 'url', 'fullName', 'id', 'name'])

InstMRel = frozenset(['investigations', 'instruments', 'sampleTypes', 'datasetTypes', 'datafileFormats', 'facilityCycles', 'parameterTypes', 'investigationTypes'])

class icat.entities.Facility43(client, instance, **kwargs)

Bases: icat.entities.Facility

An experimental facility.

InstMRel = frozenset(['investigations', 'instruments', 'sampleTypes', 'datasetTypes', 'datafileFormats', 'applications', 'facilityCycles', 'parameterTypes', 'investigationTypes'])

class icat.entities.FacilityCycle(client, instance, **kwargs)

Bases: icat.entity.Entity

An operating cycle within a facility

BeanName = 'FacilityCycle'

Constraint = ('facility', 'name')

InstAttr = frozenset(['startDate', 'description', 'endDate', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['investigations'])

class icat.entities.FacilityCycle43(client, instance, **kwargs)

Bases: icat.entities.FacilityCycle

An operating cycle within a facility.

InstMRel = frozenset([])

class icat.entities.Group(client, instance, **kwargs)

Bases: icat.entity.Entity

A group of users.

BeanName = 'Group'

Constraint = ('name',)

InstAttr = frozenset(['id', 'name'])

InstMRel = frozenset(['rules', 'userGroups'])

addUsers(users)

getUsers(attribute=None)

class icat.entities.Group43(client, instance, **kwargs)

Bases: icat.entities.Group

A group of users.

BeanName = 'Grouping'

class icat.entities.Group44(client, instance, **kwargs)

Bases: icat.entities.Group43

A group of users.

InstMRel = frozenset(['rules', 'userGroups', 'investigationGroups'])

class icat.entities.InputDatafile(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between data file as input and a job.

BeanName = 'InputDatafile'

InstRel = frozenset(['job', 'datafile'])

SortAttrs = ['job', 'datafile']

class icat.entities.InputDataset(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between data set as input and a job.

BeanName = 'InputDataset'

InstRel = frozenset(['job', 'dataset'])

SortAttrs = ['job', 'dataset']

class icat.entities.Instrument(client, instance, **kwargs)

Bases: icat.entity.Entity

Used by a user within an investigation.

BeanName = 'Instrument'

Constraint = ('facility', 'name')

InstAttr = frozenset(['fullName', 'description', 'type', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['instrumentScientists', 'investigations'])

addInstrumentScientists(users)

getInstrumentScientists(attribute=None)

class icat.entities.Instrument43(client, instance, **kwargs)

Bases: icat.entities.Instrument

Used by a user within an investigation.

InstAttr = frozenset(['description', 'url', 'fullName', 'type', 'id', 'name'])

InstMRel = frozenset(['investigationInstruments', 'instrumentScientists'])

class icat.entities.InstrumentScientist(client, instance, **kwargs)

Bases: icat.entity.Entity

Relationship between an ICAT user as an instrument scientist and the instrument.

BeanName = 'InstrumentScientist'

Constraint = ('user', 'instrument')

InstRel = frozenset(['instrument', 'user'])

class icat.entities.Investigation(client, instance, **kwargs)

Bases: icat.entity.Entity

An investigation or experiment.

BeanName = 'Investigation'

Constraint = ('name', 'visitId', 'facilityCycle', 'instrument')

InstAttr = frozenset(['startDate', 'doi', 'endDate', 'name', 'title', 'summary', 'releaseDate', 'visitId', 'id'])

InstRel = frozenset(['instrument', 'type', 'facilityCycle', 'facility'])

InstMRel = frozenset(['datasets', 'parameters', 'studyInvestigations', 'investigationUsers', 'shifts', 'publications', 'samples', 'keywords'])

addInstrument(instrument)

addKeywords(keywords)

addInvestigationUsers(users, role='Investigator')

class icat.entities.Investigation43(client, instance, **kwargs)

Bases: icat.entities.Investigation

An investigation or experiment.

Constraint = ('facility', 'name', 'visitId')

InstRel = frozenset(['type', 'facility'])

InstMRel = frozenset(['datasets', 'parameters', 'studyInvestigations', 'investigationInstruments', 'investigationUsers', 'shifts', 'publications', 'samples', 'keywords'])

addInstrument(instrument)

class icat.entities.Investigation44(client, instance, **kwargs)

Bases: icat.entities.Investigation43

An investigation or experiment.

InstMRel = frozenset(['datasets', 'parameters', 'studyInvestigations', 'investigationInstruments', 'investigationUsers', 'investigationGroups', 'shifts', 'publications', 'samples', 'keywords'])

addInvestigationGroup(group, role=None)

class icat.entities.InvestigationGroup(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between investigation and group.

BeanName = 'InvestigationGroup'

Constraint = ('grouping', 'investigation', 'role')

InstAttr = frozenset(['role', 'id'])

InstRel = frozenset(['investigation', 'grouping'])

class icat.entities.InvestigationInstrument(client, instance, **kwargs)

Bases: icat.entity.Entity

Represents a many-to-many relationship between an investigation and the instruments assigned.

BeanName = 'InvestigationInstrument'

Constraint = ('investigation', 'instrument')

InstRel = frozenset(['instrument', 'investigation'])

class icat.entities.InvestigationParameter(client, instance, **kwargs)

Bases: icat.entities.Parameter

A parameter associated with an investigation.

BeanName = 'InvestigationParameter'

Constraint = ('investigation', 'type')

InstRel = frozenset(['investigation', 'type'])

class icat.entities.InvestigationType(client, instance, **kwargs)

Bases: icat.entity.Entity

A type of investigation.

BeanName = 'InvestigationType'

Constraint = ('name', 'facility')

SortAttrs = ['facility', 'name']

InstAttr = frozenset(['description', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['investigations'])

class icat.entities.InvestigationUser(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between investigation and user.

BeanName = 'InvestigationUser'

Constraint = ('user', 'investigation')

InstAttr = frozenset(['role', 'id'])

InstRel = frozenset(['investigation', 'user'])

class icat.entities.InvestigationUser44(client, instance, **kwargs)

Bases: icat.entities.InvestigationUser

Many to many relationship between investigation and user.

Constraint = ('user', 'investigation', 'role')

class icat.entities.Job(client, instance, **kwargs)

Bases: icat.entity.Entity

A run of an application with its related inputs and outputs.

BeanName = 'Job'

InstRel = frozenset(['application'])

InstMRel = frozenset(['inputDatasets', 'outputDatafiles', 'outputDatasets', 'inputDatafiles'])

SortAttrs = ['application', 'inputDatasets', 'inputDatafiles', 'outputDatasets', 'outputDatafiles']

class icat.entities.Job43(client, instance, **kwargs)

Bases: icat.entities.Job

A run of an application with its related inputs and outputs.

InstAttr = frozenset(['id', 'arguments'])

InstRel = frozenset(['application', 'inputDataCollection', 'outputDataCollection'])

InstMRel = frozenset([])

SortAttrs = ['application', 'arguments', 'inputDataCollection', 'outputDataCollection']

class icat.entities.Keyword(client, instance, **kwargs)

Bases: icat.entity.Entity

A Keyword related to an investigation.

BeanName = 'Keyword'

Constraint = ('name', 'investigation')

InstAttr = frozenset(['id', 'name'])

InstRel = frozenset(['investigation'])

class icat.entities.NotificationRequest(client, instance, **kwargs)

Bases: icat.entity.Entity

Registers a request for a JMS notification to be sent out.

BeanName = 'NotificationRequest'

Constraint = ('name',)

InstAttr = frozenset(['what', 'name', 'jmsOptions', 'destType', 'crudFlags', 'datatypes', 'id'])

class icat.entities.Log(client, instance, **kwargs)

Bases: icat.entity.Entity

To store call logs if configured in icat.properties.

BeanName = 'Log'

InstAttr = frozenset(['entityName', 'id', 'duration', 'query', 'entityId', 'operation'])

SortAttrs = ['operation', 'entityName']

class icat.entities.OutputDatafile(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between data file as output and a job.

BeanName = 'OutputDatafile'

InstRel = frozenset(['job', 'datafile'])

SortAttrs = ['job', 'datafile']

class icat.entities.OutputDataset(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between data set as output and a job.

BeanName = 'OutputDataset'

InstRel = frozenset(['job', 'dataset'])

SortAttrs = ['job', 'dataset']

class icat.entities.ParameterType(client, instance, **kwargs)

Bases: icat.entity.Entity

A parameter type with unique name and units.

BeanName = 'ParameterType'

Constraint = ('facility', 'name', 'units')

InstAttr = frozenset(['enforced', 'verified', 'description', 'applicableToSample', 'maximumNumericValue', 'valueType', 'applicableToInvestigation', 'unitsFullName', 'minimumNumericValue', 'units', 'applicableToDataset', 'applicableToDatafile', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['datafileParameters', 'investigationParameters', 'datasetParameters', 'sampleParameters', 'permissibleStringValues'])

class icat.entities.ParameterType43(client, instance, **kwargs)

Bases: icat.entities.ParameterType

A parameter type with unique name and units.

InstAttr = frozenset(['enforced', 'verified', 'description', 'applicableToSample', 'maximumNumericValue', 'valueType', 'applicableToInvestigation', 'unitsFullName', 'minimumNumericValue', 'units', 'applicableToDataCollection', 'applicableToDataset', 'applicableToDatafile', 'id', 'name'])

InstMRel = frozenset(['dataCollectionParameters', 'sampleParameters', 'datafileParameters', 'datasetParameters', 'investigationParameters', 'permissibleStringValues'])

class icat.entities.PermissibleStringValue(client, instance, **kwargs)

Bases: icat.entity.Entity

Permissible value for string parameter types.

BeanName = 'PermissibleStringValue'

Constraint = ('value', 'type')

InstAttr = frozenset(['id', 'value'])

InstRel = frozenset(['type'])

class icat.entities.PublicStep(client, instance, **kwargs)

Bases: icat.entity.Entity

An allowed step for an INCLUDE identifed by the origin entity and the field name for navigation. Including an entry here is much more efficient than having to use the authorization rules.

BeanName = 'PublicStep'

Constraint = ('origin', 'field')

InstAttr = frozenset(['origin', 'field', 'id'])

class icat.entities.Publication(client, instance, **kwargs)

Bases: icat.entity.Entity

A publication.

BeanName = 'Publication'

InstAttr = frozenset(['fullReference', 'repository', 'url', 'repositoryId', 'doi', 'id'])

InstRel = frozenset(['investigation'])

SortAttrs = ['investigation', 'fullReference']

class icat.entities.RelatedDatafile(client, instance, **kwargs)

Bases: icat.entity.Entity

Used to represent an arbitrary relationship between data files.

BeanName = 'RelatedDatafile'

Constraint = ('sourceDatafile', 'destDatafile')

InstAttr = frozenset(['relation', 'id'])

InstRel = frozenset(['destDatafile', 'sourceDatafile'])

class icat.entities.Rule(client, instance, **kwargs)

Bases: icat.entity.Entity

An authorization rule.

BeanName = 'Rule'

InstAttr = frozenset(['crudFlags', 'what', 'id'])

InstRel = frozenset(['group'])

AttrAlias = {'grouping': 'group'}

SortAttrs = ['group', 'what']

class icat.entities.Rule43(client, instance, **kwargs)

Bases: icat.entities.Rule

An authorization rule.

InstRel = frozenset(['grouping'])

AttrAlias = {'group': 'grouping'}

SortAttrs = ['grouping', 'what']

class icat.entities.Sample(client, instance, **kwargs)

Bases: icat.entity.Entity

A sample to be used in an investigation.

BeanName = 'Sample'

Constraint = ('name', 'type', 'investigation')

InstAttr = frozenset(['id', 'name'])

InstRel = frozenset(['investigation', 'type'])

InstMRel = frozenset(['datasets', 'parameters'])

class icat.entities.Sample43(client, instance, **kwargs)

Bases: icat.entities.Sample

A sample to be used in an investigation.

Constraint = ('investigation', 'name')

class icat.entities.SampleParameter(client, instance, **kwargs)

Bases: icat.entities.Parameter

A parameter associated with a sample.

BeanName = 'SampleParameter'

Constraint = ('sample', 'type')

InstRel = frozenset(['sample', 'type'])

class icat.entities.SampleType(client, instance, **kwargs)

Bases: icat.entity.Entity

A sample to be used in an investigation.

BeanName = 'SampleType'

Constraint = ('name', 'facility')

InstAttr = frozenset(['molecularFormula', 'safetyInformation', 'id', 'name'])

InstRel = frozenset(['facility'])

InstMRel = frozenset(['samples'])

class icat.entities.SampleType43(client, instance, **kwargs)

Bases: icat.entities.SampleType

A sample to be used in an investigation.

Constraint = ('facility', 'name', 'molecularFormula')

class icat.entities.Shift(client, instance, **kwargs)

Bases: icat.entity.Entity

A period of time related to an investigation.

BeanName = 'Shift'

Constraint = ('investigation', 'startDate', 'endDate')

InstAttr = frozenset(['comment', 'startDate', 'endDate', 'id'])

InstRel = frozenset(['investigation'])

class icat.entities.Study(client, instance, **kwargs)

Bases: icat.entity.Entity

A study which may be related to an investigation.

BeanName = 'Study'

InstAttr = frozenset(['status', 'startDate', 'description', 'id', 'name'])

InstRel = frozenset(['user'])

InstMRel = frozenset(['studyInvestigations'])

SortAttrs = ['name']

class icat.entities.StudyInvestigation(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between study and investigation.

BeanName = 'StudyInvestigation'

Constraint = ('study', 'investigation')

InstRel = frozenset(['study', 'investigation'])

class icat.entities.User(client, instance, **kwargs)

Bases: icat.entity.Entity

A user of the facility.

BeanName = 'User'

Constraint = ('name',)

InstAttr = frozenset(['fullName', 'id', 'name'])

InstMRel = frozenset(['studies', 'instrumentScientists', 'userGroups', 'investigationUsers'])

class icat.entities.UserGroup(client, instance, **kwargs)

Bases: icat.entity.Entity

Many to many relationship between user and group.

BeanName = 'UserGroup'

Constraint = ('user', 'group')

InstRel = frozenset(['group', 'user'])

AttrAlias = {'grouping': 'group'}

class icat.entities.UserGroup43(client, instance, **kwargs)

Bases: icat.entities.UserGroup

Many to many relationship between user and group.

Constraint = ('user', 'grouping')

InstRel = frozenset(['user', 'grouping'])

AttrAlias = {'group': 'grouping'}