DataComparerLibrary 0.844__tar.gz → 0.846__tar.gz

{datacomparerlibrary-0.844 → datacomparerlibrary-0.846}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: DataComparerLibrary
-Version: 0.844
+Version: 0.846
 Summary: For comparing csv-files, 2d-array with a csv-file or 2d-arrays. For comparing text-files, text variable with a text-file or text variables. Including a sorting module.
 Home-page: 
 Author: René Philip Zuijderduijn
@@ -10,7 +10,6 @@ Keywords: robotframework testing test-automation datacompare
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: Microsoft :: Windows :: Windows 10
 Classifier: Operating System :: Microsoft :: Windows :: Windows 11
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -19,6 +18,15 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
 
 ===================
 DataComparerLibrary

{datacomparerlibrary-0.844 → datacomparerlibrary-0.846}/setup.py

@@ -33,7 +33,6 @@ def main():
               "License :: OSI Approved :: Apache Software License",
               "Operating System :: Microsoft :: Windows :: Windows 10",
               "Operating System :: Microsoft :: Windows :: Windows 11",
-              "Programming Language :: Python :: 3.7",
               "Programming Language :: Python :: 3.8",
               "Programming Language :: Python :: 3.9",
               "Programming Language :: Python :: 3.10",

datacomparerlibrary-0.846/src/DataComparerLibrary/datacomparer.py

@@ -0,0 +1,162 @@
+# Script for comparing csv-files, 2d-array with a csv-file or 2d-arrays and for comparing text-files, text variable with a text-file or text variables.
+#
+import csv
+import os
+
+from DataComparerLibrary.twodarray import TwoDArray
+from DataComparerLibrary.report import Report
+
+
+class DataComparer:
+    def compare_data_2d_array_with_file(self, actual_data, expected_file, delimiter_expected_data=",", quotechar_expected_data='"', template_literals_dict=None):
+        self.__check_if_actual_data_is_present(actual_data)
+        self.__check_if_expected_file_is_present(expected_file)
+        #
+        expected_data = self.__get_data_from_csv_input_file(expected_file, delimiter_expected_data, quotechar_expected_data)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_data_file_with_2d_array(self, actual_file, expected_data, delimiter_actual_data=",", quotechar_actual_data='"', template_literals_dict=None):
+        self.__check_if_actual_file_is_present(actual_file)
+        self.__check_if_expected_data_is_present(expected_data)
+        #
+        actual_data = self.__get_data_from_csv_input_file(actual_file, delimiter_actual_data, quotechar_actual_data)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_data_2d_arrays(self, actual_data, expected_data, template_literals_dict=None):
+        self.__check_if_actual_data_is_present(actual_data)
+        self.__check_if_expected_data_is_present(expected_data)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_data_files(self, actual_file, expected_file, delimiter_actual_data=",", delimiter_expected_data=",", quotechar_actual_data='"', quotechar_expected_data='"', template_literals_dict=None):
+        self.__check_if_actual_file_is_present(actual_file)
+        self.__check_if_expected_file_is_present(expected_file)
+        #
+        actual_data = self.__get_data_from_csv_input_file(actual_file, delimiter_actual_data, quotechar_actual_data)
+        expected_data = self.__get_data_from_csv_input_file(expected_file, delimiter_expected_data, quotechar_expected_data)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+
+    def compare_text_variable_with_text_file(self, actual_text, expected_file, template_literals_dict=None):
+        self.__check_if_actual_data_is_present(actual_text)
+        self.__check_if_expected_file_is_present(expected_file)
+        #
+        actual_data = self.__split_text_into_textline_array(actual_text)
+        expected_data = self.__split_textfile_into_textline_array(expected_file)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_text_file_with_text_variable(self, actual_file, expected_text, template_literals_dict=None):
+        self.__check_if_actual_file_is_present(actual_file)
+        self.__check_if_expected_data_is_present(expected_text)
+        #
+        actual_data = self.__split_textfile_into_textline_array(actual_file)
+        expected_data = self.__split_text_into_textline_array(expected_text)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_text_variables(self, actual_text, expected_text, template_literals_dict=None):
+        self.__check_if_actual_data_is_present(actual_text)
+        self.__check_if_expected_data_is_present(expected_text)
+        #
+        actual_data = self.__split_text_into_textline_array(actual_text)
+        expected_data = self.__split_text_into_textline_array(expected_text)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+    def compare_text_files(self, actual_file, expected_file, template_literals_dict=None):
+        self.__check_if_actual_file_is_present(actual_file)
+        self.__check_if_expected_file_is_present(expected_file)
+        #
+        actual_data = self.__split_textfile_into_textline_array(actual_file)
+        expected_data = self.__split_textfile_into_textline_array(expected_file)
+        #
+        DataComparer.compare_data(actual_data, expected_data, template_literals_dict)
+
+
+
+    @staticmethod
+    def compare_data(actual_data, expected_data, template_literals_dict=None):
+        actual_data = DataComparer.__make_data_2d_compliant(actual_data)
+        expected_data = DataComparer.__make_data_2d_compliant(expected_data)
+        #
+        Report.show_header_and_data("Actual data", actual_data)
+        Report.show_header_and_data("Expected data", expected_data)
+        Report.show_header_differences_actual_and_expected_data()
+        #
+        Report().show_footer_comparation_result(TwoDArray(actual_data).equals(TwoDArray(expected_data), template_literals_dict))
+
+
+    @staticmethod
+    def __check_if_actual_data_is_present(data):
+        if data == None:
+            raise Exception("Actual Input data unknown.")
+
+
+    @staticmethod
+    def __check_if_expected_data_is_present(data):
+        if data == None:
+            raise Exception("Expected Input data unknown.")
+
+
+    @staticmethod
+    def __check_if_actual_file_is_present(file):
+        if os.path.exists(file):
+            print("actual_file: ", file)
+        else:
+            raise Exception("Actual Input file doesn't exists: ", file)
+
+
+    @staticmethod
+    def __check_if_expected_file_is_present(file):
+        if os.path.exists(file):
+            print("expected_file: ", file)
+        else:
+            raise Exception("Expected Input file doesn't exists: ", file)
+
+
+    @staticmethod
+    def __get_data_from_csv_input_file(input_file, delimiter_data=",", quotechar_data='"'):
+        with open(input_file, mode='rt', encoding='utf-8') as input_file:
+            if len(delimiter_data) == 1:
+                data = list(csv.reader(input_file, delimiter=delimiter_data, quotechar=quotechar_data))
+            else:
+                data = list(csv.reader((line.replace(delimiter_data, chr(255)) for line in input_file), delimiter=chr(255), quotechar=quotechar_data))
+        #
+        return data
+
+
+    @staticmethod
+    def __split_text_into_textline_array(text):
+        data = []
+        for line in text.split('\n'):
+            data.append(line.strip('\n').split(chr(255)))
+        #
+        return data
+
+
+    @staticmethod
+    def __split_textfile_into_textline_array(input_file):
+        with open(input_file, mode='rt', encoding='utf-8') as input_file:
+            data = []
+            for line in input_file.readlines():
+                data.append(line.strip('\n').split(chr(255)))
+        #
+        return data
+
+
+    @staticmethod
+    def __make_data_2d_compliant(data):
+        if data and type(data[0]) is not list:  # only a single row
+            data = [data,]  # add row to tuple of lenght 1
+        return data

datacomparerlibrary-0.846/src/DataComparerLibrary/datetimehandler.py

@@ -0,0 +1,100 @@
+import datetime
+import dateutil.relativedelta
+import re
+
+class DatetimeHandler:
+    def replace_date_template_in_expected_data(self, expected_data_field_including_date_template):
+        # Replace date_template in expected data.
+        # For example: This is text {NOW()-5Y2M1D:YYYY-MM-DD} and also text.  =>  This is text 2018-05-03 and also text.
+        position_open_brace_today_text  = expected_data_field_including_date_template.find("{NOW()")
+        position_close_brace_today_text = expected_data_field_including_date_template.find("}", position_open_brace_today_text)
+        #
+        if position_close_brace_today_text == -1:
+            return -1
+        # Close brace of TODAY has been found.
+        #
+        expected_datetime_template_string = expected_data_field_including_date_template[position_open_brace_today_text:position_close_brace_today_text + 1]
+        expected_datetime_string = DatetimeHandler.__convert_datetime_template_to_datetime(self, expected_datetime_template_string)
+        #
+        if expected_datetime_string == -1:
+            return -1
+        # Datetime_template_string has been converted to datetime.
+        #
+        # Replace expected_datetime_template_string by expected_datetime_string in expected_data_field_including_template.
+        compiled = re.compile(re.escape(expected_datetime_template_string), re.IGNORECASE)
+        expected_data_with_calculated_date = compiled.sub(expected_datetime_string, expected_data_field_including_date_template)
+        #
+        return expected_data_with_calculated_date
+
+
+    def __convert_datetime_template_to_datetime(self, expected_datetime_format):
+        # Convert expected datetime template into datetime.
+        # For example: {NOW():YYYY-MM-DD}         =>  2023-07-04
+        #              {NOW():MMDDYY}             =>  070423
+        #              {NOW()-5Y3M1D:D-MMMM-YY}   =>  3-April-18
+        #              {NOW()-5Y2M1D:YYYY-MMM-DD} =>  2018-Apr-03
+        #              {NOW()-5Y2M1D:YYYYMMDD}    =>  20180503
+        #              {NOW()-5Y2M1D:YYYY-M-D}    =>  2018-5-3
+        #              {NOW()+2D:DDMMYYYY         =>  06072023
+        #              {NOW()-5Y2M1D:YYYY-MM-DD}  =>  2018-05-03
+        template_datetime_string_splitted = expected_datetime_format.split(":")
+        #
+        match len(template_datetime_string_splitted):
+            case 2:
+                if template_datetime_string_splitted[0] == "{NOW()":
+                    # Current date time.
+                    expected_datetime = datetime.datetime.now()
+                else:
+                    # Adjust date time based on current date time.
+                    relative_datetime_template_string = template_datetime_string_splitted[0].replace('{NOW()', '')
+                    relative_datetime = DatetimeHandler.__convert_relative_datetime_template_to_relative_datetime(self, relative_datetime_template_string[1:len(relative_datetime_template_string)])
+                    if relative_datetime == -1:
+                        return -1
+                    else:
+                        match relative_datetime_template_string[0]:
+                            case "+":
+                                expected_datetime = datetime.datetime.now() + relative_datetime
+                            case "-":
+                                expected_datetime = datetime.datetime.now() - relative_datetime
+                            case _:
+                                return -1
+            case _:
+                return -1
+        #
+        year = expected_datetime.strftime("%Y")
+        year_2_digits = expected_datetime.strftime("%y")
+        month = expected_datetime.strftime("%m")
+        month_abbreviated = expected_datetime.strftime("%b")
+        month_full = expected_datetime.strftime("%B")
+        day = expected_datetime.strftime("%d")
+        #
+        expected_date = template_datetime_string_splitted[1][0:len(template_datetime_string_splitted[1]) - 1].replace("YYYY", year).replace("YY", year_2_digits).replace("MMMM", month_full).replace("MMM", month_abbreviated).replace("MM", month).replace("M", month.lstrip("0")).replace("DD", day).replace("D", day.lstrip("0"))
+        return expected_date
+
+
+    def __convert_relative_datetime_template_to_relative_datetime(self, relative_datetime_str):
+        # Convert relative datetime template to relative datetime.
+        # For example: 2Y5M1D  =>  2 years, 5 months, 1 day   (used to add to or subtract from current moment / date)
+        # \d+ means 1 of more digits; search on character - for example Y;
+        regex = re.compile(r'((?P<years>\d+?)Y)?((?P<months>\d+?)M)?((?P<days>\d+?)D)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')
+        period = regex.match(relative_datetime_str)
+
+        if not period:
+            return -1
+
+        period = period.groupdict()
+        kwargs = {}
+        period_names = ["years", "months", "days"]
+        #
+        for name, param in period.items():
+            if param:
+                period_name = name
+                period_count = param
+                #
+                if period_name in period_names:
+                    kwargs[period_name] = int(period_count)
+        #
+        if kwargs:
+            return dateutil.relativedelta.relativedelta(**kwargs)
+        else:
+            return -1    

datacomparerlibrary-0.846/src/DataComparerLibrary/field.py

@@ -0,0 +1,166 @@
+import fnmatch
+import re
+
+from DataComparerLibrary.datetimehandler import DatetimeHandler
+from DataComparerLibrary.report import Report
+from DataComparerLibrary.tools import Tools
+
+
+class Field:
+    def __init__(self, field_data, row_nr, column_nr):
+        self.field_data = field_data
+        self.row_nr = row_nr
+        self.column_nr = column_nr
+
+
+    def equals(self, other_field_including_templates_and_literals, template_literals_dict):
+        equal = True
+
+        expected_data_including_date_template = None
+        expected_data_with_wildcard = None
+        skip_exception_rule_used = False
+
+        # Replace literal templates with fixed external strings.
+        other_field_data_including_templates = self.__replace_template_literals_dict(other_field_including_templates_and_literals.field_data, template_literals_dict)
+
+        if self.field_data == other_field_data_including_templates:
+            return True
+
+        # Verify if difference is a matter of string versus integer representation.
+        if Field.__is_same_value_but_different_types(self, other_field_data_including_templates):
+            return False
+
+        # If data in actual and expected field doesn't match, check if a template has been used in expected data.
+        match other_field_data_including_templates.upper():
+            case "{PRESENT}":
+                if not self.field_data:
+                    # No data is present in actual data field.
+                    equal = False
+                    Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "Actual data field is not PRESENT")
+            #
+            case "{EMPTY}":
+                if self.field_data:
+                    # Actual data field is not empty.
+                    equal = False
+                    Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "Actual data field is not EMPTY")
+            #
+            case "{INTEGER}":
+                if isinstance(self.field_data, int):
+                    # A real integer.
+                    return True
+                #
+                # Verify if string is integer.
+                if not self.field_data.isdigit():
+                    # Not positive integer field.
+                    equal = False
+                    Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "Actual data field is not INTEGER.")
+            #
+            case "{SKIP}":
+                pass
+            case _:
+                if "{SKIP}" in other_field_data_including_templates.upper() or "{DATETIME_FORMAT():YYYYMMDDHHMMSSFF6}" in other_field_data_including_templates.upper():
+                    if other_field_data_including_templates.upper() == "{SKIP}":
+                        # Complete actual data field will be skipped for verification.
+                        pass
+                    else:
+                        # Part(s) of the actual data field will be skipped for verification.
+                        # Replace {SKIP}, ignoring cases, by wildcard *.
+                        # compiled = re.compile(re.escape("{SKIP}"), re.IGNORECASE)
+                        # expected_data_with_wildcard = compiled.sub("*", other_field_data_including_templates)
+                        compiled = re.compile(re.escape("{SKIP}"), re.IGNORECASE)
+                        compiled2 = re.compile(re.escape("{DATETIME_FORMAT():YYYYMMDDHHMMSSFF6}"), re.IGNORECASE)
+                        expected_data_with_wildcard = compiled2.sub("*", compiled.sub("*", other_field_data_including_templates))
+                        #
+                        if fnmatch.fnmatch(self.field_data, expected_data_with_wildcard):
+                            skip_exception_rule_used = True
+                           # continue
+                #
+                if expected_data_with_wildcard == None:
+                    # Wildcards not used.
+                    expected_data_including_date_template = other_field_data_including_templates
+                else:
+                    expected_data_including_date_template = expected_data_with_wildcard
+                #
+                if "{NOW()" in other_field_data_including_templates.upper():
+                    matches = ["{NOW():", "{NOW()+", "{NOW()-"]
+                    if all([x not in other_field_data_including_templates.upper() for x in matches]):
+                        equal = False
+                        Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "NOW() has been found in expected data field, but format is incorrect.")
+                        #continue
+                    #
+                    expected_data = DatetimeHandler.replace_date_template_in_expected_data(self, expected_data_including_date_template)
+                    #
+                    if expected_data == -1:
+                        equal = False
+                        Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "NOW() has been found in expected data field, but format is incorrect.")
+                    else:
+                        if not fnmatch.fnmatch(self.field_data, expected_data):
+                            # No match despite using of wildcard(s).
+                            equal = False
+                            Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "Date template format displayed. See also next message line.")
+                            Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, expected_data, "There is a difference between actual and expected data.")
+                    # continue
+                    #
+                elif "{NOT(" in other_field_data_including_templates.upper():
+                    try:
+                        unwanted_expected_data = Field.__get_unwanted_expected_data(expected_data_including_date_template)
+                        #
+                        if self.field_data == unwanted_expected_data:
+                            # Unwanted match.
+                            equal = False
+                            Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "NOT() template format displayed. See also next message line.")
+                            Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, unwanted_expected_data, "Actual and expected data are equal. However actual data should NOT be equal to the expected data!!!")
+                    except Exception as exception_message:
+                        # print(f"An exception occurred: {exception_message}")
+                        equal = False
+                        Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "NOT() has been found in expected data field, but format is incorrect.")
+                    #
+                else:
+                    if not skip_exception_rule_used:
+                        # No exceptions.
+                        equal = False
+                        Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data_including_templates, "There is a difference between actual and expected data. No exception rule has been used.")
+                #
+        return equal
+
+
+    @staticmethod
+    def __replace_template_literals_dict(data, template_literals_dict):
+        if template_literals_dict:
+            for i in range(0, len(template_literals_dict)):
+                data = data.replace(list(template_literals_dict.keys())[i], list(template_literals_dict.values())[i])
+        return data
+
+
+    def __is_same_value_but_different_types(self, other_field_data):
+        # Verify if difference is a matter of string versus integer representation.
+        if str(self.field_data) == str(other_field_data):
+            if isinstance(self.field_data, int) and isinstance(other_field_data, str):
+                Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data, "There is a difference between actual and expected data. Actual data is an integer while expected data is a string.")
+                return True
+            elif isinstance(self.field_data, str) and isinstance(other_field_data, int):
+                Report.show_differences_comparation_result(self.row_nr, self.column_nr, self.field_data, other_field_data, "There is a difference between actual and expected data. Actual data is a string while expected data is an integer.")
+                return True
+        return False
+
+
+    @staticmethod
+    def __get_unwanted_expected_data(expected_data_field_including_date_template):
+        position_open_brace = expected_data_field_including_date_template.find("{NOT(")
+        position_close_brace = expected_data_field_including_date_template.find(")}", position_open_brace)
+        #
+        if position_open_brace == -1:
+            #print("position_open_brace:", position_open_brace)
+            raise Exception()
+        #
+        if position_close_brace == -1:
+            #print("position_close_brace:", position_close_brace)
+            raise Exception()
+        #
+        unwanted_expected_data = expected_data_field_including_date_template[position_open_brace+5:position_close_brace]
+        #
+        if Tools.is_integer(unwanted_expected_data):
+            unwanted_expected_data = int(unwanted_expected_data)
+        return unwanted_expected_data
+
+

datacomparerlibrary-0.846/src/DataComparerLibrary/report.py

@@ -0,0 +1,50 @@
+class Report:
+    @staticmethod
+    def show_header_and_data(header, data):
+        Report.show_2d_array(header, data, 20)
+
+
+    @staticmethod
+    def show_header_differences_actual_and_expected_data():
+        print()
+        print("=== Overview differences between actual and expected data")
+        print()
+
+
+#show_difference_between_actual_and_expected_data
+    @staticmethod
+    def show_differences_comparation_result(row_number, column_number, actual_data, expected_data, error_message):
+        print("Row: ", row_number + 1, "  Column: ", column_number + 1, "  =>  Actual data: ", actual_data, "    Expected data: ", expected_data, "    Remark / Error message: ", error_message)
+
+
+    @staticmethod
+    def show_footer_comparation_result(equal):
+        if equal:
+            print("\n\n\n")
+            print("There are no differences between actual and expected data found.")
+            print("\n\n\n")
+        else:
+            print("\n\n\n")
+            raise Exception("There is a difference between actual and expected data. See detail information.")
+
+
+
+    @staticmethod
+    def show_2d_array(title, reader_file_list, column_width):
+        max_length_title = 30
+        title = title[0:(max_length_title - 1)]
+        length_title = len(title)
+        print("=== ", title, " ", end="")
+        print("=" * (max_length_title - length_title))
+        print()
+        #
+        for row in reader_file_list:
+            for cell_value in row:
+                #if isinstance(cell_value, str):
+                if isinstance(cell_value, str) or isinstance(cell_value, int):
+                    #print('{val:{fill}{width}}'.format(val=cell_value, fill='', width=column_width), end="  ")
+                    print('{val:{fill}{width}}'.format(val=cell_value, fill='', width=column_width, left_aligned=True), end="  ")
+
+            print()
+        print()
+        print()

datacomparerlibrary-0.846/src/DataComparerLibrary/row.py

@@ -0,0 +1,32 @@
+from DataComparerLibrary.field import Field
+from DataComparerLibrary.report import Report
+
+
+class Row:
+    def __init__(self, row_data, row_nr):
+        self.row_data = row_data
+        self.row_nr = row_nr
+        #
+        self.number_of_columns = len(row_data)
+
+
+    def equals(self, other_row, template_literals_dict):
+        equal = True
+        #
+        max_number_of_columns = max(self.number_of_columns, other_row.number_of_columns)
+        #
+        for column_nr in range(max_number_of_columns):
+            if column_nr >= self.number_of_columns:
+                equal = False
+                Report.show_differences_comparation_result(self.row_nr, column_nr, "", other_row.row_data[column_nr], "Column actual data is not PRESENT.")
+                continue
+            #
+            if column_nr >= other_row.number_of_columns:
+                equal = False
+                Report.show_differences_comparation_result(self.row_nr, column_nr, self.row_data[column_nr], "", "Column expected data is not PRESENT.")
+                continue
+            #
+            if not Field(self.row_data[column_nr], self.row_nr, column_nr).equals(Field(other_row.row_data[column_nr], self.row_nr, column_nr), template_literals_dict):
+                equal = False
+            #
+        return equal

{datacomparerlibrary-0.844 → datacomparerlibrary-0.846}/src/DataComparerLibrary/tools.py

@@ -1,5 +1,6 @@
 class Tools:
-    def is_integer(self, string):
+    @staticmethod
+    def is_integer(string):
         if string[0] == '-':
             # if a negative number
             return string[1:].isdigit()

datacomparerlibrary-0.846/src/DataComparerLibrary/twodarray.py

@@ -0,0 +1,36 @@
+from DataComparerLibrary.row import Row
+from DataComparerLibrary.report import Report
+
+
+class TwoDArray:
+    def __init__(self, two_d_array_data):
+        self.two_d_array_data = two_d_array_data
+        self.number_of_rows = len(two_d_array_data)
+
+
+    def equals(self, other_two_d_array, template_literals_dict):
+        equal = True
+        #
+        max_number_of_rows = max(self.number_of_rows, other_two_d_array.number_of_rows)
+        #
+        for row_nr in range(max_number_of_rows):
+            if row_nr >= self.number_of_rows:
+                equal = False
+                if len(other_two_d_array.two_d_array_data[row_nr]) == 0:
+                    Report.show_differences_comparation_result(row_nr, 0, "", "", "Row actual data is not PRESENT. Row expected data is EMPTY.")
+                else:
+                    Report.show_differences_comparation_result(row_nr, 0, "", other_two_d_array.two_d_array_data[row_nr][0], "Row actual data is not PRESENT.")
+                continue
+            #
+            if row_nr >= other_two_d_array.number_of_rows:
+                equal = False
+                if len(self.two_d_array_data[row_nr]) == 0:
+                    Report.show_differences_comparation_result(row_nr, 0, "", "", "Row actual data is EMPTY. Row expected data is not PRESENT.")
+                else:
+                    Report.show_differences_comparation_result(row_nr, 0, self.two_d_array_data[row_nr][0], "", "Row expected data is not PRESENT.")
+                continue
+            #
+            if not Row(self.two_d_array_data[row_nr], row_nr).equals(Row(other_two_d_array.two_d_array_data[row_nr], row_nr), template_literals_dict):
+                equal = False
+            #
+        return equal

datacomparerlibrary-0.846/src/DataComparerLibrary/version.py

@@ -0,0 +1,3 @@
+# encoding=utf-8
+
+VERSION = '0.846'

{datacomparerlibrary-0.844 → datacomparerlibrary-0.846}/src/DataComparerLibrary.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: DataComparerLibrary
-Version: 0.844
+Version: 0.846
 Summary: For comparing csv-files, 2d-array with a csv-file or 2d-arrays. For comparing text-files, text variable with a text-file or text variables. Including a sorting module.
 Home-page: 
 Author: René Philip Zuijderduijn
@@ -10,7 +10,6 @@ Keywords: robotframework testing test-automation datacompare
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: Microsoft :: Windows :: Windows 10
 Classifier: Operating System :: Microsoft :: Windows :: Windows 11
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -19,6 +18,15 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
 
 ===================
 DataComparerLibrary

{datacomparerlibrary-0.844 → datacomparerlibrary-0.846}/src/DataComparerLibrary.egg-info/SOURCES.txt

@@ -3,16 +3,18 @@ README.rst
 pyproject.toml
 setup.py
 src/DataComparerLibrary/__init__.py
-src/DataComparerLibrary/arraycomparer.py
 src/DataComparerLibrary/datacomparer.py
 src/DataComparerLibrary/datasorter.py
+src/DataComparerLibrary/datetimehandler.py
 src/DataComparerLibrary/delimitertranslator.py
+src/DataComparerLibrary/field.py
 src/DataComparerLibrary/fileconverter.py
 src/DataComparerLibrary/report.py
+src/DataComparerLibrary/row.py
 src/DataComparerLibrary/tools.py
+src/DataComparerLibrary/twodarray.py
 src/DataComparerLibrary/version.py
 src/DataComparerLibrary.egg-info/PKG-INFO
 src/DataComparerLibrary.egg-info/SOURCES.txt
 src/DataComparerLibrary.egg-info/dependency_links.txt
-src/DataComparerLibrary.egg-info/top_level.txt
-test/test1.py
+src/DataComparerLibrary.egg-info/top_level.txt

datacomparerlibrary-0.844/src/DataComparerLibrary/arraycomparer.py

@@ -1,314 +0,0 @@
-import datetime
-import fnmatch
-import re
-import dateutil.relativedelta
-
-from DataComparerLibrary.report import Report
-
-class ArrayComparer:
-    def compare_data(self, actual_data, expected_data_including_templates, template_literals_dict):
-        difference_found = False
-        #
-        if actual_data and type(actual_data[0]) is not list:  # only a single row
-            actual_data = [actual_data,]  # add row to tuple of lenght 1
-        #
-        if expected_data_including_templates and type(expected_data_including_templates[0]) is not list:  # only a single row
-            expected_data_including_templates = [expected_data_including_templates,]  # add row to tuple of lenght 1
-
-        number_of_rows_actual_data = len(actual_data)
-        number_of_rows_expected_data = len(expected_data_including_templates)
-
-        number_of_rows = number_of_rows_actual_data if (number_of_rows_actual_data >= number_of_rows_expected_data) else number_of_rows_expected_data
-
-        Report.show_2d_array(self, "Actual data", actual_data, 20)
-        Report.show_2d_array(self, "Expected data", expected_data_including_templates, 20)
-
-        print()
-        print("=== Overview differences between actual and expected data")
-        print()
-
-        for row_nr in range(number_of_rows):
-            if row_nr >= number_of_rows_actual_data:
-                difference_found = True
-                if len(expected_data_including_templates[row_nr]) == 0:
-                    Report.show_comparation_result(self, row_nr, 0, "", "", "Row actual data is not PRESENT. Row expected data is EMPTY.")
-                else:
-                    Report.show_comparation_result(self, row_nr, 0, "", expected_data_including_templates[row_nr][0], "Row actual data is not PRESENT.")
-                continue
-            #
-            if row_nr >= number_of_rows_expected_data:
-                difference_found = True
-                if len(actual_data[row_nr]) == 0:
-                    Report.show_comparation_result(self, row_nr, 0, "", "", "Row actual data is EMPTY. Row expected data is not PRESENT.")
-                else:
-                    Report.show_comparation_result(self, row_nr, 0, actual_data[row_nr][0], "", "Row expected data is not PRESENT.")
-                continue
-            #
-            number_of_columns_actual_data   = len(actual_data[row_nr])
-            number_of_columns_expected_data = len(expected_data_including_templates[row_nr])
-
-            number_of_columns = number_of_columns_actual_data if (number_of_columns_actual_data >= number_of_columns_expected_data) else number_of_columns_expected_data
-
-            for column_nr in range(number_of_columns):
-                expected_data_including_date_template = None
-                expected_data_with_wildcard = None
-                skip_exception_rule_used = False
-                #
-                if column_nr >= number_of_columns_actual_data:
-                    difference_found = True
-                    Report.show_comparation_result(self, row_nr, column_nr, "", expected_data_including_templates[row_nr][column_nr], "Column actual data is not PRESENT.")
-                    continue
-                #
-                if column_nr >= number_of_columns_expected_data:
-                    difference_found = True
-                    Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], "", "Column expected data is not PRESENT.")
-                    continue
-                #
-                if actual_data[row_nr][column_nr] != expected_data_including_templates[row_nr][column_nr]:
-                    # Replace literal templates with fixed external strings.
-                    if template_literals_dict:
-                        for i in range(0, len(template_literals_dict)):
-#                           key = list(template_literals_dict.keys())[i]
-#                           value = list(template_literals_dict.values())[i]
-#                           print("key: ", key)
-#                           print("value: ", value)
-                            expected_data_including_templates[row_nr][column_nr] = expected_data_including_templates[row_nr][column_nr].replace(list(template_literals_dict.keys())[i], list(template_literals_dict.values())[i])
-#                           print("actual_data[row_nr][column_nr]: \n", actual_data[row_nr][column_nr])
-#                           print("expected_data_including_templates[row_nr][column_nr]: \n", expected_data_including_templates[row_nr][column_nr])
-
-
-                    # Verify if difference is a matter of string versus integer representation.
-                    if str(actual_data[row_nr][column_nr]) == str(expected_data_including_templates[row_nr][column_nr]):
-                        if isinstance(actual_data[row_nr][column_nr], int) and isinstance(expected_data_including_templates[row_nr][column_nr], str):
-                            difference_found = True
-                            Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "There is a difference between actual and expected data. Actual data is an integer while expected data is a string.")
-                        elif isinstance(actual_data[row_nr][column_nr], str) and isinstance(expected_data_including_templates[row_nr][column_nr], int):
-                            difference_found = True
-                            Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "There is a difference between actual and expected data. Actual data is a string while expected data is an integer.")
-                        continue
-                    #
-                    # If data in actual and expected field doesn't match, check if a template has been used in expected data.
-                    match expected_data_including_templates[row_nr][column_nr].upper():
-                        case "{PRESENT}":
-                            if not actual_data[row_nr][column_nr]:
-                                # No data is present in actual data field.
-                                difference_found = True
-                                Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "Actual data field is not PRESENT")
-                        #
-                        case "{EMPTY}":
-                            if actual_data[row_nr][column_nr]:
-                                # Actual data field is not empty.
-                                difference_found = True
-                                Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "Actual data field is not EMPTY")
-                        #
-                        case "{INTEGER}":
-                            if isinstance(actual_data[row_nr][column_nr], int):
-                                # A real integer.
-                                continue
-                            #
-                            # Verify if string is integer.
-                            if not actual_data[row_nr][column_nr].isdigit():
-                                # Not positive integer field.
-                                difference_found = True
-                                Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "Actual data field is not INTEGER.")
-                        #
-                        case "{SKIP}":
-                            pass
-                        case _:
-                            if "{SKIP}" in expected_data_including_templates[row_nr][column_nr].upper() or "{DATETIME_FORMAT():YYYYMMDDHHMMSSFF6}" in expected_data_including_templates[row_nr][column_nr].upper():
-                                if expected_data_including_templates[row_nr][column_nr].upper() == "{SKIP}":
-                                    # Complete actual data field will be skipped for verification.
-                                    pass
-                                else:
-                                    # Part(s) of the actual data field will be skipped for verification.
-                                    # Replace {SKIP}, ignoring cases, by wildcard *.
-                                    # compiled = re.compile(re.escape("{SKIP}"), re.IGNORECASE)
-                                    # expected_data_with_wildcard = compiled.sub("*", expected_data_including_templates[row_nr][column_nr])
-                                    compiled = re.compile(re.escape("{SKIP}"), re.IGNORECASE)
-                                    compiled2 = re.compile(re.escape("{DATETIME_FORMAT():YYYYMMDDHHMMSSFF6}"), re.IGNORECASE)
-                                    expected_data_with_wildcard = compiled2.sub("*", compiled.sub("*", expected_data_including_templates[row_nr][column_nr]))
-                                    #
-                                    if fnmatch.fnmatch(actual_data[row_nr][column_nr], expected_data_with_wildcard):
-                                        skip_exception_rule_used = True
-                                        continue
-                            #
-                            if expected_data_with_wildcard is None:
-                                # Wildcards not used.
-                                expected_data_including_date_template = expected_data_including_templates[row_nr][column_nr]
-                            else:
-                                expected_data_including_date_template = expected_data_with_wildcard
-                            #
-                            if "{NOW()" in expected_data_including_templates[row_nr][column_nr].upper():
-                                matches = ["{NOW():", "{NOW()+", "{NOW()-"]
-                                if all([x not in expected_data_including_templates[row_nr][column_nr].upper() for x in matches]):
-                                    difference_found = True
-                                    Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "NOW() has been found in expected data field, but format is incorrect.")
-                                    continue
-                                #
-                                expected_data = ArrayComparer.__replace_date_template_in_expected_data(self, expected_data_including_date_template)
-                                #
-                                if expected_data == -1:
-                                    difference_found = True
-                                    Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "NOW() has been found in expected data field, but format is incorrect.")
-                                else:
-                                    if not fnmatch.fnmatch(actual_data[row_nr][column_nr], expected_data):
-                                        # No match despite using of wildcard(s).
-                                        difference_found = True
-                                        Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "Date template format displayed. See also next message line.")
-                                        Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data, "There is a difference between actual and expected data.")
-                                continue
-                                #
-                            elif "{NOT(" in expected_data_including_templates[row_nr][column_nr].upper():
-                                try:
-                                    unwanted_expected_data = ArrayComparer.__get_unwanted_expected_data(self, expected_data_including_date_template)
-                                    #
-                                    if actual_data[row_nr][column_nr] == unwanted_expected_data:
-                                        # Unwanted match.
-                                        difference_found = True
-                                        Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "NOT() template format displayed. See also next message line.")
-                                        Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], unwanted_expected_data, "Actual and expected data are equal. However actual data should NOT be equal to the expected data!!!")
-                                except Exception as exception_message:
-                                    # print(f"An exception occurred: {exception_message}")
-                                    difference_found = True
-                                    Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "NOT() has been found in expected data field, but format is incorrect.")
-                                #
-                            else:
-                                if not skip_exception_rule_used:
-                                    # No exceptions.
-                                    difference_found = True
-                                    Report.show_comparation_result(self, row_nr, column_nr, actual_data[row_nr][column_nr], expected_data_including_templates[row_nr][column_nr], "There is a difference between actual and expected data. No exception rule has been used.")
-                            #
-        if difference_found:
-            print("\n\n\n")
-            raise Exception("There is a difference between actual and expected data. See detail information.")
-        else:
-            print("There are no differences between actual and expected data found.")
-            print("\n\n\n")
-
-
-    def __replace_date_template_in_expected_data(self, expected_data_field_including_date_template):
-        # Replace date_template in expected data.
-        # For example: This is text {NOW()-5Y2M1D:YYYY-MM-DD} and also text.  =>  This is text 2018-05-03 and also text.
-        position_open_brace_today_text  = expected_data_field_including_date_template.find("{NOW()")
-        position_close_brace_today_text = expected_data_field_including_date_template.find("}", position_open_brace_today_text)
-        #
-        if position_close_brace_today_text == -1:
-            return -1
-        # Close brace of TODAY has been found.
-        #
-        expected_datetime_template_string = expected_data_field_including_date_template[position_open_brace_today_text:position_close_brace_today_text + 1]
-        expected_datetime_string = ArrayComparer.__convert_datetime_template_to_datetime(self, expected_datetime_template_string)
-        #
-        if expected_datetime_string == -1:
-            return -1
-        # Datetime_template_string has been converted to datetime.
-        #
-        # Replace expected_datetime_template_string by expected_datetime_string in expected_data_field_including_template.
-        compiled = re.compile(re.escape(expected_datetime_template_string), re.IGNORECASE)
-        expected_data_with_calculated_date = compiled.sub(expected_datetime_string, expected_data_field_including_date_template)
-        #
-        return expected_data_with_calculated_date
-
-
-    def __convert_datetime_template_to_datetime(self, expected_datetime_format):
-        # Convert expected datetime template into datetime.
-        # For example: {NOW():YYYY-MM-DD}         =>  2023-07-04
-        #              {NOW():MMDDYY}             =>  070423
-        #              {NOW()-5Y3M1D:D-MMMM-YY}   =>  3-April-18
-        #              {NOW()-5Y2M1D:YYYY-MMM-DD} =>  2018-Apr-03
-        #              {NOW()-5Y2M1D:YYYYMMDD}    =>  20180503
-        #              {NOW()-5Y2M1D:YYYY-M-D}    =>  2018-5-3
-        #              {NOW()+2D:DDMMYYYY         =>  06072023
-        #              {NOW()-5Y2M1D:YYYY-MM-DD}  =>  2018-05-03
-        template_datetime_string_splitted = expected_datetime_format.split(":")
-        #
-        match len(template_datetime_string_splitted):
-            case 2:
-                if template_datetime_string_splitted[0] == "{NOW()":
-                    # Current date time.
-                    expected_datetime = datetime.datetime.now()
-                else:
-                    # Adjust date time based on current date time.
-                    relative_datetime_template_string = template_datetime_string_splitted[0].replace('{NOW()', '')
-                    relative_datetime = ArrayComparer.__convert_relative_datetime_template_to_relative_datetime(self, relative_datetime_template_string[1:len(relative_datetime_template_string)])
-                    if relative_datetime == -1:
-                        return -1
-                    else:
-                        match relative_datetime_template_string[0]:
-                            case "+":
-                                expected_datetime = datetime.datetime.now() + relative_datetime
-                            case "-":
-                                expected_datetime = datetime.datetime.now() - relative_datetime
-                            case _:
-                                return -1
-            case _:
-                return -1
-        #
-        year = expected_datetime.strftime("%Y")
-        year_2_digits = expected_datetime.strftime("%y")
-        month = expected_datetime.strftime("%m")
-        month_abbreviated = expected_datetime.strftime("%b")
-        month_full = expected_datetime.strftime("%B")
-        day = expected_datetime.strftime("%d")
-        #
-        expected_date = template_datetime_string_splitted[1][0:len(template_datetime_string_splitted[1]) - 1].replace("YYYY", year).replace("YY", year_2_digits).replace("MMMM", month_full).replace("MMM", month_abbreviated).replace("MM", month).replace("M", month.lstrip("0")).replace("DD", day).replace("D", day.lstrip("0"))
-        return expected_date
-
-
-    def __convert_relative_datetime_template_to_relative_datetime(self, relative_datetime_str):
-        # Convert relative datetime template to relative datetime.
-        # For example: 2Y5M1D  =>  2 years, 5 months, 1 day   (used to add to or subtract from current moment / date)
-        # \d+ means 1 of more digits; search on character - for example Y;
-        regex = re.compile(r'((?P<years>\d+?)Y)?((?P<months>\d+?)M)?((?P<days>\d+?)D)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')
-        period = regex.match(relative_datetime_str)
-
-        if not period:
-            return -1
-
-        period = period.groupdict()
-        kwargs = {}
-        period_names = ["years", "months", "days"]
-        #
-        for name, param in period.items():
-            if param:
-                period_name = name
-                period_count = param
-                #
-                if period_name in period_names:
-                    kwargs[period_name] = int(period_count)
-        #
-        if kwargs:
-            return dateutil.relativedelta.relativedelta(**kwargs)
-        else:
-            return -1
-
-
-
-    def __get_unwanted_expected_data(self, expected_data_field_including_date_template):
-        position_open_brace = expected_data_field_including_date_template.find("{NOT(")
-        position_close_brace = expected_data_field_including_date_template.find(")}", position_open_brace)
-        #
-        if position_open_brace == -1:
-            #print("position_open_brace:", position_open_brace)
-            raise Exception()
-        #
-        if position_close_brace == -1:
-            #print("position_close_brace:", position_close_brace)
-            raise Exception()
-        #
-        unwanted_expected_data = expected_data_field_including_date_template[position_open_brace+5:position_close_brace]
-        #
-        if ArrayComparer.is_integer(self, unwanted_expected_data):
-            unwanted_expected_data = int(unwanted_expected_data)
-        return unwanted_expected_data
-
-
-
-    def is_integer(self, string):
-        if string[0] == '-':
-            # if a negative number
-            return string[1:].isdigit()
-        else:
-            return string.isdigit()
-
-

datacomparerlibrary-0.844/src/DataComparerLibrary/datacomparer.py

@@ -1,135 +0,0 @@
-# Script for comparing csv-files, 2d-array with a csv-file or 2d-arrays and for comparing text-files, text variable with a text-file or text variables.
-#
-import csv
-import os
-
-from DataComparerLibrary.arraycomparer import ArrayComparer
-
-
-class DataComparer:
-    def compare_data_2d_array_with_file(self, actual_data, expected_file, delimiter_expected_data=",", quotechar_expected_data='"', template_literals_dict=None):
-        self.__check_if_actual_data_is_present(actual_data)
-        self.__check_if_expected_file_is_present(expected_file)        
-        #
-        expected_data = self.__open_csv_input_file(expected_file, delimiter_expected_data, quotechar_expected_data)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_data_file_with_2d_array(self, actual_file, expected_data, delimiter_actual_data=",", quotechar_actual_data='"', template_literals_dict=None):
-        self.__check_if_actual_file_is_present(actual_file)      
-        self.__check_if_expected_data_is_present(expected_data)
-        #
-        actual_data = self.__open_csv_input_file(actual_file, delimiter_actual_data, quotechar_actual_data)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_data_2d_arrays(self, actual_data, expected_data, template_literals_dict=None):
-        self.__check_if_actual_data_is_present(actual_data)
-        self.__check_if_expected_data_is_present(expected_data) 
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_data_files(self, actual_file, expected_file, delimiter_actual_data=",", delimiter_expected_data=",", quotechar_actual_data='"', quotechar_expected_data='"', template_literals_dict=None):
-        self.__check_if_actual_file_is_present(actual_file) 
-        self.__check_if_expected_file_is_present(expected_file)            
-        #
-        actual_data = self.__open_csv_input_file(actual_file, delimiter_actual_data, quotechar_actual_data)
-        expected_data = self.__open_csv_input_file(expected_file, delimiter_expected_data, quotechar_expected_data)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_text_variable_with_text_file(self, actual_text, expected_file, template_literals_dict=None):
-        self.__check_if_actual_data_is_present(actual_text)
-        self.__check_if_expected_file_is_present(expected_file)        
-        #
-        actual_data = self.__split_text_into_textline_array(actual_text)
-        expected_data = self.__split_textfile_into_textline_array(expected_file)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_text_file_with_text_variable(self, actual_file, expected_text, template_literals_dict=None):
-        self.__check_if_actual_file_is_present(actual_file)      
-        self.__check_if_expected_data_is_present(expected_text)
-        #
-        actual_data = self.__split_textfile_into_textline_array(actual_file)
-        expected_data = self.__split_text_into_textline_array(expected_text)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_text_variables(self, actual_text, expected_text, template_literals_dict=None):
-        self.__check_if_actual_data_is_present(actual_text)
-        self.__check_if_expected_data_is_present(expected_text) 
-        #
-        actual_data = self.__split_text_into_textline_array(actual_text)
-        expected_data = self.__split_text_into_textline_array(expected_text)        
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-    def compare_text_files(self, actual_file, expected_file, template_literals_dict=None):
-        self.__check_if_actual_file_is_present(actual_file) 
-        self.__check_if_expected_file_is_present(expected_file)            
-        #
-        actual_data = self.__split_textfile_into_textline_array(actual_file)        
-        expected_data = self.__split_textfile_into_textline_array(expected_file)
-        #
-        ArrayComparer.compare_data(self, actual_data, expected_data, template_literals_dict)
-
-
-
-    def __check_if_actual_data_is_present(self, data):
-        if data == None:
-            raise Exception("Actual Input data unknown.")        
-
-
-    def __check_if_expected_data_is_present(self, data):
-        if data == None:
-            raise Exception("Expected Input data unknown.")        
-
-
-    def __check_if_actual_file_is_present(self, file):
-        if os.path.exists(file):
-            print("actual_file: ", file)
-        else:
-            raise Exception("Actual Input file doesn't exists: ", file)
-
-
-    def __check_if_expected_file_is_present(self, file):
-        if os.path.exists(file):
-            print("expected_file: ", file)    
-        else:
-            raise Exception("Expected Input file doesn't exists: ", file)  
-        
-
-    def __open_csv_input_file(self, input_file, delimiter_data=",", quotechar_data='"'):
-        with open(input_file, mode='rt', encoding='utf-8') as input_file:
-            if len(delimiter_data) == 1:
-                data = list(csv.reader(input_file, delimiter=delimiter_data, quotechar=quotechar_data))
-            else:
-                data = list(csv.reader((line.replace(delimiter_data, chr(255)) for line in input_file), delimiter=chr(255), quotechar=quotechar_data))
-        #
-        return data        
-    
-
-    def __split_text_into_textline_array(self, text):
-        data = []
-        for line in text.split('\n'):
-            data.append(line.strip('\n').split(chr(255)))
-        #
-        return data
-    
-
-    def __split_textfile_into_textline_array(self, input_file):
-        with open(input_file, mode='rt', encoding='utf-8') as input_file:
-            data = []
-            for line in input_file.readlines():
-                data.append(line.strip('\n').split(chr(255)))
-        #
-        return data
-    

datacomparerlibrary-0.844/src/DataComparerLibrary/report.py

@@ -1,23 +0,0 @@
-class Report:
-    def show_2d_array(self, title, reader_file_list, column_width):
-        max_length_title = 30
-        title = title[0:(max_length_title - 1)]
-        length_title = len(title)
-        print("=== ", title, " ", end="")
-        print("=" * (max_length_title - length_title))
-        print()
-        #
-        for row in reader_file_list:
-            for cell_value in row:
-                #if isinstance(cell_value, str):
-                if isinstance(cell_value, str) or isinstance(cell_value, int):
-                    #print('{val:{fill}{width}}'.format(val=cell_value, fill='', width=column_width), end="  ")
-                    print('{val:{fill}{width}}'.format(val=cell_value, fill='', width=column_width, left_aligned=True), end="  ")
-
-            print()
-        print()
-        print()
-
-
-    def show_comparation_result(self, row_number, column_number, actual_data, expected_data, error_message):
-        print("Row: ", row_number + 1, "  Column: ", column_number + 1, "  =>  Actual data: ", actual_data, "    Expected data: ", expected_data, "    Remark / Error message: ", error_message)

datacomparerlibrary-0.844/src/DataComparerLibrary/version.py

@@ -1,3 +0,0 @@
-# encoding=utf-8
-
-VERSION = '0.844'

datacomparerlibrary-0.844/test/test1.py

@@ -1,21 +0,0 @@
-from DataComparerLibrary import DataComparer
-
-# Input files
-actual_file   = "C:\\Users\\USER\\Documents\\Tool projecten\\Robot Framework Verzamelmap\\RobotDemo-master-Probeersel\\data_vergelijker\\actueel_resultaat\\actual.csv"
-expected_file = "C:\\Users\\USER\\Documents\\Tool projecten\\Robot Framework Verzamelmap\\RobotDemo-master-Probeersel\\data_vergelijker\\verwacht_resultaat\\expected_equal.csv"
-
-
-a = DataComparer()
-a.compare_data_files(actual_file, expected_file, delimiter_actual_data=';', delimiter_expected_data=';')
-a.compare_data_files(actual_file, expected_file, delimiter_actual_data=';', delimiter_expected_data=';', quotechar_actual_data=None, quotechar_expected_data=None)
-a.compare_data_files(actual_file, expected_file)
-actual_data_input = [['3', '1.1', '4', '7', '2023-05-27 12:00'],
-                     ['1', '0', '2', '9', '2023-05-29 12:00'],
-                     ['', '2', '0', '1', '5'],
-                     ['5.1', '8', '1', '0', '3'],
-                     ['3', '', '2023-06-19', '3', '2023-06-08']]
-
-a.compare_data_files(actual_data_input, expected_file)
-
-a.compare_data_files(actual_file, expected_file)
-