SankeyExcelParser 1.0.0b0__py3-none-any.whl

SankeyExcelParser/sankey_utils/sankey_object.py

@@ -0,0 +1,165 @@
+"""
+Author : Vincent LE DOZE
+Date : 31/05/23
+
+This file contains descriptions for sankey proto class
+
+"""
+
+
+# Local modules -----------------------------------------------------
+from SankeyExcelParser.sankey_utils.protos.sankey_object import _ProtoSankeyObject
+from SankeyExcelParser.sankey_utils.tag_group import TagGroup
+from SankeyExcelParser.sankey_utils.tag import Tag
+from SankeyExcelParser.sankey_utils.functions import _stdStr
+
+
+# CLASS ----------------------------------------------------------------------------
+class SankeyObject(_ProtoSankeyObject):
+    """
+    Define a generic sankey object.
+    Inherits from _ProtoSankeyObject but add methods to deal with Tag and TagGroup
+    """
+
+    def __init__(self):
+        # Initialize from proto
+        _ProtoSankeyObject.__init__(self)
+
+    @property
+    def tags(self):
+        return self._tags
+
+    @tags.setter
+    def tags(self, _):
+        if type(_) is list:
+            if len(_) > 0:
+                self._tags = []
+                for item in _:
+                    if type(item) is Tag:
+                        self._update_tags(item)
+            else:
+                self._tags = _
+        elif type(_) is Tag:
+            self._update_tags(_)
+
+    def add_tag(self, tag: Tag):
+        if type(tag) is Tag:
+            if tag not in self._tags:
+                self._update_tags(tag)
+            return
+
+    def get_taggroups_from_tagtype(self, tagtype):
+        taggs = []
+        for tagg in self._taggs:
+            if tagg.type == tagtype:
+                taggs.append(tagg)
+        return taggs
+
+    def get_tags_from_taggroup(
+        self,
+        tagg,
+        return_names_instead_of_refs=False
+    ):
+        """
+        Return the list of tags from given tag group and that are related
+        to this object.
+
+        Parameters
+        ----------
+        :param tagg: Tagg group from which the tags must belong to.
+        :type tagg: TagGroup
+
+        :param return_names_instead_of_refs: Return a list of tags names.
+        :type return_names_instead_of_refs: bool (default=False)
+
+        Returns
+        -------
+        :return: List of the tags or None
+        :rtype: list[Tag] | list[str] | None
+        """
+        tags = []
+        if type(tagg) is TagGroup:
+            for tag in self._tags:
+                if tag.group == tagg:
+                    if return_names_instead_of_refs:
+                        tags.append(tag.name_unformatted)
+                    else:
+                        tags.append(tag)
+        if type(tagg) is str:
+            tagg = _stdStr(tagg)
+            for tag in self._tags:
+                if tag.group.name == tagg:
+                    if return_names_instead_of_refs:
+                        tags.append(tag.name_unformatted)
+                    else:
+                        tags.append(tag)
+        if len(tags) == 0:
+            tags = None
+        return tags
+
+    def get_tags_from_taggroups(
+        self,
+        taggs,
+        return_names_instead_of_refs=False
+    ):
+        """
+        Return the list of tags from given list of tag groups and
+        that are related to this object.
+
+        Parameters
+        ----------
+        :param taggs: List of tagg group from which the tags must belong to.
+        :type taggs: list[TagGroup]
+
+        :param return_names_instead_of_refs: Return a list of tags names.
+        :type return_names_instead_of_refs: bool (default=False)
+
+        Returns
+        -------
+        :return: List of the tags as [or None
+        :rtype: list[Tag] | None
+        """
+        output = []
+        if type(taggs) is list:
+            for tagg in taggs:
+                try:
+                    tags = self.get_tags_from_taggroup(tagg)
+                    if tags is not None:
+                        if return_names_instead_of_refs:
+                            output.append(
+                                ':'.join([tag.name_unformatted for tag in tags]))
+                        else:
+                            output.append(tags)
+                    else:
+                        output.append(None)
+                except AttributeError:
+                    output.append(None)
+        return output
+
+    def has_specific_tag(self, tagg, tag):
+        # Find list of tags related to tag group and applied to self
+        tags = self.get_tags_from_taggroup(tagg)
+        # If no tag found
+        if tags is None:
+            return False
+        # Some tags where found
+        if type(tag) is Tag:
+            return (tag in tags)
+        if type(tag) is str:
+            for _ in tags:
+                if _.name_unformatted == tag:
+                    return True
+            return False
+        # Default answer
+        return False
+
+    def _update_tags(self, _):
+        if type(_) is Tag:
+            self._tags.append(_)
+            self._update_taggs(_)
+            _.add_reference(self)
+
+    def _update_taggs(self, _):
+        if type(_) is Tag:
+            if _.group not in self._taggs:
+                self._taggs.append(_.group)

SankeyExcelParser/sankey_utils/table_object.py

@@ -0,0 +1,37 @@
+"""
+Author : Vincent LE DOZE
+Date : 31/05/23
+
+This file contains descriptions for sankey proto class
+
+"""
+
+
+# CLASS ----------------------------------------------------------------------------
+class TableObject(object):
+    """
+    Define an object that is created from given table
+
+    :param extra_infos: Extra infos related to the object.
+    :type extra_infos: dict {info_name: info_content}
+
+    :param excel_source: Source Excel data.
+    :type excel_source: ExcelSource
+    """
+    def __init__(self):
+        self._extra_infos = {}
+        self._excel_source = None
+
+    @property
+    def extra_infos(self):
+        return self._extra_infos
+
+    @property
+    def extra_infos_name(self):
+        return list(self._extra_infos.keys())
+
+    def add_extra_info(self, info_name, info_content):
+        self._extra_infos[info_name] = info_content
+
+    def add_extra_infos(self, info_dict):
+        self._extra_infos.update(info_dict)

SankeyExcelParser/sankey_utils/tag.py

@@ -0,0 +1,95 @@
+"""
+Author : Vincent LE DOZE
+Date : 31/05/23
+
+This file contains descriptions for Tag class
+
+"""
+
+
+# Local modules -----------------------------------------------------
+from SankeyExcelParser.sankey_utils.tag_group import _ProtoTagGroup
+from SankeyExcelParser.sankey_utils.sankey_object import _ProtoSankeyObject
+from SankeyExcelParser.sankey_utils.functions import _stdStr, _convertColorToHex
+
+
+# CLASS ----------------------------------------------------------------------------
+class Tag(object):
+    """
+    Define any Tag.
+
+    Parameters
+    ----------
+    :param name: name of the Tag
+    :type name: str
+
+    :param group: Reference to the tag group from which the tag belongs to.
+    :type group: _ProtoTagGroup
+
+    :param references: Sankey object linked to the tag.
+    :type references: list [SankeyObject, ...]
+    """
+
+    def __init__(
+        self,
+        name: str,
+        group: _ProtoTagGroup
+    ):
+        # Default values
+        self._name = _stdStr(name)
+        self._name_unformatted = name.strip().replace('.0', '')
+        self._color = ''
+        self._group = group
+        self._references = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def name_unformatted(self):
+        return self._name_unformatted
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def color_in_hex(self):
+        return _convertColorToHex(self._color)
+
+    @color.setter
+    def color(self, _):
+        if type(_) is str:
+            self._color = _
+
+    @property
+    def group(self):
+        return self._group
+
+    @group.setter
+    def group(self, _):
+        if isinstance(_, _ProtoTagGroup):
+            self._group = _
+
+    @property
+    def references(self):
+        return self._references.copy()
+
+    def add_reference(
+        self,
+        ref: _ProtoSankeyObject
+    ):
+        self._references.append(ref)
+
+    def __repr__(self):
+        """
+        Gives a string representation of Tag object.
+
+        Returns
+        -------
+        :return: String format of self.
+        :rtype: str
+        """
+        s = '{}'.format(self.name_unformatted)
+        return s

SankeyExcelParser/sankey_utils/tag_group.py

@@ -0,0 +1,206 @@
+"""
+Author : Vincent LE DOZE
+Date : 31/05/23
+
+This file contains descriptions for Tag class
+
+"""
+
+# Local modules -----------------------------------------------------
+from SankeyExcelParser.sankey_utils.protos.tag_group import _ProtoTagGroup
+from SankeyExcelParser.sankey_utils.tag import Tag
+from SankeyExcelParser.sankey_utils.functions import _stdStr
+
+# CONSTANTS -----------------------------------------------------------------------
+ANTI_TAGS_NAME = '0'
+
+
+# CLASS ----------------------------------------------------------------------------
+class TagGroup(_ProtoTagGroup):
+    """
+    Define a Tag Group object.
+    Inherits from _ProtoTagGroup but adds methods to deal with Tags.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        taggtype: str,
+        **kwargs
+    ):
+        # Init parent class
+        _ProtoTagGroup.__init__(self, name, taggtype)
+        # Update values
+        self.update(**kwargs)
+
+    def update(
+        self,
+        **kwargs
+    ):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @property
+    def tags(self):
+        return self._tags
+
+    @tags.setter
+    def tags(self, _):
+        # Input as str
+        if type(_) is str:
+            if len(_) > 0:
+                self._tags = {}
+                names_tags = _.split(':')
+                for name_tag in names_tags:
+                    self._tags[_stdStr(name_tag)] = Tag(name_tag, self)
+            return
+        # Input as list of Tags
+        if type(_) is list:
+            self._tags = {}
+            for tag in _:
+                if type(tag) is Tag:
+                    self._tags[_stdStr(tag.name)] = tag
+
+    @property
+    def anti_tags(self):
+        return self._anti_tags
+
+    def get_or_create_tag(self, tag):
+        # Case tag already a Tag
+        if type(tag) is Tag:
+            # Check if ref name in dict of tags
+            ref_tag = _stdStr(tag.name)
+            if (ref_tag not in self._tags.keys()) and \
+               (ref_tag != self._anti_tags):
+                self.add_tag(tag)
+            # Return already existing or newly created tag
+            return tag
+        # Case tag is a name
+        if type(tag) is str:
+            # Check if ref name in dict of tags
+            ref_tag = _stdStr(tag)
+            if (ref_tag not in self._tags.keys()) or \
+               ((ref_tag == ANTI_TAGS_NAME) and (self._anti_tags is None)):
+                self.add_tag(tag)
+            # Return already existing or newly created tag
+            return self.get_tag_from_name(tag)
+        return None
+
+    def add_tag(self, tag):
+        # Case tag already a Tag
+        if type(tag) is Tag:
+            ref_tag = _stdStr(tag.name)
+            tag.group = self
+            if ref_tag == ANTI_TAGS_NAME:
+                self._anti_tags = tag
+            else:
+                self._tags[ref_tag] = tag
+            return
+        # Case tag is a name
+        if type(tag) is str:
+            ref_tag = _stdStr(tag)
+            if ref_tag == ANTI_TAGS_NAME:
+                self._anti_tags = Tag(ANTI_TAGS_NAME, self)
+            else:
+                self._tags[ref_tag] = Tag(tag, self)
+            return
+
+    def get_tag_from_name(
+        self,
+        tag_name: str,
+        include_anti_tags: bool = True
+    ):
+        ref_tag_name = _stdStr(tag_name)  # all the keys are standardized
+        if ref_tag_name in self._tags.keys():
+            return self._tags[ref_tag_name]
+        # Special case : anti tag -> we create it if it does not exist
+        if include_anti_tags and (ref_tag_name == ANTI_TAGS_NAME):
+            if self._anti_tags is None:
+                self._anti_tags = Tag(ANTI_TAGS_NAME, self)
+            return self._anti_tags
+        return None
+
+    def get_previous_tag(self, _):
+        prev_tag = None
+        if type(_) is str:
+            for tag_name in self.tags.keys():
+                if tag_name == _:
+                    return prev_tag
+                prev_tag = self.tags[tag_name]
+        if type(_) is Tag:
+            for tag in self.tags.values():
+                if tag == _:
+                    return prev_tag
+                prev_tag = tag
+        return prev_tag
+
+    @property
+    def tags_str(self):
+        return ":".join([tag.name_unformatted for tag in self._tags.values()])
+
+    @property
+    def antagonists_taggs(self):
+        return self._antagonists_taggs
+
+    def add_antagonist_tagg(self, tagg):
+        if type(tagg) is TagGroup:
+            if tagg not in self._antagonists_taggs:
+                self._antagonists_taggs.append(tagg)
+                tagg.add_antagonist_tagg(self)
+
+    def has_antagonists(self):
+        return (len(self._antagonists_taggs) > 0)
+
+    @property
+    def colors(self):
+        if self.has_colors_defined():
+            return ':'.join([tag.color for tag in self._tags.values()])
+        else:
+            return ''
+
+    @colors.setter
+    def colors(self, _):
+        if type(_) is str:
+            if len(_) > 0:
+                colors = _.split(':')
+                for color, tag in zip(colors, self._tags.values()):
+                    tag.color = color
+            return
+
+    def has_colors_defined(self):
+        for tag in self.tags.values():
+            if tag.color != '':
+                return True
+        return False
+
+    def get_as_dict(self):
+        # Init output
+        output = {}
+        # Get values
+        output['name'] = self.name
+        output['tags'] = [_.name for _ in self.tags.values()]
+        try:
+            output['anti_tags'] = self.anti_tags.name
+        except Exception:
+            pass
+        try:
+            output['antagonists_taggs'] = self.antagonists_taggs.name
+        except Exception:
+            pass
+        output['colormap'] = self.colormap
+        output['is_palette'] = self.is_palette
+        return output
+
+    def __repr__(self):
+        """
+        Gives a string representation of Taggroup object.
+
+        Returns
+        -------
+        :return: String format of self.
+        :rtype: str
+        """
+        s = '{{{0} | {1}}}'.format(
+            self.name_unformatted,
+            self.tags_str)
+        return s