🎨 review code and closes brazil-data-cube#73 brazil-data-cube#72

Author: fabianazioti

lccs/classes.py

@@ -16,117 +16,118 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/gpl-3.0.html>.
 #
 """Python Client Library for the LCCS Web Service."""
+from typing import List, Optional
 from .utils import Utils
 
 
 class ClassesGroup(dict):
-    """Group of classes mappings."""
+    """Group of classification system classes."""
 
-    def __init__(self, data, validate=False):
-        """Initialize instance with dictionary data.
+    def __init__(self, data: dict, validate: bool = False) -> None:
+        """
+        Initialize instance with dictionary data.
 
-        :param data: Dict with Item Collection metadata.
-        :param validate: true if the Item Collection should be validate using its jsonschema. Default is False.
+        :param data: Dictionary containing classification group data.
+        :param validate: Whether to validate the data using jsonschema. Default is False.
         """
+        super().__init__(data or {})
         self._validate = validate
-        super(ClassesGroup, self).__init__(data or {})
-        self._classes = [ClassificationSystemClass(i, self._validate) for i in self['classes']]
+        self._classes: List[ClassificationSystemClass] = [
+            ClassificationSystemClass(i, self._validate) for i in self.get('classes', [])
+        ]
 
     @property
-    def classes(self):
-        """:return: classes."""
+    def classes(self) -> List['ClassificationSystemClass']:
+        """Return the list of classification system classes."""
         return self._classes
 
-    def _repr_html_(self):
-        """HTML repr."""
+    def _repr_html_(self) -> str:
+        """Render HTML representation."""
         return Utils.render_html('mapping.html', mappings=self)
 
-    def __repr__(self):
-        """Return the string representation of a mapping group object."""
-        text = ''
-        for i in self._classes:
-            text += f'\n\t{i}'
-        return text
+    def __repr__(self) -> str:
+        """Return the string representation of the group."""
+        return "\n".join([str(cls) for cls in self._classes])
 
-    def __str__(self):
-        """Return the string representation of a mapping group object."""
-        text = ''
-        for i in self._classes:
-            text += f'\n\t{i}'
-        return text
+    def __str__(self) -> str:
+        """Return the string representation of the group (readable)."""
+        return self.__repr__()
 
 
 class ClassificationSystemClass(dict):
-    """Class of the classification system."""
-
-    def __init__(self, data, validate=False) -> None:
-        """Initialize instance with dictionary data.
+    """Class representing a classification system."""
 
-        :param data: Dict with Class metadata.
+    def __init__(self, data: dict, validate: bool = False) -> None:
+        """
+        Initialize instance with dictionary data.
 
-        :param validate: true if the Class should be validate using its jsonschema. Default is False.
+        :param data: Dictionary containing class metadata.
+        :param validate: Whether to validate the data using jsonschema. Default is False.
         """
+        super().__init__(data or {})
         self._validate = validate
-        super(ClassificationSystemClass, self).__init__(data or {})
 
     @property
-    def id(self):
-        """:return: the class id."""
-        return self['id']
+    def id(self) -> str:
+        """Return the class ID."""
+        return self.get('id')
 
     @property
-    def name(self):
-        """:return: the class name."""
-        return self['name']
+    def name(self) -> str:
+        """Return the class name."""
+        return self.get('name')
 
     @property
-    def title(self):
-        """:return: the class title."""
-        return self['title']
+    def title(self) -> str:
+        """Return the class title."""
+        return self.get('title')
 
     @property
-    def description(self):
-        """:return: the class description."""
-        return self['description'] if 'description' in self else None
+    def description(self) -> Optional[str]:
+        """Return the class description."""
+        return self.get('description')
 
     @property
-    def color(self):
-        """:return: the class description."""
-        return self['color'] if 'color' in self else None
+    def color(self) -> Optional[str]:
+        """Return the class color."""
+        return self.get('color')
 
     @property
-    def code(self):
-        """:return: the class code."""
-        return self['code']
+    def code(self) -> str:
+        """Return the class code."""
+        return self.get('code')
 
     @property
-    def links(self):
-        """:return: the class links."""
-        return self['links']
+    def links(self) -> List[dict]:
+        """Return the class links."""
+        return self.get('links', [])
 
     @property
-    def class_parent_id(self):
-        """:return: the class parent id."""
-        return self['class_parent_id'] if 'class_parent_id' in self else None
+    def class_parent_id(self) -> Optional[str]:
+        """Return the parent class ID."""
+        return self.get('class_parent_id')
 
     @property
-    def class_parent_name(self):
-        """:return: class_parent_name of classification system."""
+    def class_parent_name(self) -> Optional[str]:
+        """Return the parent class name."""
         return self._get_parent_name()
 
-    def _get_parent_name(self):
-        if 'class_parent_id' in self:
-            parent = [link['href'] for link in self['links'] if link['rel'] == 'parent'][0]
-            system = parent.rsplit('/', maxsplit=1)[1].split('?')[0]
-
-            if len(parent.rsplit('/', maxsplit=1)[1].split('?')) > 1:
-                token = parent.rsplit('/', maxsplit=1)[1].split('?')[1]
-                parent_class_uri = parent.rsplit('/', maxsplit=1)[
-                                       0] + f'/{system}' + f'/classes/{self["class_parent_id"]}?{token}'
-            else:
-                parent_class_uri = parent.rsplit('/', maxsplit=1)[
-                                       0] + f'/{system}' + f'/classes/{self["class_parent_id"]}'
-            class_parent_name = ClassificationSystemClass(Utils._get(parent_class_uri)).name
-            return class_parent_name
-        else:
-            return None
+    def _get_parent_name(self) -> Optional[str]:
+        """Resolve and return the parent class name, if available."""
+        if self.class_parent_id:
+            parent_link = next((link for link in self.links if link.get('rel') == 'parent'), None)
+            if parent_link:
+                try:
+                    parent_url = self._build_parent_url(parent_link['href'])
+                    parent_data = Utils._get(parent_url)
+                    return ClassificationSystemClass(parent_data).name
+                except Exception as e:
+                    return None
+        return None
+
+    def _build_parent_url(self, href: str) -> str:
+        """Build the full URL for the parent class."""
+        system = href.rsplit('/', maxsplit=1)[1].split('?')[0]
+        token = href.split('?')[-1] if '?' in href else ""
+        base_url = href.rsplit('/', maxsplit=1)[0]
+        return f"{base_url}/{system}/classes/{self['class_parent_id']}?{token}" if token else f"{base_url}/{system}/classes/{self['class_parent_id']}"

lccs/classification_system.py

@@ -16,94 +16,114 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/gpl-3.0.html>.
 #
 """Python Client Library for the LCCS Web Service."""
-from typing import Union, Any, List, Optional, cast
-
+from typing import Union, Any, List, Optional
 from .classes import ClassificationSystemClass, ClassesGroup
 from .link import Link
 from .utils import Utils
 
 
 class ClassificationSystem(dict):
-    """Classification System Class."""
+    """Representation of a Classification System."""
 
-    def __init__(self, data, validate=False):
-        """Initialize instance with dictionary data.
+    def __init__(self, data: dict, validate: bool = False) -> None:
+        """
+        Initialize a classification system with metadata.
 
-        :param data: Dict with class system metadata.
-        :param validate: true if the Class System should be validate using its jsonschema. Default is False.
+        :param data: Dictionary containing classification system metadata.
+        :param validate: Whether to validate the data using jsonschema. Default is False.
         """
+        super().__init__(data or {})
         self._validate = validate
-        super(ClassificationSystem, self).__init__(data or {})
 
     @property
     def id(self) -> int:
-        """:return: id of classification system."""
-        return self['id']
+        """Return the ID of the classification system."""
+        return self.get('id')
 
     @property
     def identifier(self) -> str:
-        """:return: identifier of classification system."""
-        return self['identifier']
+        """Return the identifier of the classification system."""
+        return self.get('identifier')
 
     @property
     def name(self) -> str:
-        """:return: name of classification system."""
-        return self['name']
+        """Return the name of the classification system."""
+        return self.get('name')
 
     @property
     def title(self) -> str:
-        """:return: title of classification system."""
-        return self['title']
+        """Return the title of the classification system."""
+        return self.get('title')
 
     @property
     def links(self) -> List[Link]:
-        """:return: a list of link in the classification system."""
-        return [Link(link) for link in self['links']]
+        """Return a list of links associated with the classification system."""
+        return [Link(link) for link in self.get('links', [])]
 
     @property
-    def description(self) -> str:
-        """:return: description of classification system."""
-        return self['description']
+    def description(self) -> Optional[str]:
+        """Return the description of the classification system."""
+        return self.get('description')
 
     @property
     def version(self) -> str:
-        """:return: version of classification system."""
-        return self['version']
+        """Return the version of the classification system."""
+        return self.get('version')
 
     @property
-    def authority_name(self) -> str:
-        """:return: authority_name of classification system."""
-        return self['authority_name']
-
-    def classes(self, class_name_or_id: Optional[str] = None, style_format_name_or_id: Optional[str] = None) -> Union[ClassesGroup, ClassificationSystemClass]:
-        """:return: classes of the classification system."""
-        if style_format_name_or_id is not None:
-            _classes_data = next(Utils._get(f"{link['href']}&style_format_id={style_format_name_or_id}") for link in self['links'] if link['rel'] == 'classes')
-
-        else:
-            _classes_data = next(Utils._get(link['href']) for link in self['links'] if link['rel'] == 'classes')
-
-
-        if class_name_or_id is not None:
-            _classes_link = [link['href'] for link in self['links'] if link['rel'] == 'classes'][0]
-            link = _classes_link.split('classes')
-            data = Utils._get(f'{link[0]}classes/{class_name_or_id}{link[1]}')
-            return ClassificationSystemClass(data, self._validate)
-
-        all_classes = ClassesGroup(dict(classes=_classes_data))
-        return all_classes.classes
+    def authority_name(self) -> Optional[str]:
+        """Return the authority name of the classification system."""
+        return self.get('authority_name')
+
+    def classes(
+        self,
+        class_name_or_id: Optional[str] = None,
+        style_format_name_or_id: Optional[str] = None
+    ) -> Union[ClassesGroup, ClassificationSystemClass]:
+        """
+        Return the classes of the classification system.
 
-    def _repr_html_(self):
-        """HTML repr."""
+        :param class_name_or_id: Name or ID of a specific class. Default is None.
+        :param style_format_name_or_id: Style format ID for filtering classes. Default is None.
+        :return: A group of classes or a specific classification system class.
+        """
+        try:
+            if style_format_name_or_id:
+                classes_url = next(
+                    link['href'] + f"&style_format_id={style_format_name_or_id}"
+                    for link in self.get('links', []) if link.get('rel') == 'classes'
+                )
+            else:
+                classes_url = next(
+                    link['href'] for link in self.get('links', []) if link.get('rel') == 'classes'
+                )
+            classes_data = Utils._get(classes_url)
+
+            if class_name_or_id:
+                classes_link = next(
+                    link['href'] for link in self.get('links', []) if link.get('rel') == 'classes'
+                )
+                base_url, params = classes_link.split('classes', 1)
+                specific_class_data = Utils._get(f"{base_url}classes/{class_name_or_id}{params}")
+                return ClassificationSystemClass(specific_class_data, self._validate)
+
+            all_classes = ClassesGroup({"classes": classes_data})
+            return all_classes.classes
+        except StopIteration:
+            raise ValueError("No 'classes' link found in the classification system.")
+        except Exception as e:
+            raise RuntimeError(f"An error occurred while retrieving classes: {e}")
+
+    def _repr_html_(self) -> str:
+        """Render an HTML representation of the classification system."""
         return Utils.render_html('classification_system.html', classification_system=self)
 
     def __repr__(self) -> str:
-        """Return the string representation of a classification system object."""
-        text = f'{self.id}:{self.name}-{self.version} - Title: {self.title}'
-        return text
+        """Return the string representation of the classification system."""
+        return f'{self.id}:{self.name}-{self.version} - Title: {self.title}'
 
     def __str__(self) -> str:
-        """Return the string representation of a classification system object."""
+        """Return a human-readable string representation of the classification system."""
         return f'<Classification System [{self.id}:{self.name}-{self.version} - Title: {self.title}]>'
 
 

lccs/lccs.py

@@ -345,7 +345,6 @@ def delete_mapping(self, system_source: str, system_target: str) -> int:
 
         return retval.status_code
 
-    #TODO
     def create_style(self, system: str, style_format: str, options: dict, rules: list):
         """Create style sld."""
         sld = SldGenerator.create_sld(options=options, rules=rules, layer_name=system)

lccs/link.py

@@ -21,29 +21,29 @@
 class Link(dict):
     """Link object."""
 
-    def __init__(self, data):
+    def __init__(self, data) -> None:
         """Initialize instance with dictionary data.
 
         :param data: Dict with Link metadata.
         """
         super(Link, self).__init__(data or {})
 
     @property
-    def rel(self):
+    def rel(self) -> str:
         """:return: the Link relation."""
         return self['rel']
 
     @property
-    def href(self):
+    def href(self) -> str:
         """:return: the Link url."""
         return self['href']
 
     @property
-    def type(self):
+    def type(self) -> str:
         """:return: the type of the Link object."""
         return self['type']
 
     @property
-    def title(self):
+    def title(self)  -> str:
         """:return: the title of the Link object."""
         return self['title']