TimeFeatures 1.0.10__tar.gz → 1.0.12__tar.gz

{TimeFeatures-1.0.10 → TimeFeatures-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TimeFeatures
-Version: 1.0.10
+Version: 1.0.12
 Summary: Timefeatures add-on for Orange 3 data mining software.
 Home-page: https://github.com/alervgr/Orange-TimeFeatures
 Author: Alejandro Rivas García

{TimeFeatures-1.0.10 → TimeFeatures-1.0.12}/TimeFeatures.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TimeFeatures
-Version: 1.0.10
+Version: 1.0.12
 Summary: Timefeatures add-on for Orange 3 data mining software.
 Home-page: https://github.com/alervgr/Orange-TimeFeatures
 Author: Alejandro Rivas García

{TimeFeatures-1.0.10 → TimeFeatures-1.0.12}/TimeFeatures.egg-info/SOURCES.txt

@@ -9,8 +9,8 @@ TimeFeatures.egg-info/entry_points.txt
 TimeFeatures.egg-info/top_level.txt
 timefeatures/widgets/__init__.py
 timefeatures/widgets/owsavetodb.py
-timefeatures/widgets/owtfgraphgenerator.py
-timefeatures/widgets/owtimefeatureconstructor.py
+timefeatures/widgets/owtimefeaturesconstructor.py
+timefeatures/widgets/owvardependencygraph.py
 timefeatures/widgets/icons/graphgenerator.svg
 timefeatures/widgets/icons/savedatadb.svg
 timefeatures/widgets/icons/timefeature-xs.svg

{TimeFeatures-1.0.10 → TimeFeatures-1.0.12}/setup.py

@@ -21,7 +21,7 @@ setup(name="TimeFeatures",
       packages=["timefeatures.widgets"],
       package_data={"timefeatures.widgets": ["icons/*.svg", "icons/*.png"]},
       entry_points={"orange.widgets": "Time-Features = timefeatures.widgets"},
-      version="1.0.10",
+      version="1.0.12",
       author="Alejandro Rivas García",
       author_email="alejandrorivasgarcia@gmail.com",
       keywords=[

{TimeFeatures-1.0.10 → TimeFeatures-1.0.12}/timefeatures/widgets/owsavetodb.py

@@ -46,7 +46,7 @@ class owsavetodb(OWBaseSql, OWWidget):
     name = "Save to DB"
     description = "Save a dataset into a DB."
     icon = "icons/savedatadb.svg"
-    priority = 2240
+    priority = 2241
     keywords = "sql table, save, data, db, dataset"
 
     class Inputs:
@@ -169,7 +169,8 @@ class owsavetodb(OWBaseSql, OWWidget):
             datetime TIMESTAMP NOT NULL,
             rows INT NOT NULL,
             cols INT NOT NULL,
-            class VARCHAR(30)
+            class VARCHAR(30),
+            class_name VARCHAR(30)
         )
         """
         try:
@@ -257,9 +258,15 @@ class owsavetodb(OWBaseSql, OWWidget):
             self.Error.connection("Host and database fields must be filled.")
         else:
             self.create_master_table()
-            query = "INSERT INTO public.datasets (name, datetime, rows, cols, class) VALUES ('" + self.tableName.text().lower() + "','" + datetime.now().strftime(
+
+            if self.data.domain.class_var:
+                class_name = self.data.domain.class_var.name
+            else:
+                class_name = None
+
+            query = "INSERT INTO public.datasets (name, datetime, rows, cols, class, class_name) VALUES ('" + self.tableName.text().lower() + "','" + datetime.now().strftime(
                 '%Y-%m-%d %H:%M:%S') + "','" + str(self.rows) + "','" + str(self.cols) + "','" + str(
-                self.target) + "');"
+                self.target) + "','" + str(class_name) + "');"
 
             try:
                 with self.backend.execute_sql_query(query):

TimeFeatures-1.0.10/timefeatures/widgets/owtimefeatureconstructor.py → TimeFeatures-1.0.12/timefeatures/widgets/owtimefeaturesconstructor.py

@@ -809,20 +809,21 @@ class FeatureConstructorHandler(DomainContextHandler):
         return True
 
 
-class owtimefeatureconstructor(OWWidget, ConcurrentWidgetMixin):
-    name = "Time Feature Constructor"
+class owtimefeaturesconstructor(OWWidget, ConcurrentWidgetMixin):
+    name = "Time Features Constructor"
     description = "Construct new time features (data columns) from a set of " \
                   "existing features in the input dataset."
     icon = "icons/timefeature.svg"
-    keywords = "time feature constructor, function, lambda, time, constructor, feature"
-    priority = 2240
+    keywords = "time features constructor, function, time, constructor, features"
+    priority = 2239
 
     class Inputs:
         data = Input("Data", Orange.data.Table)
+        expressions = Input("Variable Definitions", Orange.data.Table)
 
     class Outputs:
         data = Output("Data", Orange.data.Table)
-        expressions = Output("Expressions", Orange.data.Table)
+        expressions = Output("Variable Definitions", Orange.data.Table)
 
     want_main_area = False
 
@@ -847,11 +848,13 @@ class owtimefeatureconstructor(OWWidget, ConcurrentWidgetMixin):
     class Warning(OWWidget.Warning):
         renamed_var = Msg("Recently added variable has been renamed, "
                           "to avoid duplicates.\n")
+        table_warning = Msg("You need a configuration table (Variable-Expression).")
 
     def __init__(self):
         super().__init__()
         ConcurrentWidgetMixin.__init__(self)
         self.data = None
+        self.expressions = None
         self.dataOriginal = None
         self.editors = {}
 
@@ -1022,7 +1025,6 @@ class owtimefeatureconstructor(OWWidget, ConcurrentWidgetMixin):
 
         self.apply()
 
-
     def _on_selectedVariableChanged(self, selected, *_):
         index = selected_row(self.featureview)
         if index is not None:
@@ -1102,6 +1104,35 @@ class owtimefeatureconstructor(OWWidget, ConcurrentWidgetMixin):
         self.fix_button.setHidden(not self.expressions_with_values)
         self.editorstack.setEnabled(self.currentIndex >= 0)
 
+    @Inputs.expressions
+    @check_sql_input
+    def setExpressions(self, expressions=None):
+
+        self.expressions = expressions
+
+        if self.expressions is None:
+            self.Warning.clear()
+            self.Error.transform_error.clear()
+
+        if self.data is not None and self.expressions is not None:
+            if self.expressions is not None:
+                if len(self.expressions.domain) >= 2 and (
+                        self.expressions.domain[0].name != "Variable" or self.expressions.domain[1].name != "Expression"):
+                    self.Warning.table_warning()
+                else:
+                    self.Error.transform_error.clear()
+                    for datos in reversed(self.expressions):
+                        if not math.isnan(datos[1]) and str(datos[1]) != "NaN":
+                            desc = ContinuousDescriptor(
+                                name=str(datos[0]),
+                                expression=str(datos[1]),
+                                meta=False,
+                                number_of_decimals=3,
+                            )
+                            self.addFeature(desc)
+        else:
+            self.Error.transform_error("There is not data input.")
+
     def handleNewSignals(self):
         if self.data is not None:
             self.apply()
@@ -1187,6 +1218,14 @@ class owtimefeatureconstructor(OWWidget, ConcurrentWidgetMixin):
         desc = self._validate_descriptors(desc)
         self.start(run, self.data, desc, self.expressions_with_values)
 
+        '''
+        INTENTO DE PODER USAR VARIABLES NO CONTENIDAS EN EL DATASET ORIGINAL.
+        
+        desc = list(self.featuremodel)
+        for d in desc:
+            self.start(run, self.data, self._validate_descriptors(d), self.expressions_with_values)'''
+
+
     def on_done(self, result: "Result") -> None:
         data, attrs, desc = result.data, result.attributes, result.desc
         disc_attrs_not_ok = self.check_attrs_values(
@@ -1360,6 +1399,7 @@ class Result:
 def run(data: Table, desc, use_values, task: TaskState) -> Result:
     if task.is_interruption_requested():
         raise CancelledError  # pragma: no cover
+
     new_variables, new_metas = construct_variables(desc, data, use_values)
     # Explicit cancellation point after `construct_variables` which can
     # already run `compute_value`.
@@ -1373,10 +1413,14 @@ def run(data: Table, desc, use_values, task: TaskState) -> Result:
     try:
         for variable in new_variables:
             variable.compute_value.mask_exceptions = False
-        data = data.transform(new_domain)
+        try:
+            data = data.transform(new_domain)
+        except:
+            raise TypeError("One or more variables were not found.")
     finally:
         for variable in new_variables:
             variable.compute_value.mask_exceptions = True
+
     return Result(data, new_variables, new_metas, desc)
 
 
@@ -1455,6 +1499,7 @@ def validate_exp(exp):
 
 def construct_variables(descriptions, data, use_values=False):
     # subs
+
     variables = []
     metas = []
     source_vars = data.domain.variables + data.domain.metas
@@ -1814,4 +1859,4 @@ class FeatureFunc:
 
 
 if __name__ == "__main__":  # pragma: no cover
-    WidgetPreview(owtimefeatureconstructor).run(Orange.data.Table("iris"))
+    WidgetPreview(owtimefeaturesconstructor).run(Orange.data.Table("iris"))

TimeFeatures-1.0.10/timefeatures/widgets/owtfgraphgenerator.py → TimeFeatures-1.0.12/timefeatures/widgets/owvardependencygraph.py

@@ -17,6 +17,72 @@ from PyQt5.QtWidgets import QPushButton, QVBoxLayout, QHBoxLayout
 from orangecontrib.network import Network
 from orangewidget.utils.signals import Input
 
+'''
+
+CALCULO DE PONDERACIONES PARA LOS PESOS DE LAS ARISTAS.
+
+def calculate_weight(expression):
+    # Encontrar todas las coincidencias con las funciones temporales y almacenarlas
+    matches_shift = list(re.finditer(r'shift\(([^,]+),([-+]?\d+)\)', expression))
+    matches_sum = list(re.finditer(r'sum\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+    matches_mean = list(re.finditer(r'mean\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+    matches_count = list(re.finditer(r'count\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+    matches_min = list(re.finditer(r'min\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+    matches_max = list(re.finditer(r'max\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+    matches_sd = list(re.finditer(r'sd\(([^,]+),([-+]?\d+),([-+]?\d+)\)', expression))
+
+    valores = {}
+
+    # Iterar sobre todas las coincidencias de shift y cambiar la expresión
+    for match in matches_shift:
+        variable_name = match.group(1)
+        shift_value = match.group(2)
+
+        valores[variable_name] = -abs(int(shift_value))
+
+    for match in matches_sum:
+        variable_name = match.group(1)
+        sum_value1 = match.group(2)
+        sum_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(sum_value1)), abs(int(sum_value2)))
+
+    for match in matches_mean:
+        variable_name = match.group(1)
+        mean_value1 = match.group(2)
+        mean_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(mean_value1)), abs(int(mean_value2)))
+
+    for match in matches_count:
+        variable_name = match.group(1)
+        count_value1 = match.group(2)
+        count_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(count_value1)), abs(int(count_value2)))
+
+    for match in matches_min:
+        variable_name = match.group(1)
+        min_value1 = match.group(2)
+        min_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(min_value1)), abs(int(min_value2)))
+
+    for match in matches_max:
+        variable_name = match.group(1)
+        max_value1 = match.group(2)
+        max_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(max_value1)), abs(int(max_value2)))
+
+    for match in matches_sd:
+        variable_name = match.group(1)
+        sd_value1 = match.group(2)
+        sd_value2 = match.group(3)
+
+        valores[variable_name] = -max(abs(int(sd_value1)), abs(int(sd_value2)))
+
+    return valores.values()'''
 
 def from_row_col(f):
     @wraps(f)
@@ -34,12 +100,16 @@ def from_row_col(f):
         expresion_regular = r'\b(' + '|'.join(map(re.escape, variables)) + r')\b'
 
         relaciones = {}
+        # edge_weights = []
 
         for datos in data:
             variable = str(datos[0])
             variable = variable.replace(" ", "_").replace("-", "_")
             if not math.isnan(datos[1]) and str(datos[1]) != "NaN":
                 tipo_var.append(0)
+                # edge_weights_exp = calculate_weight(str(datos[1]))
+                # for weight in edge_weights_exp:
+                    # edge_weights.append(int(weight))
             else:
                 tipo_var.append(1)
             relaciones[variable] = []
@@ -63,7 +133,10 @@ def from_row_col(f):
 
         tipo_var_reshaped = np.array(tipo_var).reshape(-1, 1)
 
+        # np_edge_weights = np.array(edge_weights)
+
         n = len(relaciones)
+        # edges = sp.csr_matrix((np_edge_weights, (row_edges, col_edges)), shape=(n, n))
         edges = sp.csr_matrix((np.ones(len(row_edges)), (row_edges, col_edges)), shape=(n, n))
         return Network(range(n), edges, name=f"{f.__name__}{args}"), nombres_variables, tipo_var_reshaped
 
@@ -75,11 +148,11 @@ def grafo(data=None):
     return data
 
 
-class owtfgraphgenerator(OWWidget, ConcurrentWidgetMixin):
-    name = "T.F Graph Generator"
+class owvardependencygraph(OWWidget, ConcurrentWidgetMixin):
+    name = "Variable Dependency Graph"
     description = "Construct a graph with all the conexions between the variables"
     icon = "icons/graphgenerator.svg"
-    keywords = "time feature graph generator, function, graph"
+    keywords = "variable dependency graph, function, graph, dependency, variable"
     priority = 2240
 
     GRAPH_TYPES = (
@@ -97,7 +170,7 @@ class owtfgraphgenerator(OWWidget, ConcurrentWidgetMixin):
         generation_error = Msg("{}")
 
     class Inputs:
-        data = Input("Data", Orange.data.Table)
+        data = Input("Variable Definitions", Orange.data.Table)
 
     class Outputs:
         network = Output("Network", Network)
@@ -120,7 +193,7 @@ class owtfgraphgenerator(OWWidget, ConcurrentWidgetMixin):
         buttonlayout.setContentsMargins(0, 0, 0, 0)
 
         self.btn_generate = QPushButton(
-            "Generar", toolTip="Generar grafo",
+            "Generate", toolTip="Generate dependency graph.",
             minimumWidth=10
         )
         self.btn_generate.clicked.connect(self.generate)