From 823a1aa22d574e92369f9ec1332c6103dbb7f8f3 Mon Sep 17 00:00:00 2001
From: Sylvain Garancher <sylvain.garancher@syleam.fr>
Date: Wed, 4 Oct 2017 15:06:28 +0200
Subject: [PATCH] [FIX] P3: graph: correct P3 migration errors

- leftover real division errors
- typos in migration of values() calls in
  fffaf735f58f1ac57781c095eb552de6d1fcdc47
---
 odoo/tools/graph.py | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/odoo/tools/graph.py b/odoo/tools/graph.py
index d43088d97ab3..0f7665f06246 100755
--- a/odoo/tools/graph.py
+++ b/odoo/tools/graph.py
@@ -257,7 +257,7 @@ class graph(object):
         """The ranks are normalized by setting the least rank to zero.
         """
 
-        least_rank = min(x['x'] for x in self.result.values.values())
+        least_rank = min(x['x'] for x in self.result.values())
 
         if least_rank!=0:
             for node in self.result:
@@ -334,7 +334,7 @@ class graph(object):
         """
         adj_nodes = self.adj_position(node, adj_rank)
         l = len(adj_nodes)
-        m = l/2
+        m = l // 2
 
         if l==0:
             return -1.0
@@ -381,7 +381,7 @@ class graph(object):
         """Finds actual-order of the nodes with respect to maximum number of nodes in a rank in component
         """
         mid_pos = 0.0
-        max_level = max(len(x) for x in self.levels.values.values())
+        max_level = max(len(x) for x in self.levels.values())
 
         for level in self.levels:
             if level:
@@ -391,16 +391,16 @@ class graph(object):
                 list.reverse()
 
                 if no%2==0:
-                    first_half = list[no/2:]
+                    first_half = list[no // 2:]
                     factor = -factor
                 else:
-                    first_half = list[no/2+1:]
+                    first_half = list[no // 2 + 1:]
                     if max_level==1:#for the case when horizontal graph is there
-                        self.result[list[no/2]]['y'] = mid_pos + (self.result[list[no/2]]['x']%2 * 0.5)
+                        self.result[list[no // 2]]['y'] = mid_pos + (self.result[list[no // 2]]['x']%2 * 0.5)
                     else:
-                        self.result[list[no/2]]['y'] = mid_pos + factor
+                        self.result[list[no // 2]]['y'] = mid_pos + factor
 
-                last_half = list[:no/2]
+                last_half = list[:no // 2]
 
                 i=1
                 for node in first_half:
@@ -423,8 +423,8 @@ class graph(object):
         no = len(l)
 
         rest = no%2
-        first_half = l[no/2+rest:]
-        last_half = l[:no/2]
+        first_half = l[no // 2 + rest:]
+        last_half = l[:no // 2]
 
         for i, child in enumerate(first_half):
             self.result[child]['y'] = mid_pos - (i+1 - (0 if rest else 0.5))
@@ -435,7 +435,7 @@ class graph(object):
                 last = self.tree_order(child, last)
 
         if rest:
-            mid_node = l[no/2]
+            mid_node = l[no // 2]
             self.result[mid_node]['y'] = mid_pos
 
             if self.transitions.get(mid_node, False):
@@ -472,7 +472,7 @@ class graph(object):
         """
 
         if self.Is_Cyclic:
-            max_level = max(len(x) for x in self.levels.values.values())
+            max_level = max(len(x) for x in self.levels.values())
 
             if max_level%2:
                 self.result[self.start]['y'] = (max_level+1)/2 + self.max_order + (self.max_order and 1)
@@ -484,7 +484,7 @@ class graph(object):
         else:
             self.result[self.start]['y'] = 0
             self.tree_order(self.start, 0)
-            min_order = math.fabs(min(x['y'] for x in self.result.values.values()))
+            min_order = math.fabs(min(x['y'] for x in self.result.values()))
 
             index = self.start_nodes.index(self.start)
             same = False
@@ -518,27 +518,27 @@ class graph(object):
 
 
                 no = len(roots)
-                first_half = roots[:no/2]
+                first_half = roots[:no // 2]
 
                 if no%2==0:
-                    last_half = roots[no/2:]
+                    last_half = roots[no // 2:]
                 else:
-                    last_half = roots[no/2+1:]
+                    last_half = roots[no // 2 + 1:]
 
-                factor = -math.floor(no/2)
+                factor = -math.floor(no // 2)
                 for start in first_half:
                     self.result[start]['y'] = base + factor
                     factor += 1
 
                 if no%2:
-                    self.result[roots[no/2]]['y'] = base + factor
+                    self.result[roots[no // 2]]['y'] = base + factor
                 factor +=1
 
                 for start in last_half:
                     self.result[start]['y'] = base + factor
                     factor += 1
 
-            self.max_order = max(x['y'] for x in self.result.values.values())
+            self.max_order = max(x['y'] for x in self.result.values())
 
     def find_starts(self):
         """Finds other start nodes of the graph in the case when graph is disconneted
-- 
GitLab