pybis.py

        if project is not None:
            setattr(self, 'project', project)

        if props is not None:
            for key in props:
                setattr(self.p, key, props[key])

        if code is not None:
            self.code = code

        if kwargs is not None:
            defs = _definitions('Experiment')
            for key in kwargs:
                if key in defs['attrs']:
                    setattr(self, key, kwargs[key])
                else:
                    raise ValueError("{attr} is not a known attribute for an Experiment".format(attr=key))


    def _set_data(self, data):
        # assign the attribute data to self.a by calling it
        # (invoking the AttrHolder.__call__ function)
        self.a(data)
        self.__dict__['data'] = data

        # put the properties in the self.p namespace (without checking them)
        for key, value in data['properties'].items():
            self.p.__dict__[key.lower()] = value

    def __str__(self):
        return self.data['code']

    def __dir__(self):
        # the list of possible methods/attributes displayed
        # when invoking TAB-completition
        return [
            'code', 'permId', 'identifier',
            'type', 'project',
            'props.', 
            'project', 'tags', 'attachments', 'data',
            'get_datasets()', 'get_samples()',
            'set_tags()', 'add_tags()', 'del_tags()',
            'add_attachment()', 'get_attachments()', 'download_attachments()',
            'save()'
        ]

    @property
    def props(self):
        return self.__dict__['p']

    @property
    def type(self):
        return self.__dict__['type']

    @type.setter
    def type(self, type_name):
        experiment_type = self.openbis.get_experiment_type(type_name)
        self.p.__dict__['_type'] = experiment_type
        self.a.__dict__['_type'] = experiment_type

    def __getattr__(self, name):
        return getattr(self.__dict__['a'], name)

    def __setattr__(self, name, value):
        if name in ['set_properties', 'add_tags()', 'del_tags()', 'set_tags()']:
            raise ValueError("These are methods which should not be overwritten")

        setattr(self.__dict__['a'], name, value)

    def _repr_html_(self):
        html = self.a._repr_html_()
        return html

    def set_properties(self, properties):
        self.openbis.update_experiment(self.permId, properties=properties)

    def save(self):
        if self.is_new:
            request = self._new_attrs()
            props = self.p._all_props()
            request["params"][1][0]["properties"] = props
            resp = self.openbis._post_request(self.openbis.as_v3, request)

            print("Experiment successfully created.")
            new_exp_data = self.openbis.get_experiment(resp[0]['permId'], only_data=True)
            self._set_data(new_exp_data)
            return self
        else:
            request = self._up_attrs()
            props = self.p._all_props()
            request["params"][1][0]["properties"] = props
            self.openbis._post_request(self.openbis.as_v3, request)
            print("Experiment successfully updated.")
            new_exp_data = self.openbis.get_experiment(resp[0]['permId'], only_data=True)
            self._set_data(new_exp_data)

    def delete(self, reason):
        if self.permId is None:
            return None
        self.openbis.delete_entity('experiment', self.permId, reason)

    def get_datasets(self, **kwargs):
        if self.permId is None:
            return None
        return self.openbis.get_datasets(experiment=self.permId, **kwargs)

    def get_projects(self, **kwargs):
        if self.permId is None:
            return None
        return self.openbis.get_project(experiment=self.permId, **kwargs)

    def get_samples(self, **kwargs):
        if self.permId is None:
            return None
        return self.openbis.get_samples(experiment=self.permId, **kwargs)

    get_objects = get_samples # Alias

    def add_samples(self, *samples):

        for sample in samples:
            if isinstance(sample, str):
                obj = self.openbis.get_sample(sample)
            else:
                # we assume we got a sample object
                obj = sample

            # a sample can only belong to exactly one experiment
            if obj.experiment is not None:
                raise ValueError(
                    "sample {} already belongs to experiment {}".format(
                        obj.code, obj.experiment
                    )
                )
            else:
                if self.is_new:
                    raise ValueError("You need to save this experiment first before you can assign any samples to it")
                else:
                    # update the sample directly
                    obj.experiment = self.identifier
                    obj.save()
                    self.a.__dict__['_samples'].append(obj._identifier)

    add_objects = add_samples # Alias

    def del_samples(self, samples):
        if not isinstance(samples, list):
            samples = [samples]

        
        for sample in samples:
            if isinstance(sample, str):
                obj = self.openbis.get_sample(sample)
                objects.append(obj)
            else:
                # we assume we got an object
                objects.append(obj)
        
        self.samples = objects

    del_objects = del_samples # Alias

class Attachment():
    def __init__(self, filename, title=None, description=None):
        if not os.path.exists(filename):
            raise ValueError("File not found: {}".format(filename))
        self.fileName = filename
        self.title = title
        self.description = description

    def get_data_short(self):
        return {
            "fileName": self.fileName,
            "title": self.title,
            "description": self.description,
        }

    def get_data(self):
        with open(self.fileName, 'rb') as att:
            content = att.read()
            contentb64 = base64.b64encode(content).decode()
        return {
            "fileName": self.fileName,
            "title": self.title,
            "description": self.description,
            "content": contentb64,
            "@type": "as.dto.attachment.create.AttachmentCreation",
        }


class Project(OpenBisObject):
    def __init__(self, openbis_obj, data=None, **kwargs):
        self.__dict__['openbis'] = openbis_obj
        self.__dict__['a'] = AttrHolder(openbis_obj, 'Project')

        if data is not None:
            self.a(data)
            self.__dict__['data'] = data

        if kwargs is not None:
            for key in kwargs:
                setattr(self, key, kwargs[key])

    def _modifiable_attrs(self):
        return

    def __dir__(self):
        """all the available methods and attributes that should be displayed
        when using the autocompletion feature (TAB) in Jupyter
        """
        return ['code', 'permId', 'identifier', 'description', 'space', 'registrator',
                'registrationDate', 'modifier', 'modificationDate', 'add_attachment()',
                'get_attachments()', 'download_attachments()',
                'get_experiments()', 'get_samples()', 'get_datasets()',
                'save()', 'delete()'
                ]

    def get_samples(self, **kwargs):
        return self.openbis.get_samples(project=self.permId, **kwargs)

    def get_sample(self, sample_code):
        if is_identifier(sample_code) or is_permid(sample_code):
            return self.openbis.get_sample(sample_code)
        else:
            # we assume we just got the code
            return self.openbis.get_sample(project=self, code=sample_code)

    get_objects = get_samples # Alias

    def get_experiments(self):
        return self.openbis.get_experiments(project=self.permId)

    def get_datasets(self):
        return self.openbis.get_datasets(project=self.permId)

    def delete(self, reason):
        self.openbis.delete_entity('project', self.permId, reason)

    def save(self):
        if self.is_new:
            request = self._new_attrs()
            resp = self.openbis._post_request(self.openbis.as_v3, request)
            self.a.__dict__['_is_new'] = False
            print("Project successfully created.")
            new_project_data = self.openbis.get_project(resp[0]['permId'], only_data=True)
            self._set_data(new_project_data)
            return self
        else:
            request = self._up_attrs()
            self.openbis._post_request(self.openbis.as_v3, request)
            print("Project successfully updated.")


class SemanticAnnotation():
    def __init__(self, openbis_obj, isNew=True, **kwargs):
        self._openbis = openbis_obj
        self._isNew = isNew;
        
        self.permId = kwargs.get('permId')
        self.entityType = kwargs.get('entityType')
        self.propertyType = kwargs.get('propertyType')
        self.predicateOntologyId = kwargs.get('predicateOntologyId')
        self.predicateOntologyVersion = kwargs.get('predicateOntologyVersion')
        self.predicateAccessionId = kwargs.get('predicateAccessionId')
        self.descriptorOntologyId = kwargs.get('descriptorOntologyId')
        self.descriptorOntologyVersion = kwargs.get('descriptorOntologyVersion')
        self.descriptorAccessionId = kwargs.get('descriptorAccessionId')
        self.creationDate = kwargs.get('creationDate')

    def __dir__(self):
        return [
            'permId', 'entityType', 'propertyType', 
            'predicateOntologyId', 'predicateOntologyVersion', 
            'predicateAccessionId', 'descriptorOntologyId',
            'descriptorOntologyVersion', 'descriptorAccessionId', 
            'creationDate', 
            'save()', 'delete()' 
        ]

    def save(self):
        if self._isNew:
            self._create()
        else:
            self._update()
            
    def _create(self):
        
        creation = {
            "@type": "as.dto.semanticannotation.create.SemanticAnnotationCreation"
        }

        if self.entityType is not None and self.propertyType is not None:
            creation["propertyAssignmentId"] = {
                "@type": "as.dto.property.id.PropertyAssignmentPermId",
                "entityTypeId" : {
                    "@type": "as.dto.entitytype.id.EntityTypePermId",
                    "permId" : self.entityType,
                    "entityKind" : "SAMPLE"
                },
                "propertyTypeId" : {
                    "@type" : "as.dto.property.id.PropertyTypePermId",
                    "permId" : self.propertyType
                }
            }
        elif self.entityType is not None:
            creation["entityTypeId"] = {
                "@type": "as.dto.entitytype.id.EntityTypePermId",
                "permId" : self.entityType,
                "entityKind" : "SAMPLE"
            }
        elif self.propertyType is not None:
            creation["propertyTypeId"] = {
                "@type" : "as.dto.property.id.PropertyTypePermId",
                "permId" : self.propertyType
            }
            
        for attr in ['predicateOntologyId', 'predicateOntologyVersion', 'predicateAccessionId', 'descriptorOntologyId', 'descriptorOntologyVersion', 'descriptorAccessionId']:
            creation[attr] = getattr(self, attr)

        request = {
            "method": "createSemanticAnnotations",
            "params": [
                self._openbis.token,
                [creation]
            ]
        }
        
        self._openbis._post_request(self._openbis.as_v3, request)
        self._isNew = False
        
        print("Semantic annotation successfully created.")
    
    def _update(self):
        
        update = {
            "@type": "as.dto.semanticannotation.update.SemanticAnnotationUpdate",
            "semanticAnnotationId" : {
                "@type" : "as.dto.semanticannotation.id.SemanticAnnotationPermId",
                "permId" : self.permId
            }
        }
        
        for attr in ['predicateOntologyId', 'predicateOntologyVersion', 'predicateAccessionId', 'descriptorOntologyId', 'descriptorOntologyVersion', 'descriptorAccessionId']:
            update[attr] = {
                "@type" : "as.dto.common.update.FieldUpdateValue",
                "isModified" : True,
                "value" : getattr(self, attr)
            }
            
        request = {
            "method": "updateSemanticAnnotations",
            "params": [
                self._openbis.token,
                [update]
            ]
        }
        
        self._openbis._post_request(self._openbis.as_v3, request)
        print("Semantic annotation successfully updated.")
    
    def delete(self, reason):
        self._openbis.delete_entity('SemanticAnnotation', self.permId, reason, False)
        print("Semantic annotation successfully deleted.")