utilskit 0.2.11__tar.gz → 0.2.13__tar.gz

{utilskit-0.2.11/utilskit.egg-info → utilskit-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utilskit
-Version: 0.2.11
+Version: 0.2.13
 Summary: 다양한 편의성 함수 모음 패키지
 Author-email: kimyh <kim_yh663927@naver.com>
 Classifier: Programming Language :: Python :: 3
@@ -17,6 +17,10 @@ Requires-Dist: tqdm==4.67.1
 Requires-Dist: xlrd==2.0.2
 Requires-Dist: openpyxl==3.1.5
 
+# 0.2.13
+- repeatutils 에 section_union 함수 추가
+# 0.2.12
+- dataframeutils 의 fill_repeat_nan 함수가 NaN 이 딱 하나만 있는 경우 보정하지 못하는 현상 수정
 # 0.2.11
 - dataframeutils 의 fill_repeat_nan 함수가 3 이하 반복되는 NaN 이 아닌 3 이상 반복되는 NaN 구간에 대해 보정하는 현상 수정
 # 0.2.10

{utilskit-0.2.11 → utilskit-0.2.13}/README.md

@@ -1,3 +1,7 @@
+# 0.2.13
+- repeatutils 에 section_union 함수 추가
+# 0.2.12
+- dataframeutils 의 fill_repeat_nan 함수가 NaN 이 딱 하나만 있는 경우 보정하지 못하는 현상 수정
 # 0.2.11
 - dataframeutils 의 fill_repeat_nan 함수가 3 이하 반복되는 NaN 이 아닌 3 이상 반복되는 NaN 구간에 대해 보정하는 현상 수정
 # 0.2.10

{utilskit-0.2.11 → utilskit-0.2.13}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 name = "utilskit"
 
 # 버전
-version = "0.2.11"
+version = "0.2.13"
 
 # 패키지 설명 (짧은 설명)
 description = "다양한 편의성 함수 모음 패키지"

{utilskit-0.2.11 → utilskit-0.2.13}/test/test.py

@@ -401,20 +401,26 @@ def main16():
 
 def main17():
     from utilskit import repeatutils as rpu
+    from utilskit import dataframeutils as dfu
     import numpy as np
+    import pandas as pd
 
     # data = [1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7]
-    ary = np.array([-1, 0, 1, 2, 3, 4, 111, 1223])
+    ary = np.array([-1, 0, np.nan, 2, 3, 4, np.nan, np.nan, 7, 8, np.nan])
+    df = pd.DataFrame({'value':ary})
+
+    df = dfu.fill_repeat_nan(df, 'value', repeat=5)
+    print(df)
+    sys.exit()
+
     # data = ['아', '메', '리', '카']
     section = rpu.get_section(
-            data=ary,
-            repeat=2,
-            max_key=99,
-            min_key=1,
-            max_equal=False,
-            min_equal=False,
-            between=True
-        )
+        data=ary,
+        key='nan',
+        except_nan=False,
+        repeat=3,
+        mode='b'
+    )
     # section = rpu.get_section(data=data_tf, repeat=w_re, key=75)
     print(section)
 

{utilskit-0.2.11 → utilskit-0.2.13}/utilskit/dataframeutils/dataframeutils.py

@@ -138,6 +138,22 @@ def fill_repeat_nan(dataframe, column, repeat=5):
         repeat=repeat,
         mode='b'
     )
+
+    # NaN 가 하나만 있는 경우
+    for i, d in enumerate(stan_ary):
+        if str(d) == 'nan':
+            pre_val = str(stan_ary[i-1])
+            if (i-1) == -1:
+                pre_val = '1'
+            
+            try:
+                next_val = str(stan_ary[i+1])
+            except IndexError:
+                next_val = '1'
+
+            if (pre_val != 'nan') and (next_val != 'nan'):
+                section['nan'].append((i, i))
+    
     # 결측치 채우기
     if len(section) > 0:
         section = section['nan']
@@ -147,6 +163,7 @@ def fill_repeat_nan(dataframe, column, repeat=5):
         for (nan_si, nan_ei) in section:#zip(nan_start_idx_list, nan_end_idx_list):
             df.loc[nan_si-1:nan_ei, column] = df.loc[nan_si-1:nan_ei, column].fillna(method='ffill')
             df.loc[nan_si:nan_ei+1, column] = df.loc[nan_si:nan_ei+1, column].fillna(method='bfill')
+    
     return df
 
 

{utilskit-0.2.11 → utilskit-0.2.13}/utilskit/repeatutils/repeatutils.py

@@ -4,33 +4,33 @@ import numpy as np
 import pandas as pd
 import warnings
 
-__all__ = ['get_section']
-
-
-def issame(value1, value2):
-    # 서로 같은 경우
-    if value1 == value2:
-        return True
-    # 서로 다른 경우
-    else:
-        # 어느 한 쪽 이라도 str type 인 경우
-        if isinstance(value1, str) or isinstance(value2, str):
-            if str(value1) == str(value2):
-                return True # ex) value1 = 1, value2 = '1'
-            else:
-                return False # ex) value1 = 1, value2 = 'nan'
-        # 어느 한 쪽이라도 str type 이 아닌 경우
-        else:
-            # value1 이 NaN 일때
-            if np.isnan(value1):
-                # value2 도 NaN 이면
-                if np.isnan(value2):
-                    return True
-                # value2 가 NaN 이 아니면
-                else:
-                    return False
-            else:
-                return False
+__all__ = ['get_section', 'section_union']
+
+
+# def issame(value1, value2):
+#     # 서로 같은 경우
+#     if value1 == value2:
+#         return True
+#     # 서로 다른 경우
+#     else:
+#         # 어느 한 쪽 이라도 str type 인 경우
+#         if isinstance(value1, str) or isinstance(value2, str):
+#             if str(value1) == str(value2):
+#                 return True # ex) value1 = 1, value2 = '1'
+#             else:
+#                 return False # ex) value1 = 1, value2 = 'nan'
+#         # 어느 한 쪽이라도 str type 이 아닌 경우
+#         else:
+#             # value1 이 NaN 일때
+#             if np.isnan(value1):
+#                 # value2 도 NaN 이면
+#                 if np.isnan(value2):
+#                     return True
+#                 # value2 가 NaN 이 아니면
+#                 else:
+#                     return False
+#             else:
+#                 return False
 
 
 # def get_repeat_section2(data, repeat_num, refer_value=None, except_nan=True):
@@ -95,177 +95,177 @@ def issame(value1, value2):
 
 
 
-def get_repeat_section(data, repeat, except_nan=True):
-    '''
-    데이터 array 에서 정해놓은 반복 횟수 (stan_repeat) 만큼 반복되는 숫자구간이 있다면
-    그 구간의 시작, 끝 위치 index 값을 추출한다.
-    NaN 가 반복되는지 여부를 포함시킬 수 있다.
-    '''
-    ary = data.copy()
+# def get_repeat_section(data, repeat, except_nan=True):
+#     '''
+#     데이터 array 에서 정해놓은 반복 횟수 (stan_repeat) 만큼 반복되는 숫자구간이 있다면
+#     그 구간의 시작, 끝 위치 index 값을 추출한다.
+#     NaN 가 반복되는지 여부를 포함시킬 수 있다.
+#     '''
+#     ary = data.copy()
 
-    value_list = []
-    start_idx_list = []
-    end_idx_list = []
-    start_idx = 0
-    # pre_value = 'nan'
-    repeat_num = 1    
-    for idx, value in enumerate(ary):
+#     value_list = []
+#     start_idx_list = []
+#     end_idx_list = []
+#     start_idx = 0
+#     # pre_value = 'nan'
+#     repeat_num = 1    
+#     for idx, value in enumerate(ary):
         
-        # 가장 처음인 경우
-        if idx == 0:
-            pre_value = value
-            continue
+#         # 가장 처음인 경우
+#         if idx == 0:
+#             pre_value = value
+#             continue
         
-        # 현재 값이 이전 값과 동일할때
-        if issame(value, pre_value):
-            repeat_num += 1
+#         # 현재 값이 이전 값과 동일할때
+#         if issame(value, pre_value):
+#             repeat_num += 1
             
-        # 현재 값이 이전 값과 다를때
-        else:
-            if repeat_num >= repeat:
-                value_list.append(pre_value)
-                start_idx_list.append(start_idx)
-                end_idx_list.append(idx-1)
-            # 시작 지점 갱신 & 반복횟수 초기화
-            start_idx = idx
-            repeat_num = 1
-
-        pre_value = value
-
-    # 마지막 값이 이전 값과 같을때
-    if issame(value, pre_value):
-        if repeat_num >= repeat:
-            value_list.append(value)
-            start_idx_list.append(start_idx)
-            end_idx_list.append(idx)
-    # --------------------------------------
-    # 함수 수정중
-    # 결과 정리
-    # print(value_list)
-    # sys.exit()
-    result = {}
-    for v, si, ei in zip(value_list, start_idx_list, end_idx_list):
-        try:
-            result[str(v)].append((si, ei))
-        except KeyError:
-            result[str(v)] = [(si, ei)]
-    if except_nan:
-        del result['nan']
-    return result
+#         # 현재 값이 이전 값과 다를때
+#         else:
+#             if repeat_num >= repeat:
+#                 value_list.append(pre_value)
+#                 start_idx_list.append(start_idx)
+#                 end_idx_list.append(idx-1)
+#             # 시작 지점 갱신 & 반복횟수 초기화
+#             start_idx = idx
+#             repeat_num = 1
 
+#         pre_value = value
 
-def get_stan_repeat_section(data, value, repeat, mode='a', reverse=False):
-    '''
-    ary 에서 기준값(stan_value)이 지정한 횟수(stan_repeat) 
-    이상(above) 또는 이하(below) 만큼 반복되는 구간의 시작, 끝 위치 index 값을 추출하는 함수
-    reverse 를 True 로 지정하면 해당 각 구간의 끝->시작, 시작->끝 으로 반전된다.
-    mode 는 a (above) 와 b (below)만 존재
-    '''
-    ary = data.copy()
+#     # 마지막 값이 이전 값과 같을때
+#     if issame(value, pre_value):
+#         if repeat_num >= repeat:
+#             value_list.append(value)
+#             start_idx_list.append(start_idx)
+#             end_idx_list.append(idx)
+#     # --------------------------------------
+#     # 함수 수정중
+#     # 결과 정리
+#     # print(value_list)
+#     # sys.exit()
+#     result = {}
+#     for v, si, ei in zip(value_list, start_idx_list, end_idx_list):
+#         try:
+#             result[str(v)].append((si, ei))
+#         except KeyError:
+#             result[str(v)] = [(si, ei)]
+#     if except_nan:
+#         del result['nan']
+#     return result
+
+
+# def get_stan_repeat_section(data, value, repeat, mode='a', reverse=False):
+#     '''
+#     ary 에서 기준값(stan_value)이 지정한 횟수(stan_repeat) 
+#     이상(above) 또는 이하(below) 만큼 반복되는 구간의 시작, 끝 위치 index 값을 추출하는 함수
+#     reverse 를 True 로 지정하면 해당 각 구간의 끝->시작, 시작->끝 으로 반전된다.
+#     mode 는 a (above) 와 b (below)만 존재
+#     '''
+#     ary = data.copy()
 
-    start_idx = 0
-    start_idx_list = []
-    end_idx_list = []
-    repeat_num = 1
+#     start_idx = 0
+#     start_idx_list = []
+#     end_idx_list = []
+#     repeat_num = 1
 
-    if len(ary) == 0:
-        return [], []
+#     if len(ary) == 0:
+#         return [], []
             
-    # stan_value = float(stan_value)
-    for idx, val_ in enumerate(ary):
+#     # stan_value = float(stan_value)
+#     for idx, val_ in enumerate(ary):
 
-        # 가장 처음인 경우
-        if idx == 0:
-            pre_value = val_
-            continue
+#         # 가장 처음인 경우
+#         if idx == 0:
+#             pre_value = val_
+#             continue
 
-        # 현재 값이 기준값(stan_value) 인 경우
-        if issame(val_, value):
-            # 이전값이 기준값과 동일하면
-            if issame(pre_value, value):
-                # 반복횟수 +1
-                repeat_num += 1
-            # 이전 값이 기준값과 다르면
-            else:
-                # 반복횟수 초기화
-                repeat_num = 1
-                # 현재 위치를 시작로 위치 지정
-                start_idx = idx
-        # 현재 값이 기준값과 다른 경우
-        else:
-            # 이전 값이 기준값과 동일하면
-            if issame(pre_value, value):
-                # idx 끝 위치 지정
-
-                # 반복 횟수 기준 이상인 경우
-                if mode == 'a':
-                    # 기록된 반복 횟수가 기준 횟수 이상이면
-                    if repeat_num >= repeat:
-                        # 지정해둔 시작 위치 index 값을 구간시작 index 로 저장
-                        start_idx_list.append(start_idx)
-                        # 현재 위치 바로 이전 위치 index 값을 구간끝 index 로 저장
-                        end_idx_list.append(idx-1)
-                # 반복 횟수 기준 이하인 경우
-                elif mode == 'b':
-                    # 기록된 반복 횟수가 기준 횟수 이하면
-                    if repeat_num <= repeat:
-                        start_idx_list.append(start_idx)
-                        end_idx_list.append(idx-1)
-                elif mode == 'e':
-                    # 기록된 반복 횟수가 기준 횟수와 동일하면
-                    if repeat_num == repeat:
-                        start_idx_list.append(start_idx)
-                        end_idx_list.append(idx-1)
-                else:
-                    print('mode 를 a (above:이상), b (below:이하) 또는 e (equal:동일) 중 하나로 지정해주세요')
-                    raise KeyError()
-        # 현재 위치 값을 이전 위치로 저장
-        pre_value = val_
+#         # 현재 값이 기준값(stan_value) 인 경우
+#         if issame(val_, value):
+#             # 이전값이 기준값과 동일하면
+#             if issame(pre_value, value):
+#                 # 반복횟수 +1
+#                 repeat_num += 1
+#             # 이전 값이 기준값과 다르면
+#             else:
+#                 # 반복횟수 초기화
+#                 repeat_num = 1
+#                 # 현재 위치를 시작로 위치 지정
+#                 start_idx = idx
+#         # 현재 값이 기준값과 다른 경우
+#         else:
+#             # 이전 값이 기준값과 동일하면
+#             if issame(pre_value, value):
+#                 # idx 끝 위치 지정
+
+#                 # 반복 횟수 기준 이상인 경우
+#                 if mode == 'a':
+#                     # 기록된 반복 횟수가 기준 횟수 이상이면
+#                     if repeat_num >= repeat:
+#                         # 지정해둔 시작 위치 index 값을 구간시작 index 로 저장
+#                         start_idx_list.append(start_idx)
+#                         # 현재 위치 바로 이전 위치 index 값을 구간끝 index 로 저장
+#                         end_idx_list.append(idx-1)
+#                 # 반복 횟수 기준 이하인 경우
+#                 elif mode == 'b':
+#                     # 기록된 반복 횟수가 기준 횟수 이하면
+#                     if repeat_num <= repeat:
+#                         start_idx_list.append(start_idx)
+#                         end_idx_list.append(idx-1)
+#                 elif mode == 'e':
+#                     # 기록된 반복 횟수가 기준 횟수와 동일하면
+#                     if repeat_num == repeat:
+#                         start_idx_list.append(start_idx)
+#                         end_idx_list.append(idx-1)
+#                 else:
+#                     print('mode 를 a (above:이상), b (below:이하) 또는 e (equal:동일) 중 하나로 지정해주세요')
+#                     raise KeyError()
+#         # 현재 위치 값을 이전 위치로 저장
+#         pre_value = val_
     
-    # 가장 마지막 데이터가 기준값과 동일한 경우
-    if issame(val_, value):
-        if mode == 'a':
-            if repeat_num >= repeat:
-                start_idx_list.append(start_idx)
-                # 현재 위치 index 를 구간 끝 index 로 저장
-                end_idx_list.append(idx)
-        elif mode == 'b':
-            if repeat_num <= repeat:
-                start_idx_list.append(start_idx)
-                end_idx_list.append(idx)
-        elif mode == 'e':
-            if repeat_num == repeat:
-                start_idx_list.append(start_idx)
-                end_idx_list.append(idx)
-        else:
-            raise KeyError('mode 를 a (above:이상), b (below:이하) 또는 e (equal:동일) 중 하나로 지정해주세요')
-    # 가장 마지막 데이터가 기준값과 다르면 반복 계산할 필요 없음
+#     # 가장 마지막 데이터가 기준값과 동일한 경우
+#     if issame(val_, value):
+#         if mode == 'a':
+#             if repeat_num >= repeat:
+#                 start_idx_list.append(start_idx)
+#                 # 현재 위치 index 를 구간 끝 index 로 저장
+#                 end_idx_list.append(idx)
+#         elif mode == 'b':
+#             if repeat_num <= repeat:
+#                 start_idx_list.append(start_idx)
+#                 end_idx_list.append(idx)
+#         elif mode == 'e':
+#             if repeat_num == repeat:
+#                 start_idx_list.append(start_idx)
+#                 end_idx_list.append(idx)
+#         else:
+#             raise KeyError('mode 를 a (above:이상), b (below:이하) 또는 e (equal:동일) 중 하나로 지정해주세요')
+#     # 가장 마지막 데이터가 기준값과 다르면 반복 계산할 필요 없음
     
-    # 반전
-    if reverse:
-        rev_start_idx_list = [0]
-        rev_end_idx_list = [len(ary)-1]
-        for ns_idx, ne_idx in zip(start_idx_list, end_idx_list):
-            if ns_idx == 0:
-                rev_start_idx_list.pop(0)
-                rev_start_idx_list.append(ne_idx+1)
-                continue
-            if ne_idx == len(ary)-1:
-                rev_end_idx_list.pop(-1)
-                rev_end_idx_list.append(ns_idx-1)
-                continue
-            rev_start_idx_list.append(ne_idx+1)
-            rev_end_idx_list.insert(-1, ns_idx-1)
+#     # 반전
+#     if reverse:
+#         rev_start_idx_list = [0]
+#         rev_end_idx_list = [len(ary)-1]
+#         for ns_idx, ne_idx in zip(start_idx_list, end_idx_list):
+#             if ns_idx == 0:
+#                 rev_start_idx_list.pop(0)
+#                 rev_start_idx_list.append(ne_idx+1)
+#                 continue
+#             if ne_idx == len(ary)-1:
+#                 rev_end_idx_list.pop(-1)
+#                 rev_end_idx_list.append(ns_idx-1)
+#                 continue
+#             rev_start_idx_list.append(ne_idx+1)
+#             rev_end_idx_list.insert(-1, ns_idx-1)
         
-        start_idx_list = rev_start_idx_list.copy()
-        end_idx_list = rev_end_idx_list.copy()
+#         start_idx_list = rev_start_idx_list.copy()
+#         end_idx_list = rev_end_idx_list.copy()
     
-    # 결과 정리
-    result = []
-    for si, ei in zip(start_idx_list, end_idx_list):
-        result.append((si, ei))
+#     # 결과 정리
+#     result = []
+#     for si, ei in zip(start_idx_list, end_idx_list):
+#         result.append((si, ei))
 
-    return result
+#     return result
 
 
 
@@ -501,4 +501,41 @@ def get_section(data, repeat, mode='a', key=None,
             rev_result[f'{k}_rev'] = rev_section
         return rev_result
 
-    return result
+    return result
+
+
+def section_union(main_section, sub_section, mode):
+
+    if len(main_section) == 0 or len(sub_section) == 0:
+        return main_section
+
+    m_min_idx = main_section[0][0]
+    m_max_idx = main_section[-1][1]
+    s_min_idx = sub_section[0][0]
+    s_max_idx = sub_section[-1][1]
+
+    max_idx = max([m_max_idx, s_max_idx])
+
+    main_ary = np.zeros(max_idx+1)
+    sub_ary = np.zeros(max_idx+1)
+
+    for m_sec in main_section:
+        main_ary[m_sec[0]:m_sec[1]+1] = -1
+
+    for s_sec in sub_section:
+        sub_ary[s_sec[0]:s_sec[1]+1] = 100
+
+    whole_ary = main_ary + sub_ary
+    if mode == '-':
+        com_ary = np.where(whole_ary==-1, 1, 0)
+    elif mode == '+':
+        com_ary = np.where((whole_ary>=99) | (whole_ary<=-1), 1, 0)
+    elif mode == '&':
+        com_ary = np.where(whole_ary==99, 1, 0)
+    new_section = rpu.get_section(
+        data=com_ary,
+        repeat=2,
+        key=1
+    )
+    section_list = list(new_section.values())[0]
+    return section_list

{utilskit-0.2.11 → utilskit-0.2.13/utilskit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utilskit
-Version: 0.2.11
+Version: 0.2.13
 Summary: 다양한 편의성 함수 모음 패키지
 Author-email: kimyh <kim_yh663927@naver.com>
 Classifier: Programming Language :: Python :: 3
@@ -17,6 +17,10 @@ Requires-Dist: tqdm==4.67.1
 Requires-Dist: xlrd==2.0.2
 Requires-Dist: openpyxl==3.1.5
 
+# 0.2.13
+- repeatutils 에 section_union 함수 추가
+# 0.2.12
+- dataframeutils 의 fill_repeat_nan 함수가 NaN 이 딱 하나만 있는 경우 보정하지 못하는 현상 수정
 # 0.2.11
 - dataframeutils 의 fill_repeat_nan 함수가 3 이하 반복되는 NaN 이 아닌 3 이상 반복되는 NaN 구간에 대해 보정하는 현상 수정
 # 0.2.10