Skip to content

Column

Column

Bases: BaseClass

Attributes:

Name Type Description
id str

id of the column
name str

name of the column
type str

Type of the column. Either "Text" or "Numeric"
values List[Any]

"These represent the values held within the column. If the column type is 'Text', the values are characterized as strings. Conversely, for 'Numeric' type columns, the values are expressed as floating-point numbers."
_fetched bool

This is a Boolean attribute indicating whether all attributes have been retrieved from the server or only the name and ID are present.
Source code in furthrmind\collection\column.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
class Column(BaseClass):
    """
    Attributes
    ----------
    id : str
        id of the column
    name : str
        name of the column
    type : str
        Type of the column. Either "Text" or "Numeric"
    values : List[Any]
        "These represent the values held within the column. If the column type is 'Text',
        the values are characterized as strings. Conversely, for 'Numeric' type columns,
        the values are expressed as floating-point numbers."
    _fetched : bool
        This is a Boolean attribute indicating whether all attributes have been retrieved from the server or only
        the name and ID are present.
    """

    id: str = ""
    name: str = ""
    type: str = ""
    unit: "Unit" = None
    values: List[Any] = []

    _attr_definition = {"unit": {"class": "Unit"}}

    def __init__(self, id=None, data=None):
        super().__init__(id, data)

    def _update_attributes(self, data):
        super()._update_attributes(data)

        def convert_date(value):
            if not value:
                return value
            if isinstance(value, (int, float)):
                value = datetime.datetime.fromtimestamp(value)
            if isinstance(value, str):
                value = datetime.datetime.fromisoformat(value)
            return value

        if self.type == "Date":
            if self.values:
                self.values = list(map(convert_date, self.values))

    @classmethod
    def get(cls, id: str = "", project_id: str = "") -> Self:

        """
        Method to get one column by its id
        If called on an instance of the class, the id of the instance is used

        Parameters
        ----------
        id : str
            id of requested column
        project_id : str, optional
            Optionally to get a column from another project as the furthrmind sdk was initiated with, defaults to ""

        Returns
        -------
        Self
            Instance of column class

        Raises
        ------
        AssertionError
            If used as a class method and id is not specified.
        """

        if isclass(cls):
            assert id, "id must be specified"

        return cls._get(id, project_id=project_id)

    # noinspection PyMethodOverriding
    @classmethod
    def get_many(cls, ids: List[str] = (), project_id: str = "") -> List[Self]:
        """
        Method to get many columns belonging to one project

        Parameters
        ----------
        ids : List[str]
            List with ids.

        project_id : str
            Optionally, the id of the project from which to get the experiments. Defaults to an empty string.

        Returns
        -------
        List[Self]
            List with instances of the experiment class.

        Raises
        ------
        AssertionError
            If `ids` is not specified.
        """

        assert ids, "ids must be specified"
        return cls._get_many(ids, project_id=project_id)

    @classmethod
    def _get_all(cls, project_id=None) -> List[Self]:
        raise ValueError("Not implemented for columns")

    def _get_url_instance(self, project_id=None):
        project_url = Column.fm.get_project_url(project_id)
        url = f"{project_url}/column/{self.id}"
        return url

    @classmethod
    def _get_url_class(cls, id, project_id=None):
        project_url = cls.fm.get_project_url(project_id)
        url = f"{project_url}/column/{id}"
        return url

    @classmethod
    def _post_url(cls, project_id=None):
        project_url = cls.fm.get_project_url(project_id)
        url = f"{project_url}/column"
        return url

    @classmethod
    def _get_all_url(cls, project_id=None):
        project_url = cls.fm.get_project_url(project_id)
        url = f"{project_url}/column"
        return url

    @classmethod
    def _type_check(cls, column_type, data):
        column_type = column_type.capitalize()
        if not column_type in ["Text", "Numeric", "Date", "Bool"]:
            raise ValueError("Column type must be Text/Numeric/Date/Bool.")
        if isinstance(data, pandas.Series):
            data = data.tolist()

        data = list(map(Column._convert_nan, data))

        if column_type == "Text":
            if iteration_utilities.all_isinstance(data, (str, type(None))):
                return data
            return [str(d) for d in data]

        elif column_type == "Numeric":
            if iteration_utilities.all_isinstance(data, (int, float, type(None))):
                return data
            data = list(map(Column._convert_float, data))
            return data

        elif column_type == "Date":
            if iteration_utilities.all_isinstance(data, (int, float, type(None))):
                return data
            data = list(map(Column._convert_date, data))
            return data

    @staticmethod
    def _convert_nan(value):
        if value is None:
            return None
        try:
            if math.isnan(value):
                return None
            else:
                return value
        except:
            return value

    @staticmethod
    def _convert_float(value):
        if value is None:
            return value
        try:
            value = float(value)
            return value
        except:
            raise ValueError(
                "All column values must be a float, int or a string that can be converted to a float")

    @staticmethod
    def _convert_date(value):
        if value is None:
            return value
        if isinstance(value, datetime.datetime):
            if isinstance(value, pandas.Timestamp):
                value = value.to_pydatetime()
            if value.tzinfo is None:
                return value.isoformat()
            return int(value.timestamp())
        elif isinstance(value, datetime.date):
            value = datetime.datetime.combine(value, datetime.datetime.min.time())
            if value.tzinfo is None:
                return value.isoformat()
            return int(value.timestamp())
        elif isinstance(value, str):
            try:
                datetime.datetime.fromisoformat(value)
                return value
            except ValueError:
                raise TypeError("No iso time format")
        elif isinstance(value, (int, float)):
            return value
        raise ValueError("All column values must be a date, datetime, string, or int")

    @classmethod
    @BaseClass._create_instances_decorator(_fetched=False)
    def create(cls, name: str, type: str, data: list, unit=None, project_id=None) -> Self:
        """
        Method to create a new column

        Parameters
        ----------
        name : str
            Name of the column
        type : str
            The column type is categorized as either "Text" or "Numeric". For the "Text" type, all data
            will be transformed into strings. Conversely, for the "Numeric" type, data will be converted
            into floats, provided such a conversion is feasible. Please ensure that your data corresponds
            to the assigned column type.
        data : Union[list, pandas.Series]
            This should be either a list or a pandas series. Its values need to comply with the specified column type
            and will undergo conversion based on the rules described above.
        unit : Optional[Union[str, Dict]]
            Dict with id or name, or name as string, or id as string
        project_id : Optional[str]
            Optionally to create an item in another project as the furthrmind sdk was initiated with

        Returns
        -------
        Self
            Instance of column class

        """
        type = type.capitalize()
        data = cls._type_check(type, data)
        unit = FieldData._check_unit(unit)
        data_dict = {"name": name, "type": type, "values": data, "unit": unit}
        id = cls._post(data_dict, project_id)
        data_dict["id"] = id
        return data_dict

    @classmethod
    @BaseClass._create_instances_decorator(_fetched=False)
    def create_many(cls, data_list: List[Dict], project_id: str = "") -> List[Self]:
        """
        Method to create many new columns

        Parameters
        ----------
        data_list : List[Dict]
            A list of dictionaries containing information about the data columns to be created. Each dictionary should
             have the following keys:

                - name: Name of the column
                - type: Type of the column. Allowed values are "Text" or "Numeric".
                - data: List of column values. The values must match the column type. Can also be a pandas data series.
                - unit: Optional. Dictionary with id or name, or name as a string, or id as a string.

        project_id : str, optional
            Optionally to create columns in another project as the furthrmind sdk was initiated with

        Returns
        -------
        List[Self]
            A list of instances of the column class.

        """

        new_data_list = []
        for item in data_list:
            type:str = item.get("type", "")
            type = type.capitalize()
            unit = item.get("unit")
            name = item.get("name")
            data = item.get("value")
            if data is None:
                data = item.get("data")
            data = cls._type_check(type, data)
            unit = FieldData._check_unit(unit)
            data_dict = {"name": name, "type": type, "values": data, "unit": unit}
            new_data_list.append(data_dict)

        id_list = cls._post(new_data_list, project_id, force_list=True)
        for item, id in zip(new_data_list, id_list):
            item["id"] = id

        return new_data_list

create(name, type, data, unit=None, project_id=None) classmethod

Method to create a new column

Parameters:

Name Type Description Default
name str

Name of the column

 required
type str

The column type is categorized as either "Text" or "Numeric". For the "Text" type, all data will be transformed into strings. Conversely, for the "Numeric" type, data will be converted into floats, provided such a conversion is feasible. Please ensure that your data corresponds to the assigned column type.

 required
data Union[list, Series]

This should be either a list or a pandas series. Its values need to comply with the specified column type and will undergo conversion based on the rules described above.

 required
unit Optional[Union[str, Dict]]

Dict with id or name, or name as string, or id as string

 None
project_id Optional[str]

Optionally to create an item in another project as the furthrmind sdk was initiated with

 None

Returns:

Type Description
Self

Instance of column class
Source code in furthrmind\collection\column.py 
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
@classmethod
@BaseClass._create_instances_decorator(_fetched=False)
def create(cls, name: str, type: str, data: list, unit=None, project_id=None) -> Self:
    """
    Method to create a new column

    Parameters
    ----------
    name : str
        Name of the column
    type : str
        The column type is categorized as either "Text" or "Numeric". For the "Text" type, all data
        will be transformed into strings. Conversely, for the "Numeric" type, data will be converted
        into floats, provided such a conversion is feasible. Please ensure that your data corresponds
        to the assigned column type.
    data : Union[list, pandas.Series]
        This should be either a list or a pandas series. Its values need to comply with the specified column type
        and will undergo conversion based on the rules described above.
    unit : Optional[Union[str, Dict]]
        Dict with id or name, or name as string, or id as string
    project_id : Optional[str]
        Optionally to create an item in another project as the furthrmind sdk was initiated with

    Returns
    -------
    Self
        Instance of column class

    """
    type = type.capitalize()
    data = cls._type_check(type, data)
    unit = FieldData._check_unit(unit)
    data_dict = {"name": name, "type": type, "values": data, "unit": unit}
    id = cls._post(data_dict, project_id)
    data_dict["id"] = id
    return data_dict

create_many(data_list, project_id='') classmethod

Method to create many new columns

Parameters:

Name Type Description Default
data_list List[Dict]

A list of dictionaries containing information about the data columns to be created. Each dictionary should have the following keys:

- name: Name of the column
- type: Type of the column. Allowed values are "Text" or "Numeric".
- data: List of column values. The values must match the column type. Can also be a pandas data series.
- unit: Optional. Dictionary with id or name, or name as a string, or id as a string.
required
project_id str

Optionally to create columns in another project as the furthrmind sdk was initiated with

 ''

Returns:

Type Description
List[Self]

A list of instances of the column class.
Source code in furthrmind\collection\column.py 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
@classmethod
@BaseClass._create_instances_decorator(_fetched=False)
def create_many(cls, data_list: List[Dict], project_id: str = "") -> List[Self]:
    """
    Method to create many new columns

    Parameters
    ----------
    data_list : List[Dict]
        A list of dictionaries containing information about the data columns to be created. Each dictionary should
         have the following keys:

            - name: Name of the column
            - type: Type of the column. Allowed values are "Text" or "Numeric".
            - data: List of column values. The values must match the column type. Can also be a pandas data series.
            - unit: Optional. Dictionary with id or name, or name as a string, or id as a string.

    project_id : str, optional
        Optionally to create columns in another project as the furthrmind sdk was initiated with

    Returns
    -------
    List[Self]
        A list of instances of the column class.

    """

    new_data_list = []
    for item in data_list:
        type:str = item.get("type", "")
        type = type.capitalize()
        unit = item.get("unit")
        name = item.get("name")
        data = item.get("value")
        if data is None:
            data = item.get("data")
        data = cls._type_check(type, data)
        unit = FieldData._check_unit(unit)
        data_dict = {"name": name, "type": type, "values": data, "unit": unit}
        new_data_list.append(data_dict)

    id_list = cls._post(new_data_list, project_id, force_list=True)
    for item, id in zip(new_data_list, id_list):
        item["id"] = id

    return new_data_list

delete(id='', project_id='') classmethod

Method to delete an item. Can be called as a classmethod with providing the id to be deleted or on the instance of a class

Parameters:

Name Type Description Default
id str

The id of the resource to delete

 ''
project_id str

Optionally to delete an item in another project as the furthrmind sdk was initiated with

 ''

Returns:

Type Description
str

The id of the item
Source code in furthrmind\collection\baseclass.py 
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
@classmethod
def delete(cls, id: str = "", project_id: str = "") -> str:
    """
    Method to delete an item. Can be called as a classmethod with providing the id to be deleted or on the instance
    of a class

    Parameters
    ----------
    id : str
        The id of the resource to delete
    project_id : str, optional
        Optionally to delete an item in another project as the furthrmind sdk was initiated with

    Returns
    -------
    str
        The id of the item
    """

    if isclass(cls):
        return cls._delete_class_method(id, project_id)
    else:
        self = cls
        return self._delete_instance_method(project_id)

get(id='', project_id='') classmethod

Method to get one column by its id If called on an instance of the class, the id of the instance is used

Parameters:

Name Type Description Default
id str

id of requested column

 ''
project_id str

Optionally to get a column from another project as the furthrmind sdk was initiated with, defaults to ""

 ''

Returns:

Type Description
Self

Instance of column class

Raises:

Type Description
AssertionError

If used as a class method and id is not specified.
Source code in furthrmind\collection\column.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@classmethod
def get(cls, id: str = "", project_id: str = "") -> Self:

    """
    Method to get one column by its id
    If called on an instance of the class, the id of the instance is used

    Parameters
    ----------
    id : str
        id of requested column
    project_id : str, optional
        Optionally to get a column from another project as the furthrmind sdk was initiated with, defaults to ""

    Returns
    -------
    Self
        Instance of column class

    Raises
    ------
    AssertionError
        If used as a class method and id is not specified.
    """

    if isclass(cls):
        assert id, "id must be specified"

    return cls._get(id, project_id=project_id)

get_many(ids=(), project_id='') classmethod

Method to get many columns belonging to one project

Parameters:

Name Type Description Default
ids List[str]

List with ids.

 ()
project_id str

Optionally, the id of the project from which to get the experiments. Defaults to an empty string.

 ''

Returns:

Type Description
List[Self]

List with instances of the experiment class.

Raises:

Type Description
AssertionError

If ids is not specified.
Source code in furthrmind\collection\column.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
@classmethod
def get_many(cls, ids: List[str] = (), project_id: str = "") -> List[Self]:
    """
    Method to get many columns belonging to one project

    Parameters
    ----------
    ids : List[str]
        List with ids.

    project_id : str
        Optionally, the id of the project from which to get the experiments. Defaults to an empty string.

    Returns
    -------
    List[Self]
        List with instances of the experiment class.

    Raises
    ------
    AssertionError
        If `ids` is not specified.
    """

    assert ids, "ids must be specified"
    return cls._get_many(ids, project_id=project_id)

to_dict()

Converts the object's attributes to a dictionary representation.

Returns:

Type Description
dict

Dictionary containing the object's attributes (excluding private attributes, callable attributes, and attributes of type Furthrmind).
Source code in furthrmind\collection\baseclass.py 
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
def to_dict(self):
    """
    Converts the object's attributes to a dictionary representation.

    Returns
    -------
    dict
        Dictionary containing the object's attributes (excluding private attributes, callable attributes, and attributes of type Furthrmind).
    """

    from furthrmind import Furthrmind

    data = {}
    for attr in dir(self):
        if attr.startswith("_"):
            continue
        value = getattr(self, attr)
        if callable(value):
            continue
        if isinstance(value, Furthrmind):
            continue
        data[attr] = self._convert(value)
    return data