pybis.py

            'data'
        ]

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

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

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

    @property
    def physicalData(self):
        if 'physicalData' in self.data:
            return PhysicalData(self.data['physicalData'])
            #return self.data['physicalData']

    @property
    def status(self):
        ds = self.openbis.get_dataset(self.permId)
        self.data['physicalData'] = ds.data['physicalData']
        try:
            return self.data['physicalData']['status']
        except Exception:
            return None

    def archive(self, remove_from_data_store=True):
        fetchopts = { 
            "removeFromDataStore": remove_from_data_store,
            "@type": "as.dto.dataset.archive.DataSetArchiveOptions" 
        }
        self.archive_unarchive('archiveDataSets', fetchopts)
        print("DataSet {} archived".format(self.permId))


    def unarchive(self):
        fetchopts = { 
            "@type": "as.dto.dataset.unarchive.DataSetUnarchiveOptions" 
        }
        self.archive_unarchive('unarchiveDataSets', fetchopts)
        print("DataSet {} unarchived".format(self.permId))


    def archive_unarchive(self, method, fetchopts):
        dss = self.get_datastore
        payload = {}

        request = {
          "method": method,
          "params": [
            self.openbis.token,
            [{
                "permId": self.permId,
                "@type": "as.dto.dataset.id.DataSetPermId" 
            }],
            dict(fetchopts)
          ],
        }
        resp = self.openbis._post_request(self._openbis.as_v3, request)
        return


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

    def download(self, files=None, destination=None, wait_until_finished=True, workers=10):
        """ download the actual files and put them by default in the following folder:
        __current_dir__/destination/dataset_permId/
        If no files are specified, all files of a given dataset are downloaded.
        If no destination is specified, the hostname is chosen instead.
        Files are usually downloaded in parallel, using 10 workers by default. If you want to wait until
        all the files are downloaded, set the wait_until_finished option to True.
        """

        if files == None:
            files = self.file_list()
        elif isinstance(files, str):
            files = [files]

        if destination is None:
            destination = self.openbis.hostname

        base_url = self.data['dataStore']['downloadUrl'] + '/datastore_server/' + self.permId + '/'

        queue = DataSetDownloadQueue(workers=workers)

        # get file list and start download
        for filename in files:
            file_info = self.get_file_list(start_folder=filename)
            file_size = file_info[0]['fileSize']
            download_url = base_url + filename + '?sessionID=' + self.openbis.token 
            filename_dest = os.path.join(destination, self.permId, filename)
            queue.put([download_url, filename_dest, file_size, self.openbis.verify_certificates])

        # wait until all files have downloaded
        if wait_until_finished:
            queue.join()


        print("Files downloaded to: %s" % os.path.join(destination, self.permId))


    def get_parents(self):
        return self.openbis.get_datasets(withChildren=self.permId)

    def get_children(self):
        return self.openbis.get_datasets(withParents=self.permId)


    def file_list(self):
        """returns the list of files including their directories as an array of strings. Just folders are not
        listed.
        """
        files = []
        for file in self.get_file_list(recursive=True):
            if file['isDirectory']:
                pass
            else:
                files.append(file['pathInDataSet'])
        return files


    def get_files(self, start_folder='/'):
        """Returns a DataFrame of all files in this dataset
        """

        def createRelativePath(pathInDataSet):
            if self.shareId is None:
                return ''
            else:
                return os.path.join(self.shareId, self.location, pathInDataSet)

        def signed_to_unsigned(sig_int):
            """openBIS delivers crc32 checksums as signed integers.
            If the number is negative, we just have to add 2**32
            We display the hex number to match with the classic UI
            """
            if sig_int < 0:
                sig_int += 2**32
            return "%x"%(sig_int & 0xFFFFFFFF)
            
        files = self.get_file_list(start_folder=start_folder)
        df = DataFrame(files)
        df['relativePath'] = df['pathInDataSet'].map(createRelativePath)
        df['crc32Checksum'] = df['crc32Checksum'].fillna(0.0).astype(int).map(signed_to_unsigned)
        return df[['isDirectory', 'pathInDataSet', 'fileSize', 'crc32Checksum']]
        

    def get_file_list(self, recursive=True, start_folder="/"):
        """Lists all files of a given dataset. You can specifiy a start_folder other than "/".
        By default, all directories and their containing files are listed recursively. You can
        turn off this option by setting recursive=False.
        """
        request = {
            "method" : "listFilesForDataSet",
            "params" : [ 
                self.openbis.token,
                self.permId, 
                start_folder,
                recursive,
            ],
           "id":"1"
        }

        resp = requests.post(
            self.data["dataStore"]["downloadUrl"] + '/datastore_server/rmi-dss-api-v1.json',
            json.dumps(request), 
            verify=self.openbis.verify_certificates
        )

        if resp.ok:
            data = resp.json()
            if 'error' in data:
                raise ValueError('Error from openBIS: ' + data['error'] )
            elif 'result' in data:
                return data['result']
            else:
                raise ValueError('request to openBIS did not return either result nor error')
        else:
            raise ValueError('internal error while performing post request')


    def save(self):
        if self.is_new:
            raise ValueError('not implemented yet.')
        else:
            request = self._up_attrs()
            props = self.p._all_props()
            request["params"][1][0]["properties"] = props
            request["params"][1][0].pop('parentIds')
            request["params"][1][0].pop('childIds')

            self.openbis._post_request(self.openbis.as_v3, request)
            print("DataSet successfully updated.")


class AttrHolder():
    """ General class for both samples and experiments that hold all common attributes, such as:
    - space
    - project
    - experiment (sample)
    - samples (experiment)
    - dataset
    - parents (sample, dataset)
    - children (sample, dataset)
    - tags
    """

    def __init__(self, openbis_obj, entity, type=None):
        self.__dict__['_openbis'] = openbis_obj
        self.__dict__['_entity'] = entity

        if type is not None:
            self.__dict__['_type'] = type.data

        self.__dict__['_allowed_attrs'] = _definitions(entity)['attrs']
        self.__dict__['_identifier'] = None
        self.__dict__['_is_new'] = True
        self.__dict__['_tags'] = []


    def __call__(self, data):
        self.__dict__['_is_new'] = False
        for attr in self._allowed_attrs:
            if attr in ["code","permId","identifier",
                    "type", "container","components"]:
                self.__dict__['_'+attr] = data.get(attr, None)

            elif attr in ["space"]:
                d =  data.get(attr, None)
                if d is not None:
                    d = d['permId']
                self.__dict__['_'+attr] = d

            elif attr in ["sample", "experiment", "project"]:
                d =  data.get(attr, None)
                if d is not None:
                    d = d['identifier']
                self.__dict__['_'+attr] = d

            elif attr in ["parents","children","samples"]:
                self.__dict__['_'+attr] = []
                for item in data[attr]:
                    if 'identifier' in item:
                        self.__dict__['_'+attr].append(item['identifier'])
                    elif 'permId' in item:
                        self.__dict__['_'+attr].append(item['permId'])

            elif attr in ["tags"]:
                tags = []
                for item in data[attr]:
                    tags.append({
                        "code": item['code'],
                        "@type": "as.dto.tag.id.TagCode"
                    })
                self.__dict__['_tags'] = tags
                import copy
                self.__dict__['_prev_tags'] = copy.deepcopy(tags)
            else:
                self.__dict__['_'+attr] = data.get(attr, None)


    def _new_attrs(self):
        defs = _definitions(self.entity)
        attr2ids = _definitions('attr2ids')

        new_obj = {
           "@type" : "as.dto.{}.create.{}Creation".format(self.entity.lower(), self.entity)
        } 

        for attr in defs['attrs_new']:
            items = None

            if attr == 'type':
                new_obj['typeId'] = self._type['permId']
                continue

            elif attr == 'attachments':
                attachments = getattr(self,'_new_attachments')
                if attachments is None:
                    continue
                atts_data = [ attachment.get_data() for attachment in attachments ]
                items = atts_data

            elif attr in defs['multi']:
                items = getattr(self, '_'+attr)
                if items is None:
                    items = []
            else:
                items = getattr(self, '_'+attr)

            key = None
            if attr in attr2ids:
                key = attr2ids[attr]
            else:
                key = attr
            
            new_obj[key] = items


        # create a new entity
        request = { 
            "method": "create{}s".format(self.entity),
            "params": [
                self.openbis.token,
                [ new_obj ]
            ]
        }
        return request


    def _up_attrs(self):
        defs = _definitions(self._entity)
        attr2ids = _definitions('attr2ids')

        up_obj = {
           "@type" : "as.dto.{}.update.{}Update".format(self.entity.lower(), self.entity),
           defs["identifier"]: self._permId
        } 

        # look at all attributes available for that entity
        # that can be updated
        for attr in defs['attrs_up']:
            items = None

            if attr == 'attachments':
                # v3 API currently only supports adding attachments
                attachments = self.__dict__.get('_new_attachments', None)
                if attachments is None:
                    continue
                atts_data = [ attachment.get_data() for attachment in attachments ]

                if self._is_new:
                    up_obj['attachments'] = atts_data
                else:
                    up_obj['attachments'] = {
                        "actions": [ {
                            "items": atts_data,
                            "@type": "as.dto.common.update.ListUpdateActionAdd"
                  } ],
                        "@type": "as.dto.attachment.update.AttachmentListUpdateValue"
                    } 

            elif attr == 'tags':
                # look which tags have been added or removed and update them
                if getattr(self,'_prev_tags') is None:
                    self.__dict__['_prev_tags'] = []
                actions = []
                for tagId in self._prev_tags:
                    if tagId not in self._tags:
                        actions.append({
                            "items": [ tagId ],
                            "@type": "as.dto.common.update.ListUpdateActionRemove"
                        })

                for tagId in self._tags:
                    if tagId not in self._prev_tags:
                        actions.append({
                            "items": [ tagId ],
                            "@type": "as.dto.common.update.ListUpdateActionAdd"
                        })
                    
                up_obj['tagIds'] = {
                    "@type": "as.dto.common.update.IdListUpdateValue",
                    "actions": actions
                }

            elif '_'+attr in self.__dict__:
                # handle multivalue attributes (parents, children, tags etc.)
                # we only cover the Set mechanism, which means we always update 
                # all items in a list
                if attr in defs['multi']:
                    items = self.__dict__.get('_'+attr, [])
                    if items == None:
                        items = []
                    up_obj[attr2ids[attr]] = {
                        "actions": [
                            {
                                "items": items,
                                "@type": "as.dto.common.update.ListUpdateActionSet",
                            }
                        ],
                        "@type": "as.dto.common.update.IdListUpdateValue"
                    }
                else:
                    # handle single attributes (space, experiment, project, container, etc.)
                    value =  self.__dict__.get('_'+attr, {})
                    if value is None:
                        pass
                    else:
                        isModified=False
                        if 'isModified' in value:
                            isModified=True
                            del value['isModified']
                        
                        up_obj[attr2ids[attr]] = {
                           "@type": "as.dto.common.update.FieldUpdateValue",
                           "isModified": isModified,
                           "value": value,
                        }

        # update a new entity
        request = { 
            "method": "update{}s".format(self.entity),
            "params": [
                self.openbis.token,
                [ up_obj ]
            ]
        }
        return request


    def __getattr__(self, name):
        """ handles all attribute requests dynamically. Values are returned in a sensible way,
            for example the identifiers of parents, children and components are returned
            as an array of values.
        """
                
        int_name = '_'+name
        if int_name in self.__dict__: 
            if int_name in ['_attachments']:
                return [
                    { 
                        "fileName": x['fileName'],
                        "title": x['title'],
                        "description": x['description']
                    } for x in self._attachments 
                ]
            if int_name in ['_registrator','_modifier', '_dataProducer']:
                return self.__dict__[int_name].get('userId', None)
            elif int_name in ['_registrationDate', '_modificationDate', '_accessDate', '_dataProductionDate']:
                return format_timestamp(self.__dict__[int_name])
            # if the attribute contains a list, 
            # return a list of either identifiers, codes or
            # permIds (whatever is available first)
            elif isinstance(self.__dict__[int_name], list):
                values = []
                for item in self.__dict__[int_name]:
                    if "identifier" in item:
                        values.append(item['identifier'])
                    elif "code" in item:
                        values.append(item['code'])
                    elif "permId" in item:
                        values.append(item['permId'])
                    else:
                        pass
                return values
            # attribute contains a dictionary: same procedure as above.
            elif isinstance(self.__dict__[int_name], dict):
                if "identifier" in self.__dict__[int_name]:
                    return self.__dict__[int_name]['identifier']
                elif "code" in self.__dict__[int_name]:
                    return self.__dict__[int_name]['code']
                elif "permId" in self.__dict__[int_name]:
                    return self.__dict__[int_name]['permId']
            else:
                return self.__dict__[int_name]
        else:
            return None


    def __setattr__(self, name, value):
        if name in ["parents", "children", "components"]:
            if not isinstance(value, list):
                value = [value]
            objs = []
            for val in value:
                # fetch objects in openBIS, make sure they actually exists
                obj = getattr(self._openbis, 'get_'+self._entity.lower())(val)
                objs.append(obj)
            self.__dict__['_'+name] = {
                "@type": "as.dto.common.update.IdListUpdateValue",
                "actions": [{
                    "@type": "as.dto.common.update.ListUpdateActionSet",
                    "items": [item._permId for item in objs]
                }]
            }
        elif name in ["tags"]:
            self.set_tags(value)
        
        elif name in ["attachments"]:
            if isinstance(value, list):
                for item in value:
                    if isinstance(item, dict):
                        self.add_attachment(**item)
                    else:
                        self.add_attachment(item)

            else:
                self.add_attachment(value)

        elif name in ["sample", "experiment", "space", "project"]:
            obj = None
            if isinstance(value, str):
                # fetch object in openBIS, make sure it actually exists
                obj = getattr(self._openbis, "get_"+name)(value)
            else:
                obj = value

            self.__dict__['_'+name] = obj.data['permId']

            # mark attribute as modified, if it's an existing entity
            if self.is_new:
                pass
            else:
                self.__dict__['_'+name]['isModified'] = True

        elif name in ["identifier"]:
            raise KeyError("you can not modify the {}".format(name))
        elif name == "code":
            try:
                if self._type.data['autoGeneratedCode']:
                    raise KeyError("for this {}Type you can not set a code".format(self.entity))
            except AttributeError:
                pass
                
            self.__dict__['_code'] = value

        elif name == "description":
            self.__dict__['_description'] = value
        else:
            raise KeyError("no such attribute: {}".format(name))

    def get_type(self):
        return self._type

    def get_parents(self):
        # e.g. self._openbis.get_samples(withChildren=self.identifier)
        return getattr(self._openbis, 'get_'+self._entity.lower()+'s')(withChildren=self.identifier)

    def get_children(self):
        # e.g. self._openbis.get_samples(withParents=self.identifier)
        return getattr(self._openbis, 'get_'+self._entity.lower()+'s')(withParents=self.identifier)

    @property
    def tags(self):
        if getattr(self, '_tags') is not None:
            return [ x['code'] for x in self._tags ]

    def set_tags(self, tags):
        if getattr(self, '_tags') is None:
            self.__dict__['_tags'] = []

        tagIds = _create_tagIds(tags)

        # remove tags that are not in the new tags list
        for tagId in self.__dict__['_tags']:
            if tagId not in tagIds:
                self.__dict__['_tags'].remove(tagId)

        # add all new tags that are not in the list yet
        for tagId in tagIds:
            if tagId not in self.__dict__['_tags']:
                self.__dict__['_tags'].append(tagId)        

    def add_tags(self, tags):
        if getattr(self, '_tags') is None:
            self.__dict__['_tags'] = []

        # add the new tags to the _tags and _new_tags list,
        # if not listed yet
        tagIds = _create_tagIds(tags)
        for tagId in tagIds:
            if not tagId in self.__dict__['_tags']:
                self.__dict__['_tags'].append(tagId)        

    def del_tags(self, tags):
        if getattr(self, '_tags') is None:
            self.__dict__['_tags'] = []

        # remove the tags from the _tags and _del_tags list,
        # if listed there
        tagIds = _create_tagIds(tags)
        for tagId in tagIds:
            if tagId in self.__dict__['_tags']:
                self.__dict__['_tags'].remove(tagId)        

    def get_attachments(self):
        if getattr(self, '_attachments') is None:
            return None
        else:
            return DataFrame(self._attachments)[['fileName','title','description','version']]

    def add_attachment(self, fileName, title=None, description=None):
        att = Attachment(filename=fileName, title=title, description=description)
        if getattr(self, '_attachments') is None:
            self.__dict__['_attachments'] = []
        self._attachments.append(att.get_data_short())

        if getattr(self, '_new_attachments') is None:
            self.__dict__['_new_attachments'] = []
        self._new_attachments.append(att)

    def download_attachments(self):
        method = 'get'+self.entity+'s'
        entity = self.entity.lower()
        request = {
            "method": method,
            "params": [ self._openbis.token,
                [ self._permId ],
                dict( 
                    attachments= fetch_option['attachmentsWithContent'],
                    **fetch_option[entity]
                )
            ]
        }
        resp = self._openbis._post_request(self._openbis.as_v3, request)
        attachments = resp[self.permId]['attachments']
        file_list = []
        for attachment in attachments:
            filename = os.path.join(
                self._openbis.hostname, 
                self.permId,
                attachment['fileName']
            )
            os.makedirs(os.path.dirname(filename), exist_ok=True)
            with open(filename, 'wb') as att:
                content = base64.b64decode(attachment['content'])
                att.write(content)    
            file_list.append(filename)
        return file_list


    def _repr_html_(self):
        def nvl(val, string=''):
            if val is None:
                return string
            return val

        html = """
            <table border="1" class="dataframe">
            <thead>
                <tr style="text-align: right;">
                <th>attribute</th>
                <th>value</th>
                </tr>
            </thead>
            <tbody>
        """
            
        for attr in self._allowed_attrs:
            if attr == 'attachments':
                continue
            html += "<tr> <td>{}</td> <td>{}</td> </tr>".format(
                attr, nvl(getattr(self, attr, ''),'') 
            )
        if getattr(self, '_attachments') is not None:
            html += "<tr><td>attachments</td><td>"
            html += "<br/>".join(att['fileName'] for att in self._attachments)
            html += "</td></tr>"

        html += """
            </tbody>
            </table>
        """
        return html
        

    def __repr__(self):

        headers = ['property', 'value']
        lines = []
        for attr in self._allowed_attrs:
            if attr == 'attachments':
                continue
            lines.append([
                attr,
                nvl(getattr(self, attr, ''))
            ])
        return tabulate(lines, headers=headers)


class Sample():
    """ A Sample is one of the most commonly used objects in openBIS.
    """

    def __init__(self, openbis_obj, type, data=None, **kwargs):
        self.__dict__['openbis'] = openbis_obj
        self.__dict__['type'] = type
        self.__dict__['p'] = PropertyHolder(openbis_obj, type)
        self.__dict__['a'] = AttrHolder(openbis_obj, 'Sample', type)

        if data is not None:
            self._set_data(data)

        if kwargs is not None:
            for key in kwargs:
                setattr(self, key, kwargs[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 __dir__(self):
        return [
            'props', 'get_parents()', 'get_children()',
            'get_datasets()', 'get_experiment()',
            'space', 'project', 'experiment', 'project', 'tags', 
            'set_tags()', 'add_tags()', 'del_tags()',
            'add_attachment()', 'get_attachments()', 'download_attachments()'
        ]

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

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

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

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

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

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

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

    def __repr__(self):
        return self.a.__repr__()

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

    def save(self):
        props = self.p._all_props()
        attrs = self.a._up_attrs()
        attrs["properties"] = props

        if self.identifier is None:
            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("Sample successfully created.")
            new_sample_data = self.openbis.get_sample(resp[0]['permId'], only_data=True)
            self._set_data(new_sample_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("Sample successfully updated.")


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

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

    def get_projects(self):
        return self.openbis.get_project(withSamples=[self.permId])

    def get_experiment(self):
        try: 
            return self.openbis.get_experiment(self._experiment['identifier'])
        except Exception:
            pass

    @property
    def experiment(self):
        try: 
            return self.openbis.get_experiment(self._experiment['identifier'])
        except Exception:
            pass
        

class Space(OpenBisObject):
    """ managing openBIS spaces
    """

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

        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 __dir__(self):
        """all the available methods and attributes that should be displayed
        when using the autocompletion feature (TAB) in Jupyter
        """
        return['code','permId', 'description', 'registrator', 'registrationDate',
        'modificationDate', 'get_projects()', 'new_project()', 'get_samples()', 'delete()']

    def __str__(self):
        return self.data.get('code', None)

    def get_samples(self):
        return self.openbis.get_samples(space=self.code)

    def get_projects(self):
        return self.openbis.get_projects(space=self.code)

    def new_project(self, code, description=None, **kwargs):
        return self.openbis.new_project(self.code, code, description, **kwargs)

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


class Things():
    """An object that contains a DataFrame object about an entity  available in openBIS.
       
    """

    def __init__(self, openbis_obj, entity, df, identifier_name='code'):
        self.openbis = openbis_obj
        self.entity = entity
        self.df = df
        self.identifier_name = identifier_name

    def __repr__(self):
        return tabulate(self.df, headers=list(self.df))

    def _repr_html_(self):
        return self.df._repr_html_()

    def __getitem__(self, key):
        if self.df is not None and len(self.df) > 0:
            row = None
            if isinstance(key, int):
                # get thing by rowid
                row = self.df.loc[[key]]
            elif isinstance(key, list):
                # treat it as a normal dataframe
                return self.df[key]
            else:
                # get thing by code
                row = self.df[self.df[self.identifier_name]==key.upper()]

            if row is not None:
                # invoke the openbis.get_entity() method
                return getattr(self.openbis, 'get_'+self.entity)(row[self.identifier_name].values[0])

    def __iter__(self):
        for item in self.df[[self.identifier_name]][self.identifier_name].iteritems():
            yield getattr(self.openbis, 'get_'+self.entity)(item[1]) 

        #return self.df[[self.identifier_name]].to_dict()[self.identifier_name]


class Experiment(OpenBisObject):
    """ 
    """

    def __init__(self, openbis_obj, type, data=None, **kwargs):
        self.__dict__['openbis'] = openbis_obj
        self.__dict__['type'] = type
        self.__dict__['p'] = PropertyHolder(openbis_obj, type)
        self.__dict__['a'] = AttrHolder(openbis_obj, 'Experiment', type)

        if data is not None:
            self._set_data(data)

        if kwargs is not None:
            for key in kwargs:
                setattr(self, key, kwargs[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 [
            'props', 'space', 'project', 
            'project','tags', 'attachments', 'data',
            'get_datasets()', 'get_samples()', 
            'set_tags()', 'add_tags()', 'del_tags()',
            'add_attachment()', 'get_attachments()', 'download_attachments()'
        ]

    @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
            self.openbis._post_request(self.openbis.as_v3, request)
            self.a.__dict__['_is_new'] = False
            print("Experiment successfully created.")
        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.")

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

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

    def get_projects(self):
        return self.openbis.get_project(experiment=self.permId)

    def get_samples(self):
        return self.openbis.get_samples(experiment=self.permId)


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",
        }