pathpilot 0.2.0__tar.gz → 0.2.2__tar.gz

{pathpilot-0.2.0 → pathpilot-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pathpilot
-Version: 0.2.0
+Version: 0.2.2
 Summary: Library that facilitates file and folder manipulation in Python.
 Home-page: https://github.com/zteinck/pathpilot
 License: MIT
@@ -15,10 +15,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: XlsxWriter
-Requires-Dist: cachegrab
-Requires-Dist: clockwork
+Requires-Dist: cachegrab (>=0.2.2)
+Requires-Dist: clockwork (>=0.2.2)
 Requires-Dist: numpy
-Requires-Dist: oddments
+Requires-Dist: oddments (>=0.2.0)
 Requires-Dist: pandas
 Project-URL: Repository, https://github.com/zteinck/pathpilot
 Description-Content-Type: text/markdown

{pathpilot-0.2.0 → pathpilot-0.2.2}/pathpilot/__init__.py

@@ -3,5 +3,5 @@ from .decorators import *
 from .exceptions import *
 from .utils import *
 
-__version__ = '0.2.0'
+__version__ = '0.2.2'
 __author__ = 'Zachary Einck <zacharyeinck@gmail.com>'

pathpilot-0.2.2/pathpilot/_file/__init__.py

@@ -0,0 +1,10 @@
+from .utils import get_size_label
+
+from .base import FileBase
+
+from ._csv import CSVFile
+from ._excel import ExcelFile
+from ._pickle import PickleFile
+from ._sqlite import SQLiteFile
+from ._text import TextFile
+from ._zip import ZipFile

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_csv.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import oddments as odd
 
-from ._file import FileBase
+from .base import FileBase
 
 
 class CSVFile(FileBase):

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_excel.py

@@ -1,6 +1,7 @@
 from collections import OrderedDict
 from functools import cached_property
 from copy import deepcopy
+import datetime
 import sys
 import re
 import pandas as pd
@@ -8,7 +9,7 @@ import numpy as np
 import oddments as odd
 from cachegrab import sha256
 
-from ._file import FileBase
+from .base import FileBase
 from .utils import get_size_label
 
 
@@ -68,13 +69,13 @@ class ExcelFile(FileBase):
     #╰-------------------------------------------------------------------------╯
 
     def __init__(
-            self,
-            f,
-            number_tabs=False,
-            verbose=True,
-            troubleshoot=False,
-            **kwargs
-            ):
+        self,
+        f,
+        number_tabs=False,
+        verbose=True,
+        troubleshoot=False,
+        **kwargs
+        ):
         super().__init__(f, **kwargs)
         self.format_cache = dict()
         self.sheet_cache = dict()
@@ -511,7 +512,7 @@ class ExcelFile(FileBase):
                                   of the list/tuple is shorter than the number
                                   of columns then no format is applied to the
                                   remaining columns.
-                • None ➜ no formatting is applied
+                • None ➜ no formatting is applied.
         inverse : bool
             If True, the 2D data is inverted such that each sub-list is treated
             as column data as opposed to row data under the default behavior.
@@ -555,10 +556,14 @@ class ExcelFile(FileBase):
             updates = dict()
 
             if outer_border:
-                if col == 0: updates['left'] = 1
-                if col == n_cols - 1: updates['right'] = 1
-                if row == 0: updates['top'] = 1
-                if row == n_rows - 1: updates['bottom'] = 1
+                if col == 0:
+                    updates['left'] = 1
+                if col == n_cols - 1:
+                    updates['right'] = 1
+                if row == 0:
+                    updates['top'] = 1
+                if row == n_rows - 1:
+                    updates['bottom'] = 1
                 fmt.update(updates)
 
             return self.get_format(fmt)
@@ -630,6 +635,7 @@ class ExcelFile(FileBase):
         header_format='pandas_header',
         data_format='auto',
         column_widths='auto',
+        date_format=None,
         normalize=True,
         autofilter=False,
         raise_on_empty=True,
@@ -642,10 +648,10 @@ class ExcelFile(FileBase):
         '''
         Description
         ------------
-        Writes a DataFrame to an Excel worksheet. This function is a superior
-        alternative to df.to_excel() because it does not share the same limitations
-        such as not being able format cells that already have a format including
-        the index, headers, and cells that contain dates or datetimes.
+        Writes a DataFrame to an Excel worksheet. This is an alternative to df.to_excel()
+        that addresses some of its limitations such as not being able format cells that
+        already have a format including the index, headers, and cells that contain dates
+        or datetimes.
 
         Parameters
         ------------
@@ -684,6 +690,14 @@ class ExcelFile(FileBase):
             • dict ➜ dictionary where keys are DataFrame column names and values
                            are column widths. Any column names excluded from the
                            dictionary will not have their widths set.
+        date_format : None | str | dict
+            Defines how date-like columns are parsed when data_format='auto'
+            (e.g. '%Y-%m-%d'). Options include:
+            • None ➜ format is inferred.
+            • str ➜ used for all date-like columns.
+            • dict ➜ dictionary where keys are DataFrame column names and values
+                      are formats. Any column names excluded from the dictionary
+                      default to None.
         normalize : bool
             if True, any date columns where the hours, minutes, seconds,
                      microseconds are all set to zero (midnight) will be converted
@@ -714,35 +728,33 @@ class ExcelFile(FileBase):
         None
         '''
 
-        # Type housekeeping
-        if isinstance(df, pd.DataFrame):
-            df = df.copy(deep=True)
-        elif isinstance(df, pd.Series):
-            df = df.to_frame()
-        else:
-            raise TypeError(f"'df' argument type {type(df)} not supported.")
+        df = odd.coerce_dataframe(df)
+
+        odd.validate_value(
+            value=date_format,
+            attr='date_format',
+            types=(str, dict),
+            none_ok=True
+            )
 
         # kwargs housekeeping
-        if kwargs.get('inverse'): raise NotImplementedError
+        if kwargs.get('inverse'):
+            raise NotImplementedError
 
         # Reset index
-        if list(filter(None, list(df.index.names))): df.reset_index(inplace=True)
+        if odd.get_index_names(df):
+            df.reset_index(inplace=True)
 
         # Check if empty
         if df.empty:
             if raise_on_empty:
                 raise ValueError("'df' argument cannot be empty.")
-            if not df.columns.tolist():
+            if len(df.columns) == 0:
                 raise ValueError("'df' argument must have an index or columns")
             total_row, total_column = False, False
 
         # Check for duplicate column names
-        s = df.columns.value_counts()
-        dupes = s[ s > 1 ].to_frame()
-        if len(dupes) > 0:
-            raise ValueError(
-                f"'df' argument cannot have duplicate column names: \n\n{dupes}\n"
-                )
+        odd.verify_no_duplicates(df=df, attr='columns')
 
         # Add a total column to dataframe
         if total_column:
@@ -763,29 +775,16 @@ class ExcelFile(FileBase):
 
         numeric_columns -= percent_columns
 
-        datelike_columns = set(df.select_dtypes(include=[np.datetime64]).columns.tolist())
+        datelike_columns = set(
+            df.select_dtypes(include=[np.datetime64]).columns.tolist()
+            )
 
         for k in df.columns:
             if isinstance(k, str) and \
-               (any(x in k.lower() for x in ('date','time')) or k.lower()[-2:] == 'dt') and \
-               str(df[k].dtype) != 'timedelta64[ns]':
+            odd.column_name_is_datelike(k) and \
+            str(df[k].dtype) != 'timedelta64[ns]':
                 datelike_columns.add(k)
 
-        date_columns, datetime_columns = [], []
-        for k in list(datelike_columns):
-            if not np.issubdtype(df[k].dtype, np.datetime64):
-                try:
-                    df[k] = pd.to_datetime(df[k])
-                except:
-                    datelike_columns.remove(k)
-
-        for k in datelike_columns:
-            if normalize and (df[k].dropna() == df[k].dropna().dt.normalize()).all():
-                df[k] = df[k].dt.date
-                date_columns.append(k)
-            else:
-                datetime_columns.append(k)
-
         # Parse start cell
         start_col, start_row = self.parse_start_cell(start_cell)
 
@@ -801,20 +800,25 @@ class ExcelFile(FileBase):
         # Force data_format to comply with the standard {column name : format}
         if isinstance(data_format, dict):
             if not all(k in df.columns for k in data_format):
-                if any(isinstance(v, (list, tuple, dict)) for v in data_format.values()):
+                if any(isinstance(v, (list, tuple, dict))
+                       for v in data_format.values()):
                     raise ValueError
                 data_format = {k: data_format for k in df.columns}
 
-        # Automatically determine the best formatting options for each dataframe column
+        # Auto-detects the best format for each DataFrame column
         if data_format == 'auto':
             data_format = dict()
 
             # cascade auto formatting
-            if total_row_format is None: total_row_format = 'auto'
-            if total_column_format is None: total_column_format = 'auto'
+            if total_row_format is None:
+                total_row_format = 'auto'
+
+            if total_column_format is None:
+                total_column_format = 'auto'
 
             infer_format = lambda fmt, s: \
-                fmt if s.sum() - s.round().sum() == 0 else f'{fmt}_two_decimals'
+                fmt if s.sum() - s.round().sum() == 0 \
+                else f'{fmt}_two_decimals'
 
             for k in numeric_columns:
                 if not df[k].isna().all():
@@ -831,14 +835,51 @@ class ExcelFile(FileBase):
                         s *= 100
                     data_format[k] = infer_format('percent', s)
 
-            for k in datetime_columns: data_format[k] = 'datetime'
-            for k in date_columns: data_format[k] = 'date'
+            if isinstance(date_format, dict):
+                date_formats = {}
+                for k in datelike_columns:
+                    v = date_format.get(k)
+                    if v is not None:
+                        odd.validate_value(value=v, types=str)
+                        date_formats[k] = v
+            else:
+                date_formats = {k: date_format for k in datelike_columns}
+
+            datetime_columns = set()
+
+            for k in list(datelike_columns):
+                if np.issubdtype(df[k].dtype, np.datetime64): continue
+                fmt = date_formats.get(k)
+                try:
+                    df[k] = pd.to_datetime(df[k], format=fmt)
+                except:
+                    if fmt is None:
+                        datelike_columns.remove(k)
+                    else:
+                        df[k] = df[k].apply(odd.ignore_nan(lambda x: \
+                            datetime.datetime.strptime(x, fmt)
+                            ))
+                        datetime_columns.add(k)
+
+            for k in datelike_columns:
+                data_format[k] = 'datetime'
+                if not normalize: continue
+                s = df[k].dropna()
+                if s.empty: continue
+                if k in datetime_columns:
+                    if all(x.time() == datetime.time(0, 0) for x in s.values):
+                        df[k] = df[k].apply(odd.ignore_nan(lambda x: x.date()))
+                        data_format[k] = 'date'
+                else:
+                    if (s == s.dt.normalize()).all():
+                        df[k] = df[k].dt.date
+                        data_format[k] = 'date'
 
         if isinstance(data_format, str):
             data_format = {k: data_format for k in df.columns}
 
         if isinstance(data_format, (list, tuple)):
-            data_format = {k: v for k,v in zip(df.columns, data_format)}
+            data_format = {k: v for k, v in zip(df.columns, data_format)}
 
         if data_format is not None and not isinstance(data_format, dict):
             raise TypeError(
@@ -882,8 +923,8 @@ class ExcelFile(FileBase):
             start_cell=(start_col + 1, start_row + 2),
             data=df.replace([np.inf, -np.inf], np.nan)\
                    .where(df.notnull(), None).values.tolist(),
-            formatting=[data_format.get(k) for k in df.columns] \
-                       if data_format is not None else None,
+            formatting=None if data_format is None else \
+                       [data_format.get(k) for k in df.columns],
             sheet=sheet,
             **kwargs
             )
@@ -1023,7 +1064,7 @@ class ExcelFile(FileBase):
             OrderedDict((i, k) for i, k in enumerate(sorted(list(set(x)))))
 
         counter = build_counter(rows) if down else build_counter(cols)
-        inverse_counter = {v: k for k,v in counter.items()}
+        inverse_counter = {v: k for k, v in counter.items()}
 
         for c, r in zip(cols, rows):
             x, y = self.get_column_letter(c - 1), str(r)

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_pickle.py

@@ -1,7 +1,7 @@
 import pickle
 import pandas as pd
 
-from ._file import FileBase
+from .base import FileBase
 
 
 class PickleFile(FileBase):

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_sqlite.py

@@ -4,7 +4,7 @@ import pandas as pd
 import numpy as np
 import oddments as odd
 
-from ._file import FileBase
+from .base import FileBase
 
 
 class SQLiteFile(FileBase):

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_text.py

@@ -1,4 +1,4 @@
-from ._file import FileBase
+from .base import FileBase
 
 
 class TextFile(FileBase):

{pathpilot-0.2.0/pathpilot → pathpilot-0.2.2/pathpilot/_file}/_zip.py

@@ -1,9 +1,9 @@
 import zipfile
 import shutil
 
-from ._folder import Folder
-from ._file import FileBase
-from .utils import is_file, is_folder
+from .._folder import Folder
+from ..utils import is_file, is_folder
+from .base import FileBase
 
 
 class ZipFile(FileBase):

pathpilot-0.2.0/pathpilot/_file.py → pathpilot-0.2.2/pathpilot/_file/base.py

@@ -5,28 +5,21 @@ import os
 import pandas as pd
 import numpy as np
 import oddments as odd
+import clockwork as cw
 from cachegrab import sha256
 
-from clockwork import (
-    quarter_end,
-    month_end,
-    day_of_week,
-    year_end,
-    Date,
-    )
-
-from .decorators import check_read_only
-from .exceptions import ReadOnlyError
+from .._folder import Folder
+from ..decorators import check_read_only
+from ..exceptions import ReadOnlyError
 
-from .utils import (
-    get_size_label,
+from ..utils import (
     trifurcate,
     is_file,
     get_created_date,
     get_modified_date,
     )
 
-from ._folder import Folder
+from .utils import get_size_label
 
 
 class FileBase(object):
@@ -513,7 +506,7 @@ class FileBase(object):
     # helper functions adding timestamps to files
     @Decorators.add_timestamp
     def quarter(self, delta=0):
-        return quarter_end(delta=delta).label
+        return cw.quarter_end(delta=delta).label
 
 
     def qtr(self, *args, **kwargs):
@@ -522,21 +515,21 @@ class FileBase(object):
 
     @Decorators.add_timestamp
     def month(self, delta=0):
-        return month_end(delta=delta).ymd
+        return cw.month_end(delta=delta).ymd
 
 
     @Decorators.add_timestamp
     def day(self, weekday, delta=0):
-        return day_of_week(weekday=weekday, delta=delta).ymd
+        return cw.day_of_week(weekday=weekday, delta=delta).ymd
 
 
     @Decorators.add_timestamp
     def year(self, delta=0):
-        return str(year_end(delta=delta).year)
+        return str(cw.year_end(delta=delta).year)
 
 
     @Decorators.add_timestamp
     def timestamp(self, normalize=False, week_offset=0, fmt=None):
-        now = Date(normalize=normalize, week_offset=week_offset)
+        now = cw.Date(normalize=normalize, week_offset=week_offset)
         now = str(now).replace(':','.') if fmt is None else now.str(fmt)
         return now

pathpilot-0.2.2/pathpilot/_file/utils.py

@@ -0,0 +1,15 @@
+import math
+
+
+def get_size_label(size_in_bytes, decimal_places=2):
+
+    units = ('','K','M','G','T','P','E','Z','Y')
+    conversion_factor = 1024
+
+    if size_in_bytes == 0:
+        index, size = 0, 0
+    else:
+        index = int(math.floor(math.log(size_in_bytes, conversion_factor)))
+        size = size_in_bytes / math.pow(conversion_factor, index)
+
+    return f'{size:,.{decimal_places}f} {units[index]}B'

pathpilot-0.2.2/pathpilot/_folder/__init__.py

@@ -0,0 +1,7 @@
+from .backup import backup_folder
+from .base import Folder
+
+from .utils import (
+    create_folder,
+    delete_folder
+    )

pathpilot-0.2.2/pathpilot/_folder/backup.py

@@ -0,0 +1,90 @@
+import shutil
+import filecmp
+import os
+
+
+def backup_folder(
+    origin,
+    destination,
+    overwrite=True,
+    shallow=True,
+    verbose=True
+    ):
+    '''
+    Description
+    ------------
+    Backs up the the folders and files in the 'origin' folder to the
+    'destination' folder. Files in 'destination' are overwritten if they are
+    different than files of the same name in 'origin' according to filecmp.cmp
+    (e.g. doc.xlsx exists in both directories but the version in 'origin' was
+    updated since the last time a backup was performed.)
+
+    Parameters
+    ------------
+    origin : str | Folder
+        folder to backup
+    destination : str | Folder
+        backup folder
+    overwrite : bool
+        if True, if the destination file already exists and it is different than
+                 the origin file, it will be overwritten.
+        If False, overlapping files are ignored.
+    shallow : bool
+        filecmp.cmp(f1, f2, shallow=True) shallow argument.
+        "If shallow is true and the os.stat() signatures (file type, size, and
+        modification time) of both files are identical, the files are taken to be
+        equal."
+        https://docs.python.org/3/library/filecmp.html
+    verbose : bool
+        if True, all folders and files that were backed up or overwritten are
+        printed.
+
+    Returns
+    ------------
+    None
+    '''
+
+    def format_path(path):
+        path = str(path).replace('\\','/')
+        if path[-1] != '/': path = path + '/'
+        return path
+
+    origin = format_path(origin)
+    destination = format_path(destination)
+    if not os.path.exists(destination): os.mkdir(destination)
+
+    for path, folders, files in os.walk(origin):
+        from_path = format_path(path)
+        to_path = from_path.replace(origin, destination)
+
+        for file in files:
+            copy_file = False
+            from_file = from_path + file
+            to_file = to_path + file
+            text = to_file.replace(destination, '/')
+
+            if os.path.exists(to_file):
+                if not filecmp.cmp(
+                    from_file,
+                    to_file,
+                    shallow=shallow
+                    ) and overwrite:
+                    action = 'Overwrite'
+                    copy_file = True
+            else:
+                action = 'BackingUp'
+                copy_file = True
+
+            if copy_file:
+                try:
+                    shutil.copyfile(from_file, to_file)
+                    if verbose: print(f'{action}: {text}')
+                except Exception as e:
+                    if verbose: print(e)
+
+        for folder in folders:
+            to_folder = to_path + folder
+            text = to_folder.replace(destination, '/') + '/'
+            if not os.path.exists(to_folder):
+                os.mkdir(to_folder)
+                if verbose: print(f'BackingUp: {text}')

pathpilot-0.2.0/pathpilot/_folder.py → pathpilot-0.2.2/pathpilot/_folder/base.py

@@ -5,19 +5,14 @@ import pandas as pd
 import oddments as odd
 from cachegrab import sha256
 
-from clockwork import (
-    quarter_end,
-    month_end,
-    day_of_week,
-    year_end,
-    )
-
-from clockwork.utils import convert_date_format_to_regex
+import clockwork as cw
+from clockwork.utils import \
+    convert_date_format_to_regex
 
-from .decorators import check_read_only
-from .exceptions import ReadOnlyError
+from ..decorators import check_read_only
+from ..exceptions import ReadOnlyError
 
-from .utils import (
+from ..utils import (
     trifurcate,
     trifurcate_and_join,
     is_file,
@@ -25,6 +20,9 @@ from .utils import (
     get_cwd,
     get_created_date,
     get_modified_date,
+    )
+
+from .utils import (
     create_folder,
     delete_folder,
     )
@@ -408,7 +406,6 @@ class Folder(object):
             return False
 
 
-
     class Folders(Contents):
         '''
         Description
@@ -429,7 +426,6 @@ class Folder(object):
             self.folder._clear_subfolder_cache()
 
 
-
     class Files(Contents):
         '''
         Description
@@ -847,19 +843,19 @@ class Folder(object):
 
     # helper functions adding timestamps to folders
     def quarter(self, delta=0, **kwargs):
-        return self.join(quarter_end(delta=delta).label, **kwargs)
+        return self.join(cw.quarter_end(delta=delta).label, **kwargs)
 
 
     def month(self, delta=0, **kwargs):
-        return self.join(month_end(delta=delta).ymd, **kwargs)
+        return self.join(cw.month_end(delta=delta).ymd, **kwargs)
 
 
     def day(self, weekday, delta=0, **kwargs):
-        return self.join(day_of_week(weekday=weekday, delta=delta).ymd, **kwargs)
+        return self.join(cw.day_of_week(weekday=weekday, delta=delta).ymd, **kwargs)
 
 
     def year(self, delta=0, **kwargs):
-        return self.join(str(year_end(delta=delta).year), **kwargs)
+        return self.join(str(cw.year_end(delta=delta).year), **kwargs)
 
 
     #╭-------------------------------------------------------------------------╮

pathpilot-0.2.2/pathpilot/_folder/utils.py

@@ -0,0 +1,30 @@
+import os
+import shutil
+
+from ..utils import is_folder
+
+
+def _verify_is_folder(func):
+
+    def wrapper(f):
+        f = str(f)
+        if not is_folder(f):
+            raise TypeError(f"{f} is not a folder")
+        return func(f)
+
+    return wrapper
+
+
+@_verify_is_folder
+def create_folder(f):
+    ''' create folder if it does not already exist '''
+    if not os.path.exists(f):
+        os.mkdir(f)
+
+
+@_verify_is_folder
+def delete_folder(f):
+    ''' delete folder if it exists '''
+    if os.path.exists(f):
+        shutil.rmtree(f)
+

{pathpilot-0.2.0 → pathpilot-0.2.2}/pathpilot/core.py

@@ -1,12 +1,10 @@
-from ._file import FileBase
-from ._folder import Folder
-from ._excel import ExcelFile
-from ._csv import CSVFile
-from ._pickle import PickleFile
-from ._text import TextFile
-from ._zip import ZipFile
-from ._sqlite import SQLiteFile
-from .utils import trifurcate, get_cwd
+from ._file import *
+from ._folder import *
+
+from .utils import (
+    trifurcate,
+    get_cwd
+    )
 
 
 #╭-------------------------------------------------------------------------╮

pathpilot-0.2.2/pathpilot/utils.py

@@ -0,0 +1,71 @@
+import os
+import datetime
+from clockwork import Date
+
+
+def split_extension(x):
+    ''' separates file extention from rest of string '''
+    dot_index = x.rfind('.')
+    if dot_index == -1: # period not found
+        return x, ''
+    else:
+        ext = x[dot_index + 1:]
+        rest = x[:dot_index]
+        return rest, ext
+
+
+def is_file(f):
+    ''' returns True if the argument is a file '''
+    return bool(trifurcate(f)[-1])
+
+
+def is_folder(f):
+    ''' returns True if the argument is a folder '''
+    f = trifurcate(f)
+    return f[0] and not any(f[1:])
+
+
+def trifurcate_and_join(f):
+    ''' split argument into its components (folder inferred if absent) and
+        combine them into one string '''
+    folder, name, ext = trifurcate(f)
+    return (folder + name + '.' + ext) if ext else folder
+
+
+def trifurcate(f, default_folder=True):
+    ''' split argument into folder, file name, and file extension components '''
+    f = str(f).replace('\\','/').strip()
+    if not f: raise ValueError("'f' argument cannot be empty")
+    explicitly_folder = f[-1] == '/'
+    f = '/'.join([x for x in f.split('/') if x])
+    f = f + '/' if explicitly_folder or '.' not in f.split('/')[-1] else f
+    if f.split('/')[0][-4:].lower() == '.com': f = '//' + f
+    f = f.rsplit('/', 1)
+    folder = f[0] + '/' if len(f) == 2 else (get_cwd() if default_folder else '')
+    name, ext = split_extension(f[-1])
+    return folder, name, ext.lower()
+
+
+def get_cwd():
+    pypath = os.getenv('PYTHONPATH')
+    f = os.getcwd() if pypath is None else pypath.split(os.pathsep)[0]
+    f = str(f).replace('\\','/') + '/'
+    return f
+
+
+def _timestamp_to_date(func):
+
+    def wrapper(path):
+        return Date(datetime.datetime.fromtimestamp(func(path)))
+
+    return wrapper
+
+
+@_timestamp_to_date
+def get_created_date(path):
+    return os.path.getctime(path)
+
+
+@_timestamp_to_date
+def get_modified_date(path):
+    return os.path.getmtime(path)

{pathpilot-0.2.0 → pathpilot-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pathpilot"
-version = "0.2.0"
+version = "0.2.2"
 description = "Library that facilitates file and folder manipulation in Python."
 authors = ["Zachary Einck <zacharyeinck@gmail.com>"]
 license = "MIT"
@@ -10,9 +10,9 @@ homepage = "https://github.com/zteinck/pathpilot"
 
 [tool.poetry.dependencies]
 python = "^3.8"
-clockwork = "*"
-cachegrab = "*"
-oddments = "*"
+clockwork = ">=0.2.2"
+cachegrab = ">=0.2.2"
+oddments = ">=0.2.0"
 pandas = "*"
 numpy = "*"
 XlsxWriter = "*"

pathpilot-0.2.0/pathpilot/utils.py

@@ -1,199 +0,0 @@
-import shutil
-import filecmp
-import math
-import os
-import datetime
-import inspect
-from clockwork import Date
-
-
-def split_extension(x):
-    ''' separates file extention from rest of string '''
-    dot_index = x.rfind('.')
-    if dot_index == -1: # period not found
-        return x, ''
-    else:
-        ext = x[dot_index + 1:]
-        rest = x[:dot_index]
-        return rest, ext
-
-
-def is_file(f):
-    ''' returns True if the argument is a file '''
-    return bool(trifurcate(f)[-1])
-
-
-def is_folder(f):
-    ''' returns True if the argument is a folder '''
-    f = trifurcate(f)
-    return f[0] and not any(f[1:])
-
-
-def trifurcate_and_join(f):
-    ''' split argument into its components (folder inferred if absent) and
-        combine them into one string '''
-    folder, name, ext = trifurcate(f)
-    return (folder + name + '.' + ext) if ext else folder
-
-
-def trifurcate(f, default_folder=True):
-    ''' split argument into folder, file name, and file extension components '''
-    f = str(f).replace('\\','/').strip()
-    if not f: raise ValueError("'f' argument cannot be empty")
-    explicitly_folder = f[-1] == '/'
-    f = '/'.join([x for x in f.split('/') if x])
-    f = f + '/' if explicitly_folder or '.' not in f.split('/')[-1] else f
-    if f.split('/')[0][-4:].lower() == '.com': f = '//' + f
-    f = f.rsplit('/', 1)
-    folder = f[0] + '/' if len(f) == 2 else (get_cwd() if default_folder else '')
-    name, ext = split_extension(f[-1])
-    return folder, name, ext.lower()
-
-
-def get_cwd():
-    pypath = os.getenv('PYTHONPATH')
-    f = os.getcwd() if pypath is None else pypath.split(os.pathsep)[0]
-    f = str(f).replace('\\','/') + '/'
-    return f
-
-
-def get_size_label(size_in_bytes, decimal_places=2):
-
-    units = ('','K','M','G','T','P','E','Z','Y')
-    conversion_factor = 1024
-
-    if size_in_bytes == 0:
-        index, size = 0, 0
-    else:
-        index = int(math.floor(math.log(size_in_bytes, conversion_factor)))
-        size = size_in_bytes / math.pow(conversion_factor, index)
-
-    return f'{size:,.{decimal_places}f} {units[index]}B'
-
-
-def backup_folder(origin, destination, overwrite=True, shallow=True, verbose=True):
-    '''
-    Description
-    ------------
-    Backs up the the folders and files in the 'origin' folder to the
-    'destination' folder. Files in 'destination' are overwritten if they are
-    different than files of the same name in 'origin' according to filecmp.cmp
-    (e.g. doc.xlsx exists in both directories but the version in 'origin' was
-    updated since the last time a backup was performed.)
-
-    Parameters
-    ------------
-    origin : str | Folder
-        folder to backup
-    destination : str | Folder
-        backup folder
-    overwrite : bool
-        if True, if the destination file already exists and it is different than
-                 the origin file, it will be overwritten.
-        If False, overlapping files are ignored.
-    shallow : bool
-        filecmp.cmp(f1, f2, shallow=True) shallow argument.
-        "If shallow is true and the os.stat() signatures (file type, size, and
-        modification time) of both files are identical, the files are taken to be
-        equal."
-        https://docs.python.org/3/library/filecmp.html
-    verbose : bool
-        if True, all folders and files that were backed up or overwritten are printed.
-
-    Returns
-    ------------
-    None
-    '''
-
-    def format_path(path):
-        path = str(path).replace('\\','/')
-        if path[-1] != '/': path = path + '/'
-        return path
-
-    origin = format_path(origin)
-    destination = format_path(destination)
-    if not os.path.exists(destination): os.mkdir(destination)
-
-    for path, folders, files in os.walk(origin):
-        from_path = format_path(path)
-        to_path = from_path.replace(origin, destination)
-
-        for file in files:
-            copy_file = False
-            from_file = from_path + file
-            to_file = to_path + file
-            text = to_file.replace(destination, '/')
-
-            if os.path.exists(to_file):
-                if not filecmp.cmp(
-                    from_file,
-                    to_file,
-                    shallow=shallow
-                    ) and overwrite:
-                    action = 'Overwrite'
-                    copy_file = True
-            else:
-                action = 'BackingUp'
-                copy_file = True
-
-            if copy_file:
-                try:
-                    shutil.copyfile(from_file, to_file)
-                    if verbose: print(f'{action}: {text}')
-                except Exception as e:
-                    if verbose: print(e)
-
-        for folder in folders:
-            to_folder = to_path + folder
-            text = to_folder.replace(destination, '/') + '/'
-            if not os.path.exists(to_folder):
-                os.mkdir(to_folder)
-                if verbose: print(f'BackingUp: {text}')
-
-
-def timestamp_to_date(func):
-
-    def wrapper(path):
-        return Date(datetime.datetime.fromtimestamp(func(path)))
-
-    return wrapper
-
-
-@timestamp_to_date
-def get_created_date(path):
-    return os.path.getctime(path)
-
-
-@timestamp_to_date
-def get_modified_date(path):
-    return os.path.getmtime(path)
-
-
-def verify_is_folder(func):
-
-    def wrapper(f):
-        f = str(f)
-        if not is_folder(f):
-            raise TypeError(f"{f} is not a folder")
-        return func(f)
-
-    return wrapper
-
-
-@verify_is_folder
-def create_folder(f):
-    ''' create folder if it does not already exist '''
-    if not os.path.exists(f):
-        os.mkdir(f)
-
-
-@verify_is_folder
-def delete_folder(f):
-    ''' delete folder if it exists '''
-    if os.path.exists(f):
-        shutil.rmtree(f)
-
-
-def get_object_folder(obj):
-    ''' return file folder of Python object '''
-    return os.path.absfolder(inspect.getfile(obj))