pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/DataTypes/TypePromotion.py

@@ -0,0 +1,195 @@
+import warnings
+
+from py_dpm.DataTypes.ScalarTypes import Boolean, Date, Duration, Integer, Item, Mixed, Null, Number, \
+    ScalarType, String, Subcategory, TimeInterval, TimePeriod
+from py_dpm.Exceptions.exceptions import SemanticError
+
+implicit_type_promotion_dict = {
+    String: {String},
+    Number: {String, Number},
+    Integer: {String, Number, Integer},
+    TimeInterval: {String, TimeInterval},
+    Date: {String, TimeInterval, Date},
+    TimePeriod: {String, TimeInterval, TimePeriod},
+    Duration: {String, Duration},
+    Boolean: {String, Boolean},
+    Item: {String, Item},
+    Subcategory: {String, Subcategory},
+    Null: {String, Number, Integer, TimeInterval, Date, TimePeriod, Duration, Boolean, Item, Subcategory, Null}
+}
+
+
+def binary_implicit_type_promotion(
+        left: ScalarType, right: ScalarType, op_type_to_check: ScalarType = None, return_type: ScalarType = None,
+        interval_allowed: bool = True, error_info: dict = None):
+    """
+    """
+    left_implicities = implicit_type_promotion_dict[left.__class__]
+    right_implicities = implicit_type_promotion_dict[right.__class__]
+
+    if left and right:
+        warning_raising = not (isinstance(left, type(right)) or isinstance(right, type(left)))
+    else:
+        warning_raising = False
+
+    if op_type_to_check:
+
+        if op_type_to_check.is_included(
+                left_implicities.intersection(right_implicities)):  # general case and date->str and boolean-> str in the str operator
+
+            if warning_raising:
+                warnings.warn(
+                    f"Implicit promotion between {left} and {right} and op_type={op_type_to_check}.")
+            if return_type:
+                binary_check_interval(result_operand=return_type, left_operand=left, right_operand=right, op_type_to_check=op_type_to_check,
+                                      return_type=return_type, interval_allowed=interval_allowed, error_info=error_info)
+                return return_type
+
+            if not left.is_null_type() and left.is_included(right_implicities):
+                binary_check_interval(result_operand=left, left_operand=left, right_operand=right, op_type_to_check=op_type_to_check,
+                                      return_type=return_type, interval_allowed=interval_allowed, error_info=error_info)
+                return left
+            elif not right.is_null_type() and right.is_included(left_implicities):
+                binary_check_interval(result_operand=right, left_operand=left, right_operand=right, op_type_to_check=op_type_to_check,
+                                      return_type=return_type, interval_allowed=interval_allowed, error_info=error_info)
+                return right
+            else:
+                if isinstance(op_type_to_check, Number):
+                    binary_check_interval(result_operand=op_type_to_check, left_operand=left, right_operand=right,
+                                          op_type_to_check=op_type_to_check, return_type=return_type, interval_allowed=interval_allowed,
+                                          error_info=error_info)
+                return op_type_to_check
+
+        else:
+            origin = None if error_info is None else "operator={operator} {left} {right}".format(left=error_info['left_name'],
+                                                                                                 operator=error_info['op'],
+                                                                                                 right=error_info['right_name'])
+            raise SemanticError("3-2", type_1=left, type_2=right, type_op=op_type_to_check, origin=origin)
+    else:
+        if warning_raising:
+            warnings.warn(f"Implicit promotion between {left} and {right}.")
+        if return_type and (left.is_included(right_implicities) or right.is_included(left_implicities)):
+            return return_type
+        elif left.is_included(right_implicities):
+            return left
+        elif right.is_included(left_implicities):
+            return right
+        else:
+            origin = None if error_info is None else "operator={operator} {left} {right}".format(left=error_info['left_name'],
+                                                                                                 operator=error_info['op'],
+                                                                                                 right=error_info['right_name'])
+            raise SemanticError("3-1", type_1=left, type_2=right, origin=origin)
+
+
+def binary_implicit_type_promotion_with_mixed_types(
+        result_dataframe, left_type, right_type, op_type_to_check=None, return_type=None, interval_allowed: bool = False, error_info=None):
+    """
+    """
+
+    if result_dataframe.empty:
+        return Mixed(), result_dataframe
+
+    # If there is not a data_type column, result_dataframe is the result of merging two recordsets
+    if 'data_type' not in result_dataframe.columns:
+        result_dataframe['data_type'] = result_dataframe.apply(
+            lambda x: binary_implicit_type_promotion(x['data_type_left'], x['data_type_right'], op_type_to_check,
+                                                     return_type, interval_allowed, error_info), axis=1)
+
+        result_dataframe = result_dataframe.drop(columns=['data_type_left', 'data_type_right'])
+
+    elif isinstance(left_type, Mixed):
+        result_dataframe['data_type'] = result_dataframe['data_type'].apply(
+            lambda x: binary_implicit_type_promotion(x, right_type, op_type_to_check, return_type, interval_allowed, error_info))
+
+    elif isinstance(right_type, Mixed):
+        result_dataframe['data_type'] = result_dataframe['data_type'].apply(
+            lambda x: binary_implicit_type_promotion(left_type, x, op_type_to_check, return_type, interval_allowed, error_info))
+
+    if return_type:
+        return return_type, result_dataframe
+    return Mixed(), result_dataframe
+
+
+def unary_implicit_type_promotion(operand: ScalarType, op_type_to_check: ScalarType = None, return_type: ScalarType = None,
+                                  interval_allowed: bool = True, error_info: dict = None):
+    """
+    """
+
+    operand_implicities = implicit_type_promotion_dict[operand.__class__]
+
+    unary_check_interval(operand=operand, op_type_to_check=op_type_to_check, return_type=return_type, interval_allowed=interval_allowed,
+                         error_info=error_info)
+
+    if op_type_to_check:
+        if not op_type_to_check.is_included(operand_implicities):
+            origin = None if error_info is None else "{}({})".format(error_info['op'], error_info['operand_name'])
+            raise SemanticError("3-3", type_1=operand, type_op=op_type_to_check, origin=origin)
+
+    if return_type:
+        return return_type
+    if op_type_to_check and not operand.is_subtype(op_type_to_check):
+        return op_type_to_check
+    return operand
+
+
+def unary_implicit_type_promotion_with_mixed_types(operand_dataframe, op_type_to_check=None, return_type=None, interval_allowed=None,
+                                                   error_info=None):
+    """
+    """
+
+    if operand_dataframe.empty:
+        return Mixed(), operand_dataframe
+
+    operand_dataframe['data_type'] = operand_dataframe['data_type'].apply(
+        lambda x: unary_implicit_type_promotion(x, op_type_to_check, return_type, interval_allowed=interval_allowed, error_info=error_info))
+
+    if return_type:
+        return return_type, operand_dataframe
+    return Mixed(), operand_dataframe
+
+
+def check_operator(return_type: ScalarType = None, op_check_type: ScalarType = None):
+    """
+    """
+    if return_type is None or op_check_type is None:
+        return True
+
+    op_check_type_implicities = implicit_type_promotion_dict[op_check_type.__class__]
+
+    if return_type.is_included(op_check_type_implicities):
+        return True
+
+    return False
+
+
+def unary_check_interval(operand: ScalarType, op_type_to_check: ScalarType = None, return_type: ScalarType = None,
+                         interval_allowed: bool = False, error_info: dict = None):
+    if interval_allowed and getattr(operand, "interval", None):
+        if return_type and isinstance(return_type, Integer):
+            return None
+        if return_type and isinstance(return_type, Number):
+            return_type.set_interval(operand.interval)
+        if op_type_to_check and isinstance(op_type_to_check, Number):
+            op_type_to_check.set_interval(operand.interval)
+    elif not interval_allowed and getattr(operand, "interval", None):
+        origin = None if error_info is None else "{}({})".format(error_info['op'], error_info['operand_name'])
+        raise SemanticError("3-5", origin=origin)
+    else:
+        return None
+
+
+def binary_check_interval(result_operand: ScalarType = None, left_operand: ScalarType = None, right_operand: ScalarType = None,
+                          op_type_to_check: ScalarType = None, return_type: ScalarType = None, interval_allowed: bool = False,
+                          error_info: dict = None):
+    """
+    """
+    if op_type_to_check is None:
+        return None
+    if return_type and isinstance(return_type, Integer):
+        return None
+    if isinstance(result_operand, Number):
+        interval = getattr(left_operand, "interval", None) or getattr(right_operand, "interval", None)
+        if interval and not interval_allowed:
+            origin = None if error_info is None else "{}({})".format(error_info['op'], error_info['operand_name'])
+            raise SemanticError("3-5", origin=origin)
+        result_operand.set_interval(interval)

py_dpm/Exceptions/exceptions.py

@@ -0,0 +1,84 @@
+from py_dpm.Exceptions.messages import centralised_messages
+from py_dpm.Utils.operands_mapping import LabelHandler, get_type_from_label
+
+"""
+Exceptions management.
+"""
+
+
+class DrrException(Exception):
+    """Base class for exceptions in this module."""
+
+    def __init__(self, message, lino=None, colno=None, code=None):
+        if code is not None:
+            super().__init__(message, code)
+        else:
+            super().__init__(message)
+        self.lino = lino
+        self.colno = colno
+
+    @property
+    def pos(self):
+        """
+
+        """
+        return [self.lino, self.colno]
+
+
+class SyntaxError(DrrException):
+
+    def __init__(self, code, **kwargs):
+        message = centralised_messages[code].format(**kwargs)
+
+        super().__init__(message, None, None, code)
+
+
+def gather_expression(operand):
+    operands_labels = LabelHandler().operands_labels
+
+    expression = operand
+    for key in operands_labels.__reversed__():
+        if key in expression:
+            expression = expression.replace(key, operands_labels[key])
+
+    if expression is None:
+        return expression
+    return expression
+
+
+class SemanticError(DrrException):
+    """
+
+    """
+
+    def __init__(self, code, **kwargs):
+        operands_labels = LabelHandler().operands_labels
+        message = centralised_messages[code].format(**kwargs)
+        for operand in reversed(operands_labels):
+            if operand in message:
+                generated = gather_expression(operand)
+                not_single = True if get_type_from_label(operand) == 'not_single' else False
+                if not_single:
+                    message = message.replace(operand, f"GENERATED:' {generated} '")
+                else:
+                    message = message.replace(operand, generated)
+
+        super().__init__(message, None, None, code)
+
+
+class DataTypeError(Exception):
+    """
+
+    """
+
+    def __init__(self, value, dataType):
+        super().__init__("Invalid Scalar value '{}' for data type {}.".format(
+            value, dataType
+        ))
+
+
+class ScriptingError(DrrException):
+
+    def __init__(self, code, **kwargs):
+        message = centralised_messages[code].format(**kwargs)
+        super().__init__(message, None, None, code)

py_dpm/Exceptions/messages.py

@@ -0,0 +1,114 @@
+"""
+Exceptions.messages.py
+======================
+
+Description
+-----------
+All exceptions possibles.
+"""
+centralised_messages = {
+    # Syntax errors
+    "0-1": "For match operator, provided regex has syntax errors: {message}",
+    "0-2": "Cannot specify {argument} more than one time in the same cell reference.",
+    "0-3": "Cannot use null literal, you must use the isnull function",
+    # Variable not founded
+    "1-1": "The following items were not found: {items}.",
+    "1-2": "Cell expression {cell_expression} was not found.",
+    "1-3": "Variable {variable} was not found.",
+    "1-4": "Table {table} was not found.",
+    "1-5": "The following open keys were not found: {open_keys}.",
+    "1-6": "Table group {table_group} not found.",
+    "1-7": "Property signature {property_code} associated with the property constraint cannot be found.",
+    "1-8": "The following operations {operations} were not found.",
+    "1-9": "Previous operation: {operation_code} was not found",
+    "1-10": "Can't be analyzed an expression with table groups. Table reference {table} is defined as table group.",  # TODO: only used in semantic not in webservice
+    "1-11": "Category with code: {category_code} was not found",
+    "1-12": "Subcategory with code: {subcategory_code} was not found",
+    "1-13": "No module versions found for table versions: {table_version_ids}.",
+    "1-14": "No module versions found for preconditions items: {precondition_items}.",
+    "1-15": "Subcategory with id: {subcategory_id} was not found",
+    "1-16": "Category with id: {category_id} was not found",
+    "1-17": "Grey cells {cell_expression} were found.",
+    "1-18": "Found explicit s* on the expression, but no sheets for the cells were found for the "
+            "operand(s).",
+    "1-19": "Found explicit r* on the expression, but no rows for the cells were found for the "
+            "operand(s).",
+    "1-20": "Missing explicit {header} on the expression for table {table}",
+    # Structures
+    "2-1": "If preconditions are involved the result has to be a boolean scalar.",
+    "2-2": "This operation is not allowed, because there is no match between DPM components. Operator={op} left={left}, right={right}.",
+    "2-3": "Structures are different (or types on key components) for this operator {op} between {structure_1} and {structure_2}. "
+           "Please check {origin}.",
+    "2-4": "For this operator {op} this component {name} is not present in both structures. "
+           "Please check {origin}.",
+    "2-5": "For this component {name} types are different for this operator {op} found {type_1} and {type_2}."
+           "Please check {origin}.",
+    "2-6": "In RecordSet: {name}, standard keys: {keys} with values {values} are duplicated.",
+    "2-7": "Component creation for {component_name} was not possible.",
+    "2-8": "At op {op}: Key components {dpm_keys} not found on recordset {recordset}.",
+    "2-9": "At op {op}: Found different number of headers on left and right hand side.",
+    # Data types
+    "3-1": "Implicit cast is not available between {type_1} and {type_2}."
+           "Please check {origin}.",
+    "3-2": "Types are wrong, type_op_1={type_1},type_op_2={type_2}, operator works for {type_op}."
+           "Please check {origin}.",
+    "3-3": "Types are wrong, type_op_1={type_1}, operator works for {type_op}."
+           "Please check {origin}.",
+    "3-4": "Interval can't be used for this operand_type={operand_type}",
+    "3-5": "Interval can't be used for this operator."
+           "Please check {origin}.",
+    "3-6": "Invalid default type, default is a {default_type} but it has to be a {expected_type}.",
+    # Operators
+    # - Aggregate Operators
+    "4-4-0-1": "Only a Recordset is allowed in the Aggregation operator {op}.",
+    "4-4-0-2": "Grouping components {not_present} are not present in key components",
+    "4-4-0-3": "Mixed type can't be used in aggregation. "
+              "Please check {origin}.",
+    # - Clause Operators
+    "4-5-0-1": "On recordset {recordset}: clause operators can't be used with standard key components or fact component.",
+    "4-5-0-2": "In {operator} operator only operands of recordset type are supported.",  #
+    # -- Rename
+    "4-5-1-1": "For rename operator component names: {names} already exists on recordset {recordset}.",
+    "4-5-1-2": "Duplicated new names after rename operator: {duplicated}.",
+    "4-5-1-3": "For rename operator, new names can't be standard key names or indexes names(x,y,z) on recordset: {recordset}",
+    "4-5-1-4": "For rename operator, key component {component} not found on recordset: {recordset} because it has already been renamed.",
+    # -- Where
+    "4-5-2-1": "Invalid clause for where operator, at least one dpm key component of recordset {recordset} must be used.",
+    "4-5-2-2": "For where operator, operand {operand} and condition {condition} must have the same structure or condition must be a subset of selection.",
+    # - Conditional Operators
+    "4-6-0-1": "For Conditional operators DPM components have to have the same records.",
+    "4-6-0-2": "For conditional operators, condition {condition} and operand/selection {operand} must have the same structure or condition must be a subset",
+    # -- if then else
+    "4-6-1-1": "Error for the condition in if then else operator",
+    "4-6-1-2": "For if then else operator, if the condition is a scalar and else operand is not provided, then operand can't be a recordset.",
+    "4-6-1-3": "For if then else operator, then and else have to be both recordset or both scalars, if the condition is a scalar.",
+    # -- nvl
+    "4-6-2-1": "Invalid input structures for Nvl operator, right op has to be scalar too.",
+    # -- filter
+    "4-6-3-1": "Filter operator only supports recordset as selection and condition",
+    # - Time Operators
+    # -- time_shift (only exists this operator in time operators)
+    "4-7-1": "Only a Recordset or a scalar is allowed for {op} operator.",
+    "4-7-2": "For time_shift operator, only var component is allowed when operand is a recordset",
+    "4-7-3": "For time_shift operator, var component must be specified when operand is a recordset",
+    # Generation of validations
+    "5-0-1": "This expression doesn't generate any correct validation.",
+    "5-0-2": "This expression can't be used for the generation of children.",
+    # - Properties constraints
+    "5-1-1": "No properties constraints were found.",
+    "5-1-2": "In an expression defined on properties constraints only there can be one property constraint.",
+    "5-1-3": "Operator '{operator}' not allowed in an expression defined on properties constraints.",
+    "5-1-4": "Property with signature {ref} was not found.",
+    # - Variants
+    "5-2-1": "The supplied expression does not contain any table group.",
+    # - Sign validations
+    "5-3-1": "Table version id {table_version_id} does not exist or does not have associated cells.",
+    # Scripting
+    "6-1": "Overwriting a variable is not allowed, trying it with {variable}.",
+    "6-2": "References to operations are not allowed in single expressions, trying it with {operation_code}.",
+    "6-3": "Preconditions are not allowed in scripting, trying it with {precondition}.",
+    "6-4": "Circular reference between operations {op1} and {op2}. Try removing or changing these references.",
+    # Other errors
+    "7-1": "Found a Property Reference in a regular validation. Please check Operation Source to use Property Constraint.",
+    "7-2": "Found a Variable Reference, please check expression"
+}

py_dpm/OperationScopes/OperationScopeService.py

@@ -0,0 +1,247 @@
+import uuid
+from datetime import datetime
+from itertools import product
+
+import numpy
+import pandas as pd
+
+from py_dpm.Exceptions import exceptions
+from py_dpm.models import ModuleVersion, OperationScope, OperationScopeComposition
+from py_dpm.Utils.tokens import VARIABLE_VID, WARNING_SEVERITY
+from py_dpm.db_utils import get_session
+
+FROM_REFERENCE_DATE = "FromReferenceDate"
+TO_REFERENCE_DATE = "ToReferenceDate"
+MODULE_VID = "ModuleVID"
+TABLE_VID = "TableVID"
+
+
+def _check_if_existing(composition_modules, existing_scopes):
+    existing_scopes = existing_scopes[existing_scopes[MODULE_VID].isin(composition_modules)][MODULE_VID].tolist()
+    if len(existing_scopes) and set(composition_modules) == set(existing_scopes):
+        return True
+    return False
+
+
+class OperationScopeService:
+    """
+    Class to calculate OperationScope and OperationScopeComposition tables for an operation version
+    """
+
+    def __init__(self, operation_version_id, session=None):
+        self.operation_version_id = operation_version_id
+        self.session = session or get_session()
+        self.module_vids = []
+        self.current_date = datetime.today().date()
+
+        self.operation_scopes = []
+
+    def calculate_operation_scope(self, tables_vids: list, precondition_items: list, only_last_release=True):
+        """
+        Calculate OperationScope and OperationScopeComposition tables for an operation version, taking as input
+        a list with the operation table version ids in order to calculate the module versions involved in the operation
+        :param tables_vids: List with table version ids
+        :param precondition_items: List with precondition codes
+        :return two list with existing and new scopes
+        """
+
+        modules_info_dataframe = self.extract_module_info(
+            tables_vids=tables_vids, precondition_items=precondition_items, only_last_release=only_last_release)  # We extract all the releases from the database
+        if modules_info_dataframe is None:
+            return [], []
+
+        modules_vids = modules_info_dataframe[MODULE_VID].unique().tolist()
+        if len(modules_info_dataframe) == 1:
+            module_vid = modules_vids[0]
+            from_date = modules_info_dataframe['FromReferenceDate'].values[0]
+            operation_scope = self.create_operation_scope(from_date)
+            self.create_operation_scope_composition(operation_scope=operation_scope, module_vid=module_vid)
+        else:
+            intra_modules = []
+            cross_modules = {}
+            unique_operands_number = len(tables_vids) + len(precondition_items)
+
+            for module_vid, group_df in modules_info_dataframe.groupby(MODULE_VID):
+                vids = group_df[VARIABLE_VID].unique().tolist()
+                if len(vids) == unique_operands_number:
+                    intra_modules.append(module_vid)
+                else:
+                    for table_vid in vids:
+                        if table_vid not in cross_modules:
+                            cross_modules[table_vid] = []
+                        cross_modules[table_vid].append(module_vid)
+
+            if len(intra_modules):
+                self.process_repeated(intra_modules, modules_info_dataframe)
+
+            if cross_modules:
+                if set(cross_modules.keys())==set(tables_vids):
+                    self.process_cross_module(cross_modules=cross_modules, modules_dataframe=modules_info_dataframe)
+                else:
+                    # add the missing table_vids to cross_modules
+                    for table_vid in tables_vids:
+                        if table_vid not in cross_modules:
+                            cross_modules[table_vid] =  modules_info_dataframe[modules_info_dataframe[VARIABLE_VID]==table_vid][MODULE_VID].unique().tolist()
+                    self.process_cross_module(cross_modules=cross_modules, modules_dataframe=modules_info_dataframe)
+
+        return self.get_scopes_with_status()
+
+    def extract_module_info(self, tables_vids, precondition_items, only_last_release=True):
+        """
+        Extracts modules information of tables version ids and preconditions from database and
+        joins them in a single dataframe
+        :param tables_vids: List with table version ids
+        :param precondition_items: List with precondition codes
+        :return two list with existing and new scopes
+        """
+        modules_info_lst = []
+        modules_info_dataframe = None
+        if len(tables_vids):
+            tables_modules_info_dataframe = ModuleVersion.get_from_tables_vids(
+                session=self.session, tables_vids=tables_vids, only_last_release=only_last_release)
+            if tables_modules_info_dataframe.empty:
+                missing_table_modules = tables_vids
+            else:
+                modules_tables = tables_modules_info_dataframe[TABLE_VID].tolist()
+                missing_table_modules = set(tables_vids).difference(set(modules_tables))
+
+            if len(missing_table_modules):
+                raise exceptions.SemanticError("1-13", table_version_ids=missing_table_modules)
+
+            tables_modules_info_dataframe.rename(columns={TABLE_VID: VARIABLE_VID}, inplace=True)
+            modules_info_lst.append(tables_modules_info_dataframe)
+
+        if len(precondition_items):
+            preconditions_modules_info_dataframe = ModuleVersion.get_precondition_module_versions(session=self.session,
+                                                                                                  precondition_items=precondition_items)
+
+            if preconditions_modules_info_dataframe.empty:
+                missing_precondition_modules = precondition_items
+            else:
+                modules_preconditions = preconditions_modules_info_dataframe['Code'].tolist()
+                missing_precondition_modules = set(precondition_items).difference(set(modules_preconditions))
+
+            if missing_precondition_modules:
+                raise exceptions.SemanticError("1-14", precondition_items=missing_precondition_modules)
+
+            preconditions_modules_info_dataframe.rename(columns={'VariableVID': VARIABLE_VID}, inplace=True)
+            modules_info_lst.append(preconditions_modules_info_dataframe)
+
+        if len(modules_info_lst):
+            modules_info_dataframe = pd.concat(modules_info_lst)
+        return modules_info_dataframe
+
+    def process_repeated(self, modules_vids, modules_info):
+        """
+        Method to calculate OperationScope and OperationScopeComposition tables for repeated operations
+        :param modules_vids: list with module version ids
+        """
+        for module_vid in modules_vids:
+            from_date = modules_info[modules_info['ModuleVID'] == module_vid]['FromReferenceDate'].values[0]
+            operation_scope = self.create_operation_scope(from_date)
+            self.create_operation_scope_composition(operation_scope=operation_scope, module_vid=module_vid)
+
+    def process_cross_module(self, cross_modules, modules_dataframe):
+        """
+        Method to calculate OperationScope and OperationScopeComposition tables for a cross module operation
+        :param cross_modules: dictionary with table version ids as key and its module version ids as values
+        :param modules_dataframe: dataframe with modules data
+        """
+        modules_dataframe[FROM_REFERENCE_DATE] = pd.to_datetime(modules_dataframe[FROM_REFERENCE_DATE])
+        modules_dataframe[TO_REFERENCE_DATE] = pd.to_datetime(modules_dataframe[TO_REFERENCE_DATE])
+
+        values = cross_modules.values()
+        for combination in product(*values):
+            combination_info = modules_dataframe[modules_dataframe[MODULE_VID].isin(combination)]
+            from_dates = combination_info[FROM_REFERENCE_DATE].values
+            to_dates = combination_info[TO_REFERENCE_DATE].values
+            ref_from_date = from_dates.max()
+            ref_to_date = to_dates.min()
+
+            is_valid_combination = True
+            for from_date, to_date in zip(from_dates, to_dates):
+                if to_date < ref_from_date or ((not pd.isna(ref_to_date)) and from_date > ref_to_date):
+                    is_valid_combination = False
+
+            if is_valid_combination:
+                from_submission_date = ref_from_date
+            else:
+                from_submission_date = None
+            operation_scope = self.create_operation_scope(from_submission_date)
+            combination = set(combination)
+            for module in combination:
+                self.create_operation_scope_composition(operation_scope=operation_scope, module_vid=module)
+
+    def create_operation_scope(self, submission_date):
+        """
+        Method to populate OperationScope table
+        """
+        if not pd.isnull(submission_date):
+            if isinstance(submission_date, numpy.datetime64):
+                submission_date = str(submission_date).split('T')[0]
+            if isinstance(submission_date, str):
+                submission_date = datetime.strptime(submission_date, '%Y-%m-%d').date()
+            elif isinstance(submission_date, datetime):
+                submission_date = submission_date.date()
+        else:
+            submission_date = None
+        operation_scope = OperationScope(
+            OperationVID=self.operation_version_id,
+            IsActive=True,
+            Severity=WARNING_SEVERITY,
+            FromSubmissionDate=submission_date,
+            RowGUID=uuid.uuid4()
+        )
+        self.session.add(operation_scope)
+        return operation_scope
+
+    def create_operation_scope_composition(self, operation_scope, module_vid):
+        """
+        Method to populate OperationScopeComposition table
+        :param operation_scope: Operation scope data
+        :param module_vid: Module version id
+        """
+        operation_scope_composition = OperationScopeComposition(
+            operation_scope=operation_scope,
+            ModuleVID=module_vid,
+            RowGUID=uuid.uuid4()
+        )
+        self.session.add(operation_scope_composition)
+
+    def get_scopes_with_status(self):
+        """
+        Method that checks if operation scope exists in database and classifies it based on whether it exists or not
+        :return two list with existing and new scopes
+        """
+        existing_scopes = []
+        new_scopes = []
+        operation_scopes = [o for o in self.session.new if isinstance(o, OperationScope)]
+        database_scopes = OperationScopeComposition.get_from_operation_version_id(self.session,
+                                                                                  self.operation_version_id)
+        if database_scopes.empty:
+            new_scopes = operation_scopes
+        else:
+            for scope in operation_scopes:
+                composition_modules = [scope_comp.ModuleVID for scope_comp in scope.composition]
+                result = database_scopes.groupby('OperationScopeID').filter(
+                    lambda x: _check_if_existing(composition_modules, x))
+
+                if not result.empty:
+                    existing_scopes.append(scope)
+                else:
+                    # if the module is closed and the operation is new, we haven't to create a new scope wih the old module
+                    # because we have the new module
+                    existing_previous = False
+                    for vid in composition_modules:
+                        if id not in existing_scopes:
+                            aux = ModuleVersion.get_module_version_by_vid(session=self.session, vid=vid)
+                            if aux.empty:
+                                continue
+                            if aux['EndReleaseID'][0] is not None:
+                                existing_previous = True
+                                break
+
+                    if not existing_previous:
+                        new_scopes.append(scope)
+
+        return existing_scopes, new_scopes