ooui 0.1.0__tar.gz

ooui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 GISCE-TI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ooui-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: ooui
+Version: 0.1.0
+Summary: Open Object User Interface
+Home-page: https://github.com/gisce/python-ooui
+Author: GISCE
+Author-email: devel@gisce.net
+License: MIT
+Provides: ooui
+License-File: LICENSE
+
+Open Object User Interface for GISCE-ERP

ooui-0.1.0/README.md

@@ -0,0 +1,2 @@
+# python-ooui
+Port of ooui.js to Python

ooui-0.1.0/ooui/graph/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import absolute_import, unicode_literals
+from lxml import etree
+from ooui.graph.indicator import GraphIndicator
+from ooui.graph.chart import GraphChart
+
+
+GRAPH_TYPES = {
+    'indicator': GraphIndicator,
+    'line': GraphChart,
+    'pie': GraphChart,
+    'bar': GraphChart,
+}
+
+
+def parse_graph(xml):
+    """
+    Parse a graph from an XML string.
+    :param xml:
+    :return:
+    :rtype ooui.graph.Graph
+    """
+    tree = etree.fromstring(xml)
+    graph = tree.xpath('//graph')[0]
+
+    graph_type = graph.get("type")
+
+    if not graph_type or graph_type not in GRAPH_TYPES:
+        raise ValueError("{} is not a valid graph".format(graph_type))
+
+    return GRAPH_TYPES[graph_type](graph_type, graph)

ooui-0.1.0/ooui/graph/axis.py

@@ -0,0 +1,100 @@
+class GraphAxis(object):
+    AXIS_OPTIONS = ('x', 'y')
+
+    def __init__(self, name, axis):
+        if axis not in self.AXIS_OPTIONS:
+            raise ValueError("Invalid axis value. Must be 'x' or 'y'.")
+
+        self._name = name
+        self._axis = axis
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def axis(self):
+        return self._axis
+
+
+class GraphXAxis(GraphAxis):
+    def __init__(self, name):
+        # Crida el constructor de GraphAxis amb l'eix 'x' fixat
+        super(GraphXAxis, self).__init__(name, 'x')
+
+
+class GraphYAxis(GraphAxis):
+    OPERATOR_OPTIONS = ('count', '+', '-', '*', 'min', 'max', 'avg')
+
+    def __init__(self, name, operator, label=None, stacked=None):
+        super(GraphYAxis, self).__init__(name, 'y')
+
+        if operator not in self.OPERATOR_OPTIONS:
+            raise ValueError("Invalid operator value.")
+
+        self._operator = operator
+        self._label = label
+        self._stacked = stacked
+
+    @property
+    def operator(self):
+        return self._operator
+
+    @property
+    def label(self):
+        return self._label
+
+    @property
+    def stacked(self):
+        return self._stacked
+
+
+def parse_xy_axis(nodes):
+    x_axis = None
+    y_axes = []
+
+    for child in nodes:
+        if child.tag == "field":
+            axis = child.get("axis")
+            name = child.get("name")
+            operator = child.get("operator")
+            label = child.get("label")
+            stacked = child.get("stacked")
+
+            if not axis:
+                raise ValueError("Field {} doesn't have an axis".format(name))
+
+            if not name:
+                raise ValueError("Missing name attribute for field")
+
+            if axis == "x":
+                x_axis = GraphXAxis(name)
+            elif axis == "y":
+                y_axes.append(GraphYAxis(name, operator, label, stacked))
+
+    if not x_axis:
+        raise ValueError("No x axis found")
+
+    if not y_axes:
+        raise ValueError("No y axis found. At least one y axis is required")
+
+    return {"x": x_axis, "y": y_axes}
+
+
+def get_y_axis_fieldname(y_axis, fields):
+    """
+    Retrieve the field name for a Y-axis based on the `GraphYAxis` object
+    and field definitions.
+
+    :param GraphYAxis y_axis: An object representing the Y-axis.
+    :param dict fields: A dictionary containing the field definitions.
+
+    :rtype: str
+    :returns: The name of the Y-axis field.
+    """
+    field_props = fields.get(y_axis.name, {})
+
+    if 'string' in field_props and field_props['string']:
+        return field_props['string']
+
+    return y_axis.name

ooui-0.1.0/ooui/graph/base.py

@@ -0,0 +1,31 @@
+
+
+class Graph(object):
+    def __init__(self, element):
+        """
+
+        :param element: lxml.etree._Element
+        """
+        self._string = element.get('string')
+        self._timerange = element.get('timerange', None)
+
+        interval = element.get('interval', None)
+        self._interval = int(interval) if interval is not None else 1
+
+        self._type = None
+
+    @property
+    def string(self):
+        return self._string
+
+    @property
+    def timerange(self):
+        return self._timerange
+
+    @property
+    def interval(self):
+        return self._interval
+
+    @property
+    def type(self):
+        return self._type

ooui-0.1.0/ooui/graph/chart.py

@@ -0,0 +1,20 @@
+from ooui.graph.base import Graph
+from ooui.graph.axis import parse_xy_axis
+
+
+class GraphChart(Graph):
+    def __init__(self, graph_type, element):
+        super(GraphChart, self).__init__(element)
+
+        self._type = graph_type
+        xy_axis = parse_xy_axis(element)
+        self._x = xy_axis['x']
+        self._y = xy_axis['y']
+
+    @property
+    def x(self):
+        return self._x
+
+    @property
+    def y(self):
+        return self._y

ooui-0.1.0/ooui/graph/fields.py

@@ -0,0 +1,116 @@
+from functools import reduce
+
+
+def get_fields_to_retrieve(ooui):
+    """
+    Returns a list of fields to retrieve from the ooui
+    :param ooui: Graph instance
+    :type ooui: ooui.graph.chart.GraphChart
+    :return: list of fields to retrieve
+    :rtype: list[str]
+    """
+    x_field = ooui.x.name
+    fields = [x_field]
+
+    if not ooui.y:
+        return []
+
+    for y in ooui.y:
+        if y.operator != 'count' and y.name not in fields:
+            fields.append(y.name)
+
+        if y.label and y.label not in fields:
+            fields.append(y.label)
+
+    return fields
+
+
+def get_value_and_label_for_field(fields, values, field_name):
+    """
+    Retrieve the value and label for a specific field.
+
+    :param dict fields: A dictionary containing the field definitions.
+        The keys are field names and the values are their details.
+    :param dict values: A dictionary containing the field values.
+        The keys are field names, and the values are the associated values.
+    :param str field_name: The name of the field for which to obtain the value
+        and label.
+
+    :rtype: dict
+    :returns: A dictionary with the keys `value` and `label`:
+        - `value`: The field value or `False` if not found.
+        - `label`: The field label or `None` if not found.
+
+    :raises ValueError: If the specified field is not found in the `fields`
+        dictionary.
+    """
+    x_field_data = fields.get(field_name)
+    value = values.get(field_name)
+
+    if not x_field_data:
+        raise ValueError("Field {} not found".format(field_name))
+
+    if x_field_data['type'] == 'many2one':
+        if not value:
+            return {'value': False, 'label': None}
+        return {'value': value[0], 'label': value[1]}
+
+    elif x_field_data['type'] == 'selection':
+        selection_values = x_field_data['selection']
+        value_pair = next((pair for pair in selection_values if pair[0] == value), None)
+
+        if not value_pair:
+            return {'value': False, 'label': None}
+
+        return {'value': value, 'label': value_pair[1]}
+
+    return {'value': value, 'label': value}
+
+
+def get_value_for_operator(operator, values):
+    """
+    Retrieve the result of applying an operator on a list of values.
+
+    :param str operator: The operator to be applied.
+        Possible values include "count", "+", "-", "*", "avg", "min", "max".
+    :param list values: A list of numerical values on which to apply the
+        operator.
+
+    :rtype: float or int
+    :returns: The result of applying the operator to the values.
+
+    :raises ValueError: If an unsupported operator is provided or if the
+        values list is empty for certain operators.
+    """
+    if operator == "count":
+        return len(values)
+    elif operator == "+":
+        return round_number(sum(values))
+    elif operator == "-":
+        return round_number(reduce(lambda x, y: x - y, values))
+    elif operator == "*":
+        return round_number(reduce(lambda x, y: x * y, values))
+    elif operator == "avg":
+        if not values:
+            return 0
+        total_sum = sum(values)
+        avg = total_sum / len(values)
+        return round_number(avg)
+    elif operator == "min":
+        return min(values)
+    elif operator == "max":
+        return max(values)
+    else:
+        raise ValueError("Unsupported operator: {}".format(operator))
+
+
+def round_number(num):
+    """
+    Round a number to two decimal places.
+
+    :param float or int num: The number to be rounded.
+
+    :rtype: float
+    :returns: The number rounded to two decimal places.
+    """
+    return round(num * 100) / 100

ooui-0.1.0/ooui/graph/indicator.py

@@ -0,0 +1,39 @@
+from ooui.graph.base import Graph
+from ooui.helpers import parse_bool_attribute, replace_entities
+
+
+class GraphIndicator(Graph):
+    def __init__(self, graph_type, element):
+        # Inicia la classe base Graph
+        super(GraphIndicator, self).__init__(element)
+
+        self._type = graph_type
+        self._color = replace_entities(element.get('color')) if element.get(
+            'color') else None
+        self._icon = replace_entities(element.get('icon')) if element.get(
+            'icon') else None
+        self._suffix = element.get('suffix') if element.get('suffix') else None
+        self._total_domain = replace_entities(
+            element.get('totalDomain')) if element.get('totalDomain') else None
+        self._show_percent = parse_bool_attribute(
+            element.get('showPercent')) if element.get('showPercent') else False
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def icon(self):
+        return self._icon
+
+    @property
+    def total_domain(self):
+        return self._total_domain
+
+    @property
+    def show_percent(self):
+        return self._show_percent
+
+    @property
+    def suffix(self):
+        return self._suffix

ooui-0.1.0/ooui/graph/processor.py

@@ -0,0 +1,186 @@
+from __future__ import absolute_import, unicode_literals
+from ooui.graph.fields import get_value_and_label_for_field, get_value_for_operator
+from ooui.graph.axis import get_y_axis_fieldname
+from ooui.graph.timerange import process_timerange_data
+
+
+def process_graph_data(ooui, values, fields, options=None):
+    """
+    Process graph data by grouping and sorting the values according to the
+    specified X and Y axes.
+
+    :param ooui: A GraphChart-like object containing chart information.
+    :type ooui: ooui.graph.GraphChart
+    :param list values: A list of dictionaries representing the original data.
+    :param dict fields: A dictionary of field definitions.
+    :param dict options: Optional additional options for processing graph data.
+
+    :rtype: dict
+    :returns: A dictionary containing the final processed data and flags like
+        isGroup and isStack.
+    """
+    if options is None:
+        options = {}
+
+    values_grouped_by_x = get_values_grouped_by_field(
+        ooui.x.name, fields, values
+    )
+
+    data = []
+
+    # Iterate through the y-axis items
+    for y_field in ooui.y:
+        for x_value, group in values_grouped_by_x.items():
+            x_label = group['label']
+            objects_for_x_value = group['entries']
+
+            if not y_field.label:
+                values_for_y_field = get_values_for_y_field(
+                    objects_for_x_value, y_field.name, fields
+                )
+                final_value = get_value_for_operator(
+                    y_field.operator, values_for_y_field
+                )
+
+                data.append({
+                    'x': x_label or False,
+                    'value': final_value,
+                    'type': get_y_axis_fieldname(y_field, fields),
+                    'operator': y_field.operator,
+                    'stacked': y_field.stacked
+                })
+            else:
+                values_grouped_by_y_label = get_values_grouped_by_field(
+                    y_field.label, fields, objects_for_x_value
+                )
+
+                for y_unique_value, grouped_entries in values_grouped_by_y_label.items():
+                    entries = grouped_entries['entries']
+                    label = grouped_entries['label']
+
+                    values_for_y_field = get_values_for_y_field(
+                        entries, y_field.name, fields
+                    )
+                    final_value = get_value_for_operator(
+                        y_field.operator, values_for_y_field
+                    )
+
+                    data.append({
+                        'x': x_label or False,
+                        'value': final_value,
+                        'type': label,
+                        'operator': y_field.operator,
+                        'stacked': y_field.stacked
+                    })
+
+    # Check if data should be flagged as grouped or stacked
+    is_group = any(y.label is not None for y in ooui.y)
+    is_stack = any(y.stacked is not None for y in ooui.y)
+
+    # Sort the data by the x-axis
+    sorted_data = sorted(data, key=lambda x: x['x'] or "")
+
+    adjusted_stacked_data = sorted_data[:]
+    if is_stack and len([y for y in ooui.y if y.stacked is not None]) > 1:
+        adjusted_stacked_data = [
+            dict(
+                entry,
+                type="{} - {}".format(entry['type'], entry['stacked'])
+            ) for entry in sorted_data
+        ]
+
+    adjusted_uninformed_data = adjusted_stacked_data[:]
+    if ooui.type == 'pie' and any(entry['x'] is False for entry in adjusted_stacked_data):
+        adjusted_uninformed_data = [
+            dict(
+                entry,
+                x=options.get('uninformedString', 'Not informed') if entry['x'] is False else entry['x']
+            ) for entry in adjusted_stacked_data
+        ]
+    else:
+        adjusted_uninformed_data = [
+            entry for entry in adjusted_stacked_data if entry['x'] is not False
+        ]
+
+    # Fill gaps if a timerange is defined
+    final_data = adjusted_uninformed_data
+    if ooui.timerange:
+        final_data = process_timerange_data(
+            final_data, ooui.timerange, ooui.interval
+        )
+    elif ooui.type == 'pie':
+        final_data = sorted(
+            adjusted_uninformed_data, key=lambda x: x['value'], reverse=True
+        )
+
+    return {
+        'data': final_data,
+        'isGroup': is_stack or is_group,
+        'isStack': is_stack
+    }
+
+
+def get_values_for_y_field(entries, field_name, fields):
+    """
+    Retrieve labels for a specified field across multiple entries.
+
+    :param list entries: A list of dictionaries representing the entries.
+    :param str field_name: The name of the field for which to retrieve labels.
+    :param dict fields: A dictionary containing the field definitions.
+    :param func get_value_and_label_for_field: Function to retrieve value and
+        label for a field.
+
+    :rtype: list
+    :returns: A list containing the labels corresponding to the specified field.
+    """
+    return [
+        get_value_and_label_for_field(fields, entry, field_name)['label']
+        for entry in entries
+    ]
+
+
+def get_values_grouped_by_field(field_name, fields, values):
+    """
+    Group values by a specific field.
+
+    :param str field_name: The name of the field by which to group values.
+    :param dict fields: A dictionary containing field definitions.
+    :param list values: A list of dictionaries representing the values to be
+        grouped.
+
+    :rtype: dict
+    :returns: A dictionary where keys are field values and values are
+        dictionaries containing a label and an "entries" list.
+    """
+    grouped_values = {}
+
+    for entry in values:
+        result = get_value_and_label_for_field(fields, entry, field_name)
+        value, label = result['value'], result['label']
+
+        if value not in grouped_values:
+            grouped_values[value] = {'label': label, 'entries': []}
+
+        grouped_values[value]['entries'].append(entry)
+
+    return grouped_values
+
+
+def get_all_objects_in_grouped_values(grouped):
+    """
+    Retrieve all objects within grouped values.
+
+    :param dict grouped: A dictionary where keys are group identifiers and
+        values are dictionaries with a key "entries" containing lists of
+        objects.
+
+    :rtype: list
+    :returns: A list containing all objects from each group's "entries".
+    """
+    total_objects = []
+
+    for key in grouped:
+        group = grouped[key]
+        total_objects.extend(group['entries'])
+
+    return total_objects

ooui-0.1.0/ooui/graph/timerange.py

@@ -0,0 +1,300 @@
+from datetime import datetime, timedelta
+from dateutil.relativedelta import relativedelta
+
+from ooui.graph.fields import get_value_for_operator
+
+
+def process_timerange_data(values, timerange, interval=1):
+    """
+    Process time range data by combining values and filling gaps.
+
+    :param list values: A list de diccionaris representing the original data.
+    :param str timerange: The time range unit ("day", "week", "month", "year").
+    :param int interval: The interval to increment dates by.
+
+    :rtype: list
+    :returns: A list containing the processed values with gaps filled.
+    """
+    combined_values = combine_values_for_timerange(values, timerange)
+    filled_values = fill_gaps_in_timerange_data(
+        combined_values, timerange, interval
+    )
+
+    return filled_values
+
+
+def fill_gaps_in_timerange_data(values, timerange, interval):
+    """
+    Fill gaps in time range data by inserting missing dates.
+
+    :param list values: A list of dictionaries representing the original data.
+    :param str timerange: The time range unit ("day", "week", "month", "year").
+    :param int interval: The interval to increment dates by.
+
+    :rtype: list
+    :returns: A new list containing all values with gaps filled in.
+    """
+    final_values = []
+    unique_values = get_unique_values_grouped_by(values, 'type-stacked')
+
+    for key, values_for_key in unique_values.items():
+        for i in range(len(values_for_key)):
+            value = values_for_key[i]
+            final_values.append(value)
+
+            if i == len(values_for_key) - 1:
+                break
+
+            date = value['x']
+            next_date = values_for_key[i + 1]['x']
+
+            missing_dates = get_missing_consecutive_dates(
+                [date, next_date], timerange, interval
+            )
+
+            final_values.extend([
+                {
+                    'x': string_date,
+                    'value': 0,
+                    'type': value['type'],
+                    'stacked': value['stacked']
+                } for string_date in missing_dates
+            ])
+
+    return final_values
+
+
+def add_time_unit(start_date, interval, units):
+    if units == 'days':
+        return start_date + timedelta(days=interval)
+    elif units == 'weeks':
+        return start_date + timedelta(weeks=interval)
+    elif units == 'months':
+        return start_date + relativedelta(months=interval)
+    elif units == 'years':
+        return start_date + relativedelta(years=interval)
+    else:
+        raise ValueError("Unsupported units: {}".format(units))
+
+
+def get_missing_consecutive_dates(dates, timerange, interval=1):
+    """
+    Retrieve the missing consecutive dates within a range according to a specific time unit.
+
+    :param list dates: A list of strings representing the sorted original dates.
+    :param str timerange: The time unit for checking consecutive dates ("day", "week", "month", "year").
+    :param int interval: An optional interval to increment dates by.
+
+    :rtype: list
+    :returns: A list of missing dates as strings.
+    """
+    missing_dates = []
+    units = "{}s".format(timerange)
+    format_str = get_format_for_units(units)
+
+    if len(dates) == 1:
+        return dates
+
+    sorted_dates = sorted(dates)
+
+    for i in range(len(sorted_dates) - 1):
+        date1 = datetime.strptime(sorted_dates[i], format_str)
+        date2 = datetime.strptime(sorted_dates[i + 1], format_str)
+
+        next_date = add_time_unit(date1, interval, units)
+
+        while next_date < date2:
+            missing_dates.append(next_date.strftime(format_str))
+            next_date = add_time_unit(next_date, interval, units)
+
+    return missing_dates
+
+
+def combine_values_for_timerange(values, timerange):
+    """
+    Combine values according to a specific time range.
+
+    :param list values: A list of dictionaries representing the original data.
+    :param str timerange: The time range for adjusting and combining the values.
+
+    :rtype: list
+    :returns: A list of dictionaries containing the final combined values.
+    """
+    adjusted_values = adjust_x_values_for_time_range(values, timerange)
+    unique_values = get_unique_values_grouped_by(adjusted_values, 'all')
+
+    final_values = []
+
+    for key, values_for_key in unique_values.items():
+        operator = values_for_key[0]['operator']
+        if operator == 'count':
+            operator = '+'
+
+        final_value = get_value_for_operator(
+            operator, [entry['value'] for entry in values_for_key]
+        )
+
+        final_values.append(dict(values_for_key[0], value=final_value))
+
+    return final_values
+
+
+def adjust_x_values_for_time_range(values, timerange):
+    """
+    Adjust the "x" values in a list of items according to the specified
+    time range.
+
+    :param list values: A list of dictionaries containing the original data.
+    :param str timerange: The time range for adjusting the "x" values.
+
+    :rtype: list
+    :returns: A new list where each item's "x" property is adjusted based on
+        the time range.
+    """
+    return [
+        dict(value, x=convert_date_to_time_range_adjusted(value['x'], timerange))
+        for value in values
+    ]
+
+
+def convert_date_to_time_range_adjusted(date, timerange):
+    """
+    Adjust a date to a specific time range format.
+
+    :param str date: The original date string.
+    :param str timerange: The time range for adjustment
+        ("hour", "day", "week", "month", "year").
+
+    :rtype: str
+    :returns: The adjusted date in the specified time range format.
+    """
+    format_str = get_date_format(date)
+    moment_date = datetime.strptime(date, format_str)
+
+    if timerange == 'hour':
+        return moment_date.strftime('%Y-%m-%d %H:00')
+    elif timerange == 'day':
+        return moment_date.strftime('%Y-%m-%d')
+    elif timerange == 'week':
+        return moment_date.strftime('%Y-%W')
+    elif timerange == 'month':
+        return moment_date.strftime('%Y-%m')
+    elif timerange == 'year':
+        return moment_date.strftime('%Y')
+    else:
+        raise ValueError("Unsupported timerange: {}".format(timerange))
+
+
+def get_date_format(date_str):
+    """
+    Determine the appropriate date format string based on whether the input
+    string contains a colon.
+
+    :param str date_str: A string representing the date to be checked.
+
+    :rtype: str
+    :returns: The appropriate date format string compatible with
+        `datetime.strptime`.
+    """
+    if ':' in date_str:
+        return '%Y-%m-%d %H:%M:%S'
+    else:
+        return '%Y-%m-%d'
+
+
+def get_unique_values_grouped_by(values, group_by):
+    """
+    Group values by unique keys determined by the grouping criteria.
+
+    :param list values: A list of dictionaries representing the values.
+    :param str group_by: Grouping criteria. Can be "all" or "type-stacked".
+
+    :rtype: dict
+    :returns: A dictionary where keys are unique identifiers based on the
+        grouping criteria, and values are lists of grouped items.
+    """
+    unique_values = {}
+
+    for value in values:
+        x = value.get('x')
+        value_type = value.get('type')
+        stacked = value.get('stacked')
+
+        if group_by == 'all':
+            unique_key = "{}-{}-{}".format(x, value_type, stacked)
+        else:
+            unique_key = "{}-{}".format(value_type, stacked)
+
+        if unique_key not in unique_values:
+            unique_values[unique_key] = []
+
+        unique_values[unique_key].append(value)
+
+    return unique_values
+
+
+def get_format_for_units(units):
+    """
+    Retrieve the appropriate date format string based on the units provided.
+
+    :param str units: A string representing the time units
+        (e.g., "days", "weeks", "months", "years", or "hours").
+
+    :rtype: str
+    :returns: The appropriate date format string based on the provided units.
+    """
+    if units == 'days':
+        return '%Y-%m-%d'
+    elif units == 'weeks':
+        return '%Y-%W'
+    elif units == 'months':
+        return '%Y-%m'
+    elif units == 'years':
+        return '%Y'
+    else:
+        return '%Y-%m-%d %H:%M'
+
+
+def check_dates_consecutive(dates, unit):
+    """
+    Check if the dates in the list are consecutive based on the provided unit.
+
+    :param list dates: A list of strings representing the dates to be checked.
+    :param str unit: The unit to check for consecutiveness ("hours", "days", "weeks", "months", or "years").
+
+    :rtype: bool
+    :returns: True if the dates are consecutive in the given unit, otherwise False.
+    """
+    if len(dates) == 0:
+        return False
+
+    if len(dates) == 1:
+        return True
+
+    consecutive = False
+    format_str = get_format_for_units(unit)
+
+    for i in range(len(dates) - 1):
+        date1 = datetime.strptime(dates[i], format_str)
+        date2 = datetime.strptime(dates[i + 1], format_str)
+
+        if unit == 'hours':
+            diff = (date2 - date1).total_seconds() / 3600
+        elif unit == 'days':
+            diff = (date2 - date1).days
+        elif unit == 'weeks':
+            diff = (date2 - date1).days // 7
+        elif unit == 'months':
+            diff = relativedelta(date2, date1).months + (relativedelta(date2, date1).years * 12)
+        elif unit == 'years':
+            diff = relativedelta(date2, date1).years
+        else:
+            raise ValueError("Unsupported unit: {}".format(unit))
+
+        if abs(diff) == 1:
+            consecutive = True
+        else:
+            consecutive = False
+            break
+
+    return consecutive

ooui-0.1.0/ooui/helpers/__init__.py

@@ -0,0 +1,25 @@
+import six
+
+
+def parse_bool_attribute(attribute):
+    """
+    Parse a boolean attribute.
+    :param attribute:
+    :return: bool
+    """
+    return str(attribute).lower() in ("1", "true")
+
+
+def replace_entities(text):
+    """
+    Replace all HTML entities with their respective unicode characters.
+    :param text:
+    :return:
+    """
+    if six.PY2:
+        from HTMLParser import HTMLParser
+        parser = HTMLParser()
+        return parser.unescape(text)
+    else:
+        import html
+        return html.unescape(text)

ooui-0.1.0/ooui.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: ooui
+Version: 0.1.0
+Summary: Open Object User Interface
+Home-page: https://github.com/gisce/python-ooui
+Author: GISCE
+Author-email: devel@gisce.net
+License: MIT
+Provides: ooui
+License-File: LICENSE
+
+Open Object User Interface for GISCE-ERP

ooui-0.1.0/ooui.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+ooui/__init__.py
+ooui.egg-info/PKG-INFO
+ooui.egg-info/SOURCES.txt
+ooui.egg-info/dependency_links.txt
+ooui.egg-info/requires.txt
+ooui.egg-info/top_level.txt
+ooui/graph/__init__.py
+ooui/graph/axis.py
+ooui/graph/base.py
+ooui/graph/chart.py
+ooui/graph/fields.py
+ooui/graph/indicator.py
+ooui/graph/processor.py
+ooui/graph/timerange.py
+ooui/helpers/__init__.py

ooui-0.1.0/ooui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ooui-0.1.0/ooui.egg-info/requires.txt

@@ -0,0 +1,3 @@
+lxml
+python-dateutil
+six

ooui-0.1.0/ooui.egg-info/top_level.txt

@@ -0,0 +1 @@
+ooui

ooui-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ooui-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='ooui',
+    description='Open Object User Interface',
+    author='GISCE',
+    author_email='devel@gisce.net',
+    url='https://github.com/gisce/python-ooui',
+    version='0.1.0',
+    license='MIT',
+    long_description='''Open Object User Interface for GISCE-ERP''',
+    provides=['ooui'],
+    install_requires=[
+        'lxml',
+        'python-dateutil',
+        'six',
+    ],
+    tests_require=[
+        'mamba',
+        'expects',
+    ],
+    packages=find_packages()
+)