checkou refill polt

plot/refill/CalcBase.py

@@ -46,23 +46,12 @@ class CalcBase(object):
                 time.sleep(sleep_time)
 
     def calc_time(self, reader, start_time: int, end_time: int):
-        end_time = reader.near_stamp(end_time, False)
-        if end_time is None:
-            raise Exception('end_time data is empty')
-
-        start_time = reader.near_stamp(start_time, True)
-        if start_time is None:
-            raise Exception('start_time data is empty')
-
-        strtime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        logger.debug("near_stamp start_time %s end_time=%s", strtime(start_time), strtime(end_time))
-
-        if start_time >= end_time:
-            raise Exception('start_time >= endtime')
+        end_time = end_time or int(time.time())
+        if start_time is None or start_time > end_time:
+            start_time = end_time - 7200
 
         days = span_days(start_time, end_time)
-        strtime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        sdays = [strtime(day) for day in days]
+        sdays = [stime(day) for day in days]
         logger.debug(sdays)
 
         return days, start_time, end_time

plot/refill/ChSpeedRatioCalc.py

@@ -15,7 +15,7 @@ class ChSpeedRatioCalc(ChannelCalc):
 
         reader = self._reader()
         end_time = int(time.time())
-        period = 1800
+        period = 900
         days, start_time, end_time = self.calc_time(reader, end_time - period, end_time)
 
         day_stamp = days[0]

plot/refill/ChannelCovPainter.py

@@ -14,49 +14,48 @@ logger = logging.getLogger('ChannelCumPainter')
 class ChannelCovPainter(ChannelPainter):
     def __init__(self, start_time: int, end_time: int, chnames: set = None, card_types: set = None, spec: int = None, filter_wave: int = None):
         self._reader = ChannelReader()
-        if filter_wave is None:
-            filter_wave = 3600
+        filter_wave = filter_wave or 3600
         self._chnames, self._card_types, self._spec, self._filter_wave = chnames, card_types, spec, filter_wave
-        _days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
         reader = self._reader
-        self._days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
-
-        tuple_pathes = reader.many_tuple_path(self._days, self._chnames, self._card_types, self._spec)
-        gen = ratio_pathes(reader, tuple_pathes, self._days, self._spec)
-        if len(self._days) == 0:
+        days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
+        if len(days) == 0:
             return BytesIO()
 
-        day_stamp = self._days[0]
+        tuple_pathes = reader.many_tuple_path(days, self._chnames, self._card_types, self._spec)
+        gen = ratio_pathes(reader, tuple_pathes, days, self._spec)
+        day_stamp = days[0]
+
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
+
         x = np.array([d - self._start_time for d in range(self._start_time, self._end_time)])
         window = np.ones(self._filter_wave)
 
         left_len = self._start_time - _start_time
-        right_len = _end_time - self._end_time
+        right_len = 0
 
         stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        logger.debug("near_stamp start_time %d, %s end_time=%s left_len=%d right_len=%d",
+        logger.debug("start_time %d, %s end_time=%s left_len=%d right_len=%d",
                      self._start_time, stime(self._start_time), stime(self._end_time),left_len,right_len)
 
         chname_ratios = []
         for _chname, _card_type, _spec, _data in gen:
-            succ, count, y = calc_cov_chratios(_data, pos_map, _start_time - day_stamp, _end_time - day_stamp, window, left_len,right_len)
+            succ, count, y = calc_cov_chratios(_data, pos_map, _start_time - day_stamp, _end_time - day_stamp, window, left_len, right_len)
             label, ratio = self._label(chname=_chname, succ=succ, count=count, card_type=_card_type, spec=_spec)
             ax.plot(x, y, ls='-', label=label)
             if _card_type is None and _spec is None and _chname != 'all':
                 chname_ratios.append((_chname, ratio))
 
-        ticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
-        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in ticks]
-        buf = fig_flush(ax, fig, ticks, xlables)
+        xticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
+        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in xticks]
+        buf = fig_flush(ax, fig, xticks, xlables)
 
         chname_ratios = sorted(chname_ratios, key=lambda x: (x[1], x[0]), reverse=True)
         result = []
         for name, ratio in chname_ratios:
             result.append(f'{name}:{ratio}')
-
         return buf, result

plot/refill/ChannelCovSuccPainter.py

@@ -14,32 +14,32 @@ logger = logging.getLogger('ChannelCumPainter')
 class ChannelCovSuccPainter(ChannelPainter):
     def __init__(self, start_time: int, end_time: int, chnames: set = None, card_types: set = None, spec: int = None, filter_wave: int = None):
         self._reader = ChannelReader()
-        if filter_wave is None:
-            filter_wave = 3600
+        filter_wave = filter_wave or 3600
         self._chnames, self._card_types, self._spec, self._filter_wave = chnames, card_types, spec, filter_wave
-        _days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
         reader = self._reader
-        self._days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
-
-        tuple_pathes = reader.many_tuple_path(self._days, self._chnames, self._card_types, self._spec)
-        gen = ratio_pathes(reader, tuple_pathes, self._days, self._spec)
-        if len(self._days) == 0:
+        days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
+        if len(days) == 0:
             return BytesIO()
 
-        day_stamp = self._days[0]
+        tuple_pathes = reader.many_tuple_path(days, self._chnames, self._card_types, self._spec)
+        gen = ratio_pathes(reader, tuple_pathes, days, self._spec)
+        day_stamp = days[0]
+
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
+
         x = np.array([d - self._start_time for d in range(self._start_time, self._end_time)])
         window = np.ones(self._filter_wave)
 
         left_len = self._start_time - _start_time
-        right_len = _end_time - self._end_time
+        right_len = 0
 
         stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        logger.debug("near_stamp start_time %d, %s end_time=%s left_len=%d right_len=%d",
+        logger.debug("start_time %d, %s end_time=%s left_len=%d right_len=%d",
                      self._start_time, stime(self._start_time), stime(self._end_time),left_len,right_len)
 
         chname_ratios = []
@@ -52,7 +52,7 @@ class ChannelCovSuccPainter(ChannelPainter):
             if _card_type is None and _spec is None and _chname != 'all':
                 chname_ratios.append((_chname, ratio))
 
-        ticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
+        ticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
         xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in ticks]
         buf = fig_flush(ax, fig, ticks, xlables)
 
@@ -76,7 +76,6 @@ class ChannelCovSuccPainter(ChannelPainter):
             ax.set_xticklabels(lables)
             fig.autofmt_xdate()
             ax.grid()
-            # fig.subplots_adjust(left=0.1, right=0.8, top=0.95, bottom=0.1)
             ax.legend(bbox_to_anchor=(1, 1), loc='upper left')
             fig.tight_layout()
 

plot/refill/ChannelCumPainter.py

@@ -14,18 +14,21 @@ logger = logging.getLogger('ChannelCumPainter')
 class ChannelCumPainter(ChannelPainter):
     def __init__(self, start_time: int, end_time: int, chnames: set = None, card_types: set = None, spec: int = None, filter_wave: int = None):
         self._reader = ChannelReader()
+        filter_wave = filter_wave or 0
         self._chnames, self._card_types, self._spec, self._filter_wave = chnames, card_types, spec, filter_wave
-        self._days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
         reader = ChannelReader()
-        tuple_pathes = reader.many_tuple_path(self._days, self._chnames, self._card_types, self._spec)
-        gen = ratio_pathes(self._reader, tuple_pathes, self._days, self._spec)
-        if len(self._days) == 0:
+        days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
+
+        tuple_pathes = reader.many_tuple_path(days, self._chnames, self._card_types, self._spec)
+        gen = ratio_pathes(reader, tuple_pathes, days, self._spec)
+        if len(days) == 0:
             return BytesIO()
+        day_stamp = days[0]
 
-        day_stamp = self._days[0]
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
         x = np.array([d - self._start_time for d in range(self._start_time, self._end_time)])
@@ -35,19 +38,23 @@ class ChannelCumPainter(ChannelPainter):
         else:
             window = None
 
+        left_len = self._start_time - _start_time
+        right_len = 0
+
         stime = lambda t: time.strftime('%d-%H:%M:%S', time.localtime(t))
-        logger.debug("near_stamp start_time %d , %s end_time=%s", self._start_time, stime(self._start_time), stime(self._end_time))
+        logger.debug("start_time %d , %s end_time=%s", self._start_time, stime(self._start_time), stime(self._end_time))
 
         chname_ratios = []
         for _chname, _card_type, _spec, _data in gen:
-            succ, count, y = calc_chratios(_data, pos_map, self._start_time - day_stamp, self._end_time - day_stamp)
-            y = np.convolve(y, window, 'same') if window is not None else y
+            succ, count, y = calc_chratios(_data, pos_map, _start_time - day_stamp, _end_time - day_stamp, window, left_len, right_len)
             label, ratio = self._label(chname=_chname, succ=succ, count=count, card_type=_card_type, spec=_spec)
             ax.plot(x, y, ls='-', label=label)
             if _card_type is None and _spec is None and _chname != 'all':
                 chname_ratios.append((_chname, ratio))
 
         ticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
+
+        ticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
         xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in ticks]
         buf = fig_flush(ax, fig, ticks, xlables)
 

plot/refill/DataStream.py

@@ -56,7 +56,7 @@ def calc_interval(start, end):
     if segment == 0:
         return 1
     else:
-        intervals = [30, 60, 300, 600, 900, 1800, 3600, 7200, 14400, 21600, 28800, 36000, 43200, 86400, 172800]
+        intervals = [30, 60, 300, 600, 900, 1800, 3600, 5400, 7200, 10800, 14400, 21600, 28800, 36000, 43200, 86400, 172800]
         for i in intervals:
             if segment < i:
                 return i
@@ -66,12 +66,13 @@ def calc_interval(start, end):
 def span_days(start_time, end_time):
     start_day = day_stamp(start_time)
     end_day = day_stamp(end_time)
+    if end_day == end_time:
+        end_day = end_day - 1
 
     days = list()
     while start_day <= end_day:
         days.append(start_day)
         start_day += 86400
-
     return days
 
 
@@ -194,19 +195,6 @@ class DataReadStream(metaclass=ABCMeta):
             logger.error(ex)
             return []
 
-    def near_stamp(self, time_stamp, left=True):
-        if len(self._days) == 0:
-            return None
-
-        if left:
-            min = self._days[0]
-            time_stamp = min if time_stamp < min else time_stamp
-        else:
-            # max = self._days[-1] + 86400 - 1
-            max = int(time.time())
-            time_stamp = max if time_stamp > max else time_stamp
-
-        return time_stamp
 
 class EMchPosmap(IntEnum):
     submit_count = 0

plot/refill/MerchantCovRatioPainter.py

@@ -14,21 +14,21 @@ logger = logging.getLogger('MerchantCovRatioPainter')
 class MerchantCovRatioPainter(MerchantPainter):
     def __init__(self, start_time: int, end_time: int, mchids: set = None, card_types: set = None, spec: int = None, filter_wave: int = None):
         self._reader = MerchantReader()
-        if filter_wave is None:
-            filter_wave = 3600
+        filter_wave = filter_wave or 3600
         self._mchids, self._card_types, self._spec, self._filter_wave = mchids, card_types, spec, filter_wave
-        _days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
         reader = self._reader
-        self._days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
-        tuple_pathes = self._reader.many_tuple_path(self._days, self._mchids, self._card_types, self._spec)
-        gen = allpathes(self._reader, tuple_pathes, self._days, self._spec)
-        if len(self._days) == 0:
+        days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
+        if len(days) == 0:
             return BytesIO()
 
-        day_stamp = self._days[0]
+        tuple_pathes = self._reader.many_tuple_path(days, self._mchids, self._card_types, self._spec)
+        gen = allpathes(reader, tuple_pathes, days, self._spec)
+        day_stamp = days[0]
+
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
 
@@ -46,7 +46,7 @@ class MerchantCovRatioPainter(MerchantPainter):
             if _card_type is None and _spec is None and type(_mchid) is int:
                 mchid_ratios.append((_mchid, ratio))
 
-        xticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
+        xticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
         xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in xticks]
         buf = fig_flush(ax, fig, xticks=xticks, xlables=xlables)
 

plot/refill/MerchantCumRatioPainter.py

@@ -14,17 +14,21 @@ logger = logging.getLogger('MerchantCumRatioPainter')
 class MerchantCumRatioPainter(MerchantPainter):
     def __init__(self, start_time: int, end_time: int, mchids: set = None, card_types: set = None, spec: int = None, filter_wave: int = None):
         self._reader = MerchantReader()
+        filter_wave = filter_wave or 0
         self._mchids, self._card_types, self._spec, self._filter_wave = mchids, card_types, spec, filter_wave
-        self._days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
-        tuple_pathes = self._reader.many_tuple_path(self._days, self._mchids, self._card_types, self._spec)
-        gen = allpathes(self._reader, tuple_pathes, self._days, self._spec)
-        if len(self._days) == 0:
+        reader = self._reader
+        days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time - self._filter_wave, self._end_time)
+        if len(days) == 0:
             return BytesIO()
 
-        day_stamp = self._days[0]
+        tuple_pathes = reader.many_tuple_path(days, self._mchids, self._card_types, self._spec)
+        gen = allpathes(reader, tuple_pathes, days, self._spec)
+        day_stamp = days[0]
+
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
         x = np.array([d - self._start_time for d in range(self._start_time, self._end_time)])
@@ -34,16 +38,17 @@ class MerchantCumRatioPainter(MerchantPainter):
         else:
             window = None
 
+        left_len = self._start_time - _start_time
+        right_len = _end_time - self._end_time
         mchid_ratios = []
         for _mchid, _card_type, _spec, _data in gen:
-            succ, count, y = calc_mchratios(_data, pos_map, self._start_time - day_stamp, self._end_time - day_stamp)
-            y = np.convolve(y, window, 'same') if window is not None else y
+            succ, count, y = calc_mchratios(_data, pos_map, _start_time - day_stamp, _end_time - day_stamp, window, left_len, right_len)
             label, ratio = self._label(chname=_mchid, succ=succ, count=count, card_type=_card_type, spec=_spec)
             ax.plot(x, y, ls='-', label=label)
             if _card_type is None and _spec is None and type(_mchid) is int:
                 mchid_ratios.append((_mchid, ratio))
 
-        xticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
+        xticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
         xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in xticks]
 
         buf = fig_flush(ax, fig, xticks=xticks, xlables=xlables)

plot/refill/NetcheckCovPainter.py

@@ -14,45 +14,39 @@ logger = logging.getLogger('NetcheckCovPainter')
 class NetcheckCovPainter(NetcheckPainter):
     def __init__(self, start_time: int, end_time: int, chnames: set = None, filter_wave: int = None):
         self._reader = NetchkReader()
-        if filter_wave is None:
-            filter_wave = 3600
+        filter_wave = filter_wave or 3600
         self._chnames, self._filter_wave = chnames, filter_wave
-        _days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
+        self._days, self._start_time, self._end_time, self._interval = self.calc_time(self._reader, start_time, end_time)
         pass
 
     def paint(self):
         reader = self._reader
-        self._days, _start_time, _end_time, _interval = self.calc_time(self._reader, self._start_time, self._end_time)
-
-        tuple_pathes = reader.many_tuple_path(self._days, self._chnames)
-        gen = net_pathes(reader, tuple_pathes, self._days)
         if len(self._days) == 0:
             return BytesIO()
 
+        tuple_pathes = reader.many_tuple_path(self._days, self._chnames)
+        gen = net_pathes(reader, tuple_pathes, self._days)
         day_stamp = self._days[0]
+
         fig_create, fig_flush = self._fig_funs()
         ax, fig = fig_create()
         x = np.array([d - self._start_time for d in range(self._start_time, self._end_time)])
         window = np.ones(self._filter_wave)
 
-        left_len = self._start_time - _start_time
-        right_len = _end_time - self._end_time
-
         stime = lambda t: time.strftime('%y-%m-%d %H:%M:%S', time.localtime(t))
-        logger.debug("near_stamp start_time %d, %s end_time=%s left_len=%d right_len=%d",
-                     self._start_time, stime(self._start_time), stime(self._end_time),left_len,right_len)
+        logger.debug("start_time %d, %s end_time=%s", self._start_time, stime(self._start_time), stime(self._end_time))
 
         chname_ratios = []
         for _chname, _data in gen:
-            fail, fails, count = calc_cov_netfail(_data, pos_map, _start_time - day_stamp, _end_time - day_stamp, window, left_len,right_len)
+            fail, fails, count = calc_cov_netfail(_data, pos_map, self._start_time - day_stamp, self._end_time - day_stamp, window)
             label, ratio = self._label(chname=_chname, succ=fails, count=count)
             ax.plot(x, fail, ls='-', label=label)
             if _chname != 'all':
                 chname_ratios.append((_chname, ratio))
 
-        ticks = [d - self._start_time for d in range(self._start_time, self._end_time + 1, self._interval)]
-        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in ticks]
-        buf = fig_flush(ax, fig, ticks, xlables)
+        xticks = self.calc_xticks(self._start_time, self._end_time, self._interval)
+        xlables = [time.strftime('%d-%H:%M:%S', time.localtime(d + self._start_time)) for d in xticks]
+        buf = fig_flush(ax, fig, xticks, xlables)
 
         chname_ratios = sorted(chname_ratios, key=lambda x: (x[1], x[0]), reverse=True)
         result = []

plot/refill/PainterBase.py

@@ -21,29 +21,31 @@ class PainterBase(object):
         return self._redis_client
 
     def calc_time(self, reader, start_time: int, end_time: int):
-        if end_time is None:
-            end_time = int(time.time())
-        end_time = reader.near_stamp(end_time, False)
-        if end_time is None:
-            raise Exception('data is empty')
-
+        end_time = end_time or int(time.time())
         if start_time is None or start_time > end_time:
             start_time = end_time - 7200
 
-        start_time = reader.near_stamp(start_time, True)
-        if start_time is None:
-            raise Exception('data is empty')
-
         stime = lambda t: time.strftime('%y-%m-%d %H:%M:%S', time.localtime(t))
-
         interval = calc_interval(start_time, end_time)
-        logger.debug("near_stamp start_time %d=%s end_time=%s interval=%d", start_time, stime(start_time), stime(end_time), interval)
-        start_time = time_border(interval, start_time, True)
-        end_time = time_border(interval, end_time, False)
-        logger.debug("time_border start_time %d , %s end_time=%s", start_time, stime(start_time), stime(end_time))
+        logger.debug("start_time %d=%s end_time=%s interval=%d", start_time, stime(start_time), stime(end_time), interval)
 
         days = span_days(start_time, end_time)
         sdays = [stime(day) for day in days]
         logger.debug(sdays)
 
-        return days, start_time, end_time, interval
+        return days, start_time, end_time, interval
+
+    def calc_xticks(self,start,end,interval):
+        ticks = []
+        _start = start
+        while True:
+            if start < end:
+                ticks.append(start - _start)
+                if start % interval == 0:
+                    start += interval
+                else:
+                    start += interval - start % interval
+            else:
+                ticks.append(end - _start)
+                break
+        return ticks

plot/refill/algorithm.py

@@ -5,43 +5,56 @@ import logging
 logger = logging.getLogger('calcer')
 
 
-def calc_chratios(data, pos_map, start, end):
+def calc_chratios(data, pos_map, start, end, window, left_len, right_len):
     view = data[[pos_map.succ_count, pos_map.fail_count, pos_map.commit_count], :]
     all = view[:, start:end]
 
     view = np.cumsum(all, axis=1)
     succ = view[0, :]
     fail = view[1, :]
-    commit = succ + fail + 0.0000001
+    commit = view[2, :] + 0.0000001
     y = succ / commit
     y = y.ravel()
 
-    return int(view[0, -1]), int(view[0, -1] + view[1, -1]), y
+    if window is not None:
+        y = np.convolve(y, window, 'same')
+    y = y[left_len:end - start - right_len]
 
-def calc_cov_chratios(data, pos_map, start, end, window, left_len,right_len):
+    cur = all[:, left_len:end - start - right_len]
+    sums = np.sum(cur, axis=1)
+    succs = int(sums[0])
+    fails = int(sums[1])
+    commits = int(sums[1])
+
+    return succs, commits, y
+
+def calc_cov_chratios(data, pos_map, start, end, window, left_len,right_len = 0):
     view = data[[pos_map.succ_count, pos_map.fail_count, pos_map.commit_count], :]
 
     sum_view = view[:, start + left_len:end - right_len]
     sums = np.sum(sum_view, axis=1)
-    succs = sums[0]
-    fails = sums[1]
+    succs = int(sums[0])
+    fails = int(sums[1])
+    commits = int(sums[2])
 
     view = view[:, start:end]
     succ = view[0, :]
     fail = view[1, :]
-    succ = np.convolve(succ, window, 'same')
-    fail = np.convolve(fail, window, 'same')
+    if window is not None:
+        succ = np.convolve(succ, window, 'same')
+        fail = np.convolve(fail, window, 'same')
     commit = succ + fail + 0.0000001
     y = succ / commit
     y = y[left_len:end - start - right_len]
 
-    return int(succs), int(succs + fails), y
+    return succs, commits, y
 
 def calc_cov_chsuccs(data, pos_map, start, end, window, left_len,right_len):
     view = data[[pos_map.succ_count, pos_map.fail_count, pos_map.commit_count], :]
     view = view[:, start:end]
 
-    sums = np.sum(view, axis=1)
+    cur = view[:, left_len:end - start - right_len]
+    sums = np.sum(cur, axis=1)
     succs = int(sums[0])
     fails = int(sums[1])
 
@@ -88,17 +101,26 @@ def calc_commit(data, pos_map, start, end):
     return commit_count
 
 
-def calc_mchratios(data, pos_map, start, end):
+def calc_mchratios(data, pos_map, start, end, window, left_len, right_len):
     view = data[[pos_map.succ_count, pos_map.fail_count, pos_map.submit_count], :]
-    view = view[:, start:end]
 
+    sum_view = view[:, start + left_len:end - right_len]
+    sums = np.sum(sum_view, axis=1)
+    succs = int(sums[0])
+    fails = int(sums[1])
+    commits = int(sums[2])
+
+    view = view[:, start:end]
     all = np.cumsum(view, axis=1)
     succ = all[0, :]
-    commit = all[0, :] + all[1, :]
-    commit += 0.0000001
+    commit = all[2, :] + 0.0000001
     y = succ / commit
     y = y.ravel()
-    return int(all[0, -1]), int(all[0, -1] + all[1, -1]), y
+    if window is not None:
+        y = np.convolve(y, window, 'same')
+    y = y[left_len:end - start - right_len]
+
+    return succs, commits, y
 
 def calc_mchratios_val(data, pos_map, start, end):
     view = data[[pos_map.succ_count, pos_map.fail_count, pos_map.submit_count], :]
@@ -178,7 +200,8 @@ def calc_mch_profit(data, pos_map: type(EMchPosmap), start: int, end: int):
 
     return int(submit_count), int(succ_count), int(fail_count), round(succ_ratio, 5), round(profit, 3)
 
-def calc_cov_netfail(data, pos_map, start, end, window, left_len,right_len):
+
+def calc_cov_netfail(data, pos_map, start, end, window):
     view = data[[pos_map.succ_count, pos_map.fail_count], :]
     view = view[:, start:end]
 
@@ -191,8 +214,5 @@ def calc_cov_netfail(data, pos_map, start, end, window, left_len,right_len):
     succ = np.convolve(succ, window, 'same')
     fail = np.convolve(fail, window, 'same')
 
-    succ = succ[left_len:end - start - right_len]
-    fail = fail[left_len:end - start - right_len]
-
     fail = fail / (fail + succ + 0.0000001)
     return fail, fails, (succs + fails)