path2success 3.6__tar.gz

path2success-3.6/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Joel Horensma
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

path2success-3.6/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: path2success
+Version: 3.6
+Summary: The "path2success" library, is a multi-OS compatible python library, that includes advanced path-related functions.
+Author: Joel Horensma
+License-Expression: Apache-2.0
+Keywords: path,paths,filter,convert bytes,copy,progress bar,ETA
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+The **path2success** library, is a multi-OS compatible python library, that includes advanced path-related functions.
+
+## **The "is_safely_quoted()" Function:**
+
+### **Description:**
+**1.)** Checks if the supplied path, is OS-appropriately quoted and has no extra quotes\
+**2.)** Returns True, if the supplied path is appropriately quoted (Or appropriately not), otherwise returns False
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.is_safely_quoted(PATH))\
+input('Press Enter: ')
+
+## **The "filter_path()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "appropriate_quotes()" function, to remove any prepended and matching quotes, at the end of the supplied path, as well as, replace any OS-inappropriate quotes, in the supplied path, with OS-appropriate ones\
+**2.)** The "appropriate_quotes()" function, checks if the supplied path contains a space, if it does,\
+the OS-appropriate quotes are added, to the beginning and end of the path, and the OS-appropriately quoted path, is returned to the "filter_path()" function\
+**3.)** Uses path2success' "unquote_path()" function, to remove the beginning and end quotes, added by the "appropriate_quotes()" function (if the supplied path contained a space), then returns the unquoted path, to the "filter_path()" function\
+**4.)** Converts any OS-specific environment variables, in the supplied path, using the "os" module\
+**5.)** Converts any dot-sequences, in the supplied path, and replaces OS-inappropriate slashes, with OS-appropriate slashes, using the "pathlib" module\
+**6.)** Returns a filtered and converted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.filter_path(PATH))\
+input('Press Enter: ')
+
+## **The "appropriate_quotes()" Function:**
+
+### **Description:**
+**1.)** Removes any prepended quotes, from the supplied path, as well as matching ones, at the end of the path\
+**2.)** Replaces any OS-inappropriate quotes, with OS-appropriate ones\
+**3.)** Checks if the supplied path contains a space, if it does, the OS-appropriate quotes are added to the beginning and end, of the supplied path\
+**4.)** Returns an appropriately quoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.appropriate_quotes(PATH))\
+input('Press Enter: ')
+
+## **The "unquote_path()" Function:**
+
+### **Description:**
+**1.)** If the first and last characters, in the supplied path, are matching quotes, they are removed\
+**2.)** Returns an unquoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.unquote_path(PATH))\
+input('Press Enter: ')
+
+## **The "recursive_files_and_bytes_total()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied path\
+**2.)** Recursively scans, for the total number of files and bytes, of data, with the help of the "os" module\
+**3.)** Returns the total number of files and bytes, of data\
+**Note:** path2success' "convert_bytes()" function, can convert the total bytes return value, to kilobytes, megabytes, gigabytes, or even terabytes
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+TOTAL_FILES, TOTAL_BYTES = path2success.recursive_files_and_bytes_total(PATH)\
+print(f'Total files: {TOTAL_FILES}')\
+print(f'Total bytes: {TOTAL_BYTES}')\
+input('Press Enter: ')
+
+## **The "convert_bytes()" Function:**
+
+### **Description:**
+**1.)** Accepts a number of bytes\
+**2.)** Returns the total b, Kb, Mb, Gb, or Tb (Max) value
+
+### **Example Usage:**
+import path2success\
+BYTES = input('Enter a number, of bytes: ')\
+CONVERTED_BYTES = path2success.convert_bytes(BYTES)\
+print(f'Converted bytes: {CONVERTED_BYTES}')\
+input('Press Enter: ')
+
+## **The "recursive_copy_with_progress()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied source and destination paths\
+**2.)** Calculates and displays the total number of files and bytes, of data, to be copied, from the source path, using path2success' "recursive_files_and_bytes_total()" function and it's internal "convert_bytes()" function, along with the help, of the "os" module\
+**3.)** Creates a new directory, in the destination path, matching the source path's folder name, using the "os" module, if the folder does not already exist in the destination path, however,\
+if the folder does already exist in the destination path, a new directory with a new name is created, in the destination path\
+**4.)** Recursively copies all files and folders within the supplied source path, to the supplied destination path, while displaying a live progress bar and ETA until finished, with the help of the "sys" and "time" modules
+
+### **Example Usage:**
+import path2success\
+SOURCE_PATH = input('Enter a source path: ')\
+DESTINATION_PATH = input('Enter a destination path: ')\
+path2success.recursive_copy_with_progress(SOURCE_PATH, DESTINATION_PATH)\
+input('Press Enter: ')
+
+### **The "recursive_copy_with_progress()" function, CLI Usage:**
+python -m path2success recursive_copy_with_progress SOURCE_PATH DESTINATION_PATH

path2success-3.6/README.md

@@ -0,0 +1,104 @@
+The **path2success** library, is a multi-OS compatible python library, that includes advanced path-related functions.
+
+## **The "is_safely_quoted()" Function:**
+
+### **Description:**
+**1.)** Checks if the supplied path, is OS-appropriately quoted and has no extra quotes\
+**2.)** Returns True, if the supplied path is appropriately quoted (Or appropriately not), otherwise returns False
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.is_safely_quoted(PATH))\
+input('Press Enter: ')
+
+## **The "filter_path()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "appropriate_quotes()" function, to remove any prepended and matching quotes, at the end of the supplied path, as well as, replace any OS-inappropriate quotes, in the supplied path, with OS-appropriate ones\
+**2.)** The "appropriate_quotes()" function, checks if the supplied path contains a space, if it does,\
+the OS-appropriate quotes are added, to the beginning and end of the path, and the OS-appropriately quoted path, is returned to the "filter_path()" function\
+**3.)** Uses path2success' "unquote_path()" function, to remove the beginning and end quotes, added by the "appropriate_quotes()" function (if the supplied path contained a space), then returns the unquoted path, to the "filter_path()" function\
+**4.)** Converts any OS-specific environment variables, in the supplied path, using the "os" module\
+**5.)** Converts any dot-sequences, in the supplied path, and replaces OS-inappropriate slashes, with OS-appropriate slashes, using the "pathlib" module\
+**6.)** Returns a filtered and converted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.filter_path(PATH))\
+input('Press Enter: ')
+
+## **The "appropriate_quotes()" Function:**
+
+### **Description:**
+**1.)** Removes any prepended quotes, from the supplied path, as well as matching ones, at the end of the path\
+**2.)** Replaces any OS-inappropriate quotes, with OS-appropriate ones\
+**3.)** Checks if the supplied path contains a space, if it does, the OS-appropriate quotes are added to the beginning and end, of the supplied path\
+**4.)** Returns an appropriately quoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.appropriate_quotes(PATH))\
+input('Press Enter: ')
+
+## **The "unquote_path()" Function:**
+
+### **Description:**
+**1.)** If the first and last characters, in the supplied path, are matching quotes, they are removed\
+**2.)** Returns an unquoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.unquote_path(PATH))\
+input('Press Enter: ')
+
+## **The "recursive_files_and_bytes_total()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied path\
+**2.)** Recursively scans, for the total number of files and bytes, of data, with the help of the "os" module\
+**3.)** Returns the total number of files and bytes, of data\
+**Note:** path2success' "convert_bytes()" function, can convert the total bytes return value, to kilobytes, megabytes, gigabytes, or even terabytes
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+TOTAL_FILES, TOTAL_BYTES = path2success.recursive_files_and_bytes_total(PATH)\
+print(f'Total files: {TOTAL_FILES}')\
+print(f'Total bytes: {TOTAL_BYTES}')\
+input('Press Enter: ')
+
+## **The "convert_bytes()" Function:**
+
+### **Description:**
+**1.)** Accepts a number of bytes\
+**2.)** Returns the total b, Kb, Mb, Gb, or Tb (Max) value
+
+### **Example Usage:**
+import path2success\
+BYTES = input('Enter a number, of bytes: ')\
+CONVERTED_BYTES = path2success.convert_bytes(BYTES)\
+print(f'Converted bytes: {CONVERTED_BYTES}')\
+input('Press Enter: ')
+
+## **The "recursive_copy_with_progress()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied source and destination paths\
+**2.)** Calculates and displays the total number of files and bytes, of data, to be copied, from the source path, using path2success' "recursive_files_and_bytes_total()" function and it's internal "convert_bytes()" function, along with the help, of the "os" module\
+**3.)** Creates a new directory, in the destination path, matching the source path's folder name, using the "os" module, if the folder does not already exist in the destination path, however,\
+if the folder does already exist in the destination path, a new directory with a new name is created, in the destination path\
+**4.)** Recursively copies all files and folders within the supplied source path, to the supplied destination path, while displaying a live progress bar and ETA until finished, with the help of the "sys" and "time" modules
+
+### **Example Usage:**
+import path2success\
+SOURCE_PATH = input('Enter a source path: ')\
+DESTINATION_PATH = input('Enter a destination path: ')\
+path2success.recursive_copy_with_progress(SOURCE_PATH, DESTINATION_PATH)\
+input('Press Enter: ')
+
+### **The "recursive_copy_with_progress()" function, CLI Usage:**
+python -m path2success recursive_copy_with_progress SOURCE_PATH DESTINATION_PATH

path2success-3.6/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ['setuptools']
+build-backend = 'setuptools.build_meta'
+
+[project]
+keywords = ['path', 'paths', 'filter', 'convert bytes', 'copy', 'progress bar', 'ETA']
+name = 'path2success'
+version = '3.6'
+description = 'The "path2success" library, is a multi-OS compatible python library, that includes advanced path-related functions.'
+readme = 'README.md'
+license = 'Apache-2.0'
+authors = [{name = 'Joel Horensma'}]
+requires-python = '>=3.14'
+
+[tool.setuptools.packages.find]
+where = ['src']

path2success-3.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

path2success-3.6/src/path2success/__init__.py

@@ -0,0 +1 @@
+from .main import *

path2success-3.6/src/path2success/__main__.py

@@ -0,0 +1,20 @@
+import sys
+from .main import recursive_copy_with_progress
+
+def main():
+    if len(sys.argv) < 4:
+        print('Usage: python -m path2success recursive_copy_with_progress SOURCE_PATH DESTINATION_PATH\n')
+        sys.exit(1)
+
+    COMMAND = sys.argv[1]
+
+    if COMMAND == 'recursive_copy_with_progress':
+        SOURCE_PATH = sys.argv[2]
+        DESTINATION_PATH = sys.argv[3]
+        recursive_copy_with_progress(SOURCE_PATH, DESTINATION_PATH)
+    else:
+        print(f'Unknown command: {COMMAND}')
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

path2success-3.6/src/path2success/_internal.py

@@ -0,0 +1,46 @@
+import os, sys
+    
+#CONVERTS SECONDS, TO FULL TIME FORMAT
+def convert_seconds(SECONDS):
+    SECONDS = str(SECONDS).strip()
+    if SECONDS:
+        if SECONDS.isnumeric():
+            SECONDS = int(SECONDS)
+            YEARS = f'{SECONDS // 31536000}y:' if (SECONDS // 31536000) > 0 else ''
+            REMAINDER_SECONDS = SECONDS % 31536000
+            MONTHS = f'{REMAINDER_SECONDS // 2628000}M:' if (REMAINDER_SECONDS // 2628000) > 0 else ''
+            REMAINDER_SECONDS %= 2628000
+            WEEKS = f'{REMAINDER_SECONDS // 604800}w:' if (REMAINDER_SECONDS // 604800) > 0 else ''
+            REMAINDER_SECONDS %= 604800
+            DAYS = f'{REMAINDER_SECONDS // 86400}d:' if (REMAINDER_SECONDS // 86400) > 0 else ''
+            REMAINDER_SECONDS %= 86400
+            HOURS = f'{REMAINDER_SECONDS // 3600}h:' if (REMAINDER_SECONDS // 3600) > 0 else ''
+            REMAINDER_SECONDS %= 3600
+            MINUTES = f'{REMAINDER_SECONDS // 60}m:' if (REMAINDER_SECONDS // 60) > 0 else ''
+            REMAINDER_SECONDS %= 60
+            SECONDS = f'{REMAINDER_SECONDS % 60}s'
+            CONVERTED_SECONDS = f'{YEARS}{MONTHS}{WEEKS}{DAYS}{HOURS}{MINUTES}{SECONDS}'
+            return CONVERTED_SECONDS
+        else:
+            raise TypeError('"convert_seconds()": The "SECONDS" variable, must be an integer')
+    else:
+        raise EOFError('"convert_seconds()": The "SECONDS" variable, cannot be empty')
+    
+#DISPLAY A PROGRESS BAR, FOR THE "recursive_copy_with_progress()" FUNCTION   
+def recursive_copy_progress_bar(COPIED_BYTES, TOTAL_BYTES, ETA_SECONDS, PADDING_WIDTH = 10):
+    COPIED_BYTES, TOTAL_BYTES, ETA_SECONDS = str(COPIED_BYTES).strip(), str(TOTAL_BYTES).strip(), str(ETA_SECONDS).strip()
+    if all([COPIED_BYTES, TOTAL_BYTES, ETA_SECONDS]):      
+        if all([COPIED_BYTES.isnumeric(), TOTAL_BYTES.isnumeric(), ETA_SECONDS.isnumeric()]):
+            COPIED_BYTES, TOTAL_BYTES, ETA_SECONDS = int(COPIED_BYTES), int(TOTAL_BYTES), int(ETA_SECONDS)
+            PERCENT = (COPIED_BYTES / TOTAL_BYTES) * 100
+            BARS_FILLED = (30 * COPIED_BYTES) // TOTAL_BYTES
+            PROGRESS_BAR = '=' * BARS_FILLED + '-' * (30 - BARS_FILLED)
+            ETA = convert_seconds(ETA_SECONDS)
+            sys.stdout.write(f'\rProgress: [{PROGRESS_BAR}]({round(PERCENT)}%) ETA: {ETA.ljust((PADDING_WIDTH))}')
+            sys.stdout.flush()
+        else:
+            raise TypeError('"recursive_copy_progress_bar()": One or more non-integer variables, were supplied')   
+    else:
+        raise EOFError('"recursive_copy_progress_bar()": One or more empty variables, were supplied')
+    if PERCENT == 100.0:
+        print('\nFinished!\n')

path2success-3.6/src/path2success/main.py

@@ -0,0 +1,206 @@
+import os, platform, time
+from pathlib import Path
+from . import _internal
+
+#RETURNS "True", IF THE SUPPLIED PATH IS OS-APPROPRIATELY AND CORRECTLY QUOTED, OTHERWISE "False"
+def is_safely_quoted(PATH):
+    PATH = PATH.strip()
+    if PATH:
+        if isinstance(PATH, str):
+            OS_QUOTE = '"' if platform.system() == 'Windows' else "'"
+            PREPENDED_QUOTES = 0
+            for CHARACTER in PATH:
+                if CHARACTER in ["'", '"']:
+                    PREPENDED_QUOTES += 1
+                else:
+                    break
+            if os.path.isabs(PATH[1:-1]) and ' ' in PATH and PATH.startswith(OS_QUOTE) and PATH.endswith(OS_QUOTE) and PATH.count(OS_QUOTE) == 2 and PREPENDED_QUOTES < 2:
+                return True
+            elif ' ' not in PATH and OS_QUOTE not in PATH and PREPENDED_QUOTES == 0:
+                return True
+            else:
+                return False
+        else:
+            raise TypeError('"is_safely_quoted()": The "PATH" variable, must be a string')
+    else:
+        raise EOFError('"is_safely_quoted()": The "PATH" variable, cannot be empty')
+
+#OS-APPROPRIATELY QUOTES, A SUPPLIED PATH (IF A SPACE, IS PRESENT) AND FIXES INCORRECT QUOTING
+def appropriate_quotes(PATH):
+    PATH = PATH.strip()
+    if PATH:
+        if isinstance(PATH, str):
+            if is_safely_quoted(PATH):
+                return PATH
+            else:
+                NON_OS_QUOTE = "'" if platform.system() == 'Windows' else '"'
+                OS_QUOTE = '"' if platform.system() == 'Windows' else "'"
+                PREPENDED_QUOTES = 0
+                MATCHED_QUOTES = 0
+                for CHARACTER in PATH:
+                    if CHARACTER in ["'", '"']:
+                        PREPENDED_QUOTES += 1
+                        if CHARACTER == PATH[-PREPENDED_QUOTES]:
+                            MATCHED_QUOTES += 1
+                    else:
+                        break
+                PATH = PATH[PREPENDED_QUOTES:-MATCHED_QUOTES].replace(OS_QUOTE, NON_OS_QUOTE) if MATCHED_QUOTES > 0 else PATH[PREPENDED_QUOTES:].replace(OS_QUOTE, NON_OS_QUOTE)
+                PATH = f'{OS_QUOTE}{PATH}{OS_QUOTE}' if ' ' in PATH else PATH.replace(OS_QUOTE, NON_OS_QUOTE)
+                return PATH
+        else:
+            raise TypeError('"appropriate_quotes()": The "PATH" variable, must be a string')
+    else:
+        raise EOFError('"appropriate_quotes()": The "PATH" variable, cannot be empty')
+    
+#UNQUOTES, THE FIRST INSTANCES, OF BEGINNING AND END QUOTES, OF THE SUPPLIED PATH
+def unquote_path(PATH):
+    PATH = PATH.strip()
+    if PATH:
+        if isinstance(PATH, str):
+            QUOTES = ["'", '"']
+            if PATH[0] in QUOTES and PATH[0] == PATH[-1]:
+                return PATH[1:-1]
+            else:
+                return PATH
+        else:
+            raise TypeError('"unquote_path()": The "PATH" variable, must be a string')
+    else:
+        raise EOFError('"unquote_path()": The "PATH" variable, cannot be empty')
+
+#STRIPS, EXPANDS VARIABLES, OS-NORMALIZES SLASHES, AND CONVERTS DOT-SEQUENCES, FROM THE SUPPLIED PATH
+def filter_path(PATH):
+    PATH = PATH.strip()
+    if PATH:
+        if isinstance(PATH, str):
+            PATH = appropriate_quotes(PATH)
+            PATH = unquote_path(PATH)
+            PATHLIB_PATH = str(Path.cwd())
+            PATH = os.path.expandvars(PATH)
+            RESOLVED = str(Path(PATH).resolve(strict=False))
+            STRIP_LENGTH = 0 if len(PATHLIB_PATH) == 0 else len(PATHLIB_PATH) + 1
+            if not os.path.isabs(PATH) and RESOLVED.lower().startswith(PATHLIB_PATH.lower()):
+                PATH = RESOLVED[STRIP_LENGTH:]
+            else:
+                PATH = RESOLVED
+            return PATH
+        else:
+            raise TypeError('"filter_path()": The "PATH" variable, must be a string')
+    else:
+        raise EOFError('"filter_path()": The "PATH" variable, cannot be empty')
+    
+#RECURSIVELY SCANS A FOLDER PATH, FOR THE TOTAL NUMBER, OF FILES OF BYTES, KILOBYTES, MEGABYTES, ETC.
+def recursive_files_and_bytes_total(PATH):
+    PATH = PATH.strip()
+    if PATH:
+        if isinstance(PATH, str):
+            PATH = filter_path(PATH)
+            if os.path.exists(PATH):
+                if os.path.isdir(PATH):
+                    FILES_TOTAL = 0
+                    BYTES_TOTAL = 0
+
+                    #LOOP THROUGH FOLDERS, IN THE PATH, RECURSIVELY
+                    for WALK_PATH, DIRECTORIES, FILES in os.walk(PATH):
+                        
+                        #REMOVE HIDDEN AND LINK FILES, FROM THE FILES LIST
+                        FILES = [FILE for FILE in FILES if not FILE.startswith('.') and not os.path.islink(os.path.join(WALK_PATH, FILE))]
+
+                        #LOOP THROUGH FILES, IN THE FOLDER
+                        for FILE in FILES:
+                            FILES_TOTAL += 1
+                            SCAN_PATH = os.path.join(WALK_PATH, FILE)
+                            FILE_SIZE = os.path.getsize(SCAN_PATH)
+                            BYTES_TOTAL += FILE_SIZE
+                    return FILES_TOTAL, BYTES_TOTAL
+                else:
+                    raise NotADirectoryError('"recursive_files_and_bytes_total()": The "PATH" variable, must be a path, to a folder')
+            else:
+                raise FileNotFoundError(f'"recursive_files_and_bytes_total()": The path: {PATH}, was not found')
+        else:
+            raise TypeError('"recursive_files_and_bytes_total()": The "PATH" variable, must be a string')
+    else:
+        raise EOFError('"recursive_files_and_bytes_total()": The "PATH" variable, cannot be empty')
+
+#CONVERTS BYTES, TO OTHER MEASUREMENTS, IN BINARY FORMAT
+def convert_bytes(BYTES):
+    BYTES = str(BYTES).strip()
+    if BYTES:
+        if BYTES.isnumeric():
+            BYTES = int(BYTES)
+            BINARY_INCREMENT = 1024
+            if BYTES < BINARY_INCREMENT:return f'{BYTES} b'
+            KILOBYTES = f'{round(BYTES/BINARY_INCREMENT, 2)}'
+            if BYTES >= BINARY_INCREMENT and BYTES < BINARY_INCREMENT ** 2:return f'{KILOBYTES} kb'
+            MEGABYTES = round(BYTES/(BINARY_INCREMENT ** 2), 2)
+            if BYTES >= (BINARY_INCREMENT ** 2) and BYTES < BINARY_INCREMENT ** 3:return f'{MEGABYTES} Mb'
+            GIGABYTES = round(BYTES/(BINARY_INCREMENT ** 3), 2)
+            if BYTES >= (BINARY_INCREMENT ** 3) and BYTES < BINARY_INCREMENT ** 4:return f'{GIGABYTES} Gb'
+            TERABYTES = round(BYTES/(BINARY_INCREMENT ** 4), 2)
+            return f'{round(TERABYTES, 2)} Tb'
+        else:
+            raise TypeError('"convert_bytes()": The "BYTES" variable, must be an integer')
+    else:
+        raise EOFError('"convert_bytes()": The "BYTES" variable, cannot be empty')
+    
+#RECURSIVELY COPIES A SUPPLIED SOURCE PATH, TO A SUPPLIED DESTINATION PATH,
+#WHILE SKIPPING FILES THAT CANNOT BE COPIED, LIKE HIDDEN AND SYM-LINK FILES
+def recursive_copy_with_progress(SOURCE_PATH, DESTINATION_PATH):
+    SOURCE_PATH, DESTINATION_PATH = SOURCE_PATH.strip(), DESTINATION_PATH.strip()
+    if SOURCE_PATH and DESTINATION_PATH:
+        if isinstance(SOURCE_PATH, str) and isinstance(DESTINATION_PATH, str):
+            SOURCE_PATH = filter_path(SOURCE_PATH)
+            DESTINATION_PATH = filter_path(DESTINATION_PATH)
+            if os.path.exists(SOURCE_PATH) and os.path.exists(DESTINATION_PATH):
+                if os.path.isdir(SOURCE_PATH) and os.path.isdir(DESTINATION_PATH):
+                    TOTAL_FILES, TOTAL_BYTES = recursive_files_and_bytes_total(SOURCE_PATH)
+                    print(f'Copying a total of: {TOTAL_FILES} files ({convert_bytes(TOTAL_BYTES)})')
+                    DESTINATION_PATH = os.path.join(DESTINATION_PATH, os.path.basename(SOURCE_PATH))
+                    if SOURCE_PATH == DESTINATION_PATH or os.path.exists(DESTINATION_PATH):
+                        i = 0
+                        MAKE_DESTINATION_DIRECTORY = DESTINATION_PATH
+
+                        #CHECK IF THE FOLDER ALREADY EXISTS, IN THE DESTINATION PATH
+                        #AND MAKE A NEW FOLDER, WITH A DIFFERENT NAME, IF SO
+                        while os.path.exists(MAKE_DESTINATION_DIRECTORY) == True:
+                            i += 1
+                            MAKE_DESTINATION_DIRECTORY = DESTINATION_PATH + ' ' + str(f'- Copy {i}').strip()
+                        DESTINATION_PATH = MAKE_DESTINATION_DIRECTORY
+                    
+                    #MAKE THE FOLDER, IN THE DESTINATION PATH
+                    os.makedirs(DESTINATION_PATH, exist_ok=True)
+                    START_COPY = time.time()
+                    COPIED_BYTES = 0
+                    for WALK_PATH, DIRECTORIES, FILES in os.walk(SOURCE_PATH):
+                        RELATIVE_DIRECTORY = os.path.relpath(WALK_PATH, SOURCE_PATH)
+                        SUB_DESTINATION_DIRECTORY = os.path.join(DESTINATION_PATH, RELATIVE_DIRECTORY)
+                        os.makedirs(SUB_DESTINATION_DIRECTORY, exist_ok=True)
+
+                        #REMOVE HIDDEN AND SYM-LINK FILES, FROM THE FILES LIST
+                        FILES = [FILE_NAME for FILE_NAME in FILES if not FILE_NAME.startswith('.') and not os.path.islink(os.path.join(WALK_PATH, FILE_NAME))]
+                        
+                        for FILE_NAME in FILES:
+                            SOURCE_FILE_PATH = os.path.join(WALK_PATH, FILE_NAME)
+                            DESTINATION_FILE_PATH = os.path.join(SUB_DESTINATION_DIRECTORY, FILE_NAME)
+                            with open(SOURCE_FILE_PATH, 'rb') as FILE_SOURCE, open(DESTINATION_FILE_PATH, 'wb') as FILE_DESTINATION:
+                                BUFFER_SIZE = (1024 * 1024 * 2)
+                                while True:
+                                    DATA_CHUNK = FILE_SOURCE.read(BUFFER_SIZE)
+                                    if not DATA_CHUNK:
+                                        break
+                                    else:
+                                        FILE_DESTINATION.write(DATA_CHUNK)
+                                        COPIED_BYTES += len(DATA_CHUNK)
+                                    COPY_COMPLETE = time.time()
+                                    ELAPSED_SECONDS = float(COPY_COMPLETE - START_COPY)
+                                    BYTES_PER_SECOND = (COPIED_BYTES / ELAPSED_SECONDS)
+                                    ETA_SECONDS =  int(f'{(TOTAL_BYTES - COPIED_BYTES) / BYTES_PER_SECOND:.0f}')
+                                    _internal.recursive_copy_progress_bar(COPIED_BYTES, TOTAL_BYTES, ETA_SECONDS)
+                    return
+                else:
+                    raise NotADirectoryError('"recursive_copy_with_progress()": One or more supplied paths, do not exist')
+            else:
+                raise FileNotFoundError(f'"recursive_copy_with_progress()": One or more supplied paths, were not found')
+        else:
+            raise TypeError('"recursive_copy_with_progress()": One or more non-string variables, were supplied')
+    else:
+        raise EOFError('"recursive_copy_with_progress()": One or more empty variables, were supplied')

path2success-3.6/src/path2success.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: path2success
+Version: 3.6
+Summary: The "path2success" library, is a multi-OS compatible python library, that includes advanced path-related functions.
+Author: Joel Horensma
+License-Expression: Apache-2.0
+Keywords: path,paths,filter,convert bytes,copy,progress bar,ETA
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+The **path2success** library, is a multi-OS compatible python library, that includes advanced path-related functions.
+
+## **The "is_safely_quoted()" Function:**
+
+### **Description:**
+**1.)** Checks if the supplied path, is OS-appropriately quoted and has no extra quotes\
+**2.)** Returns True, if the supplied path is appropriately quoted (Or appropriately not), otherwise returns False
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.is_safely_quoted(PATH))\
+input('Press Enter: ')
+
+## **The "filter_path()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "appropriate_quotes()" function, to remove any prepended and matching quotes, at the end of the supplied path, as well as, replace any OS-inappropriate quotes, in the supplied path, with OS-appropriate ones\
+**2.)** The "appropriate_quotes()" function, checks if the supplied path contains a space, if it does,\
+the OS-appropriate quotes are added, to the beginning and end of the path, and the OS-appropriately quoted path, is returned to the "filter_path()" function\
+**3.)** Uses path2success' "unquote_path()" function, to remove the beginning and end quotes, added by the "appropriate_quotes()" function (if the supplied path contained a space), then returns the unquoted path, to the "filter_path()" function\
+**4.)** Converts any OS-specific environment variables, in the supplied path, using the "os" module\
+**5.)** Converts any dot-sequences, in the supplied path, and replaces OS-inappropriate slashes, with OS-appropriate slashes, using the "pathlib" module\
+**6.)** Returns a filtered and converted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.filter_path(PATH))\
+input('Press Enter: ')
+
+## **The "appropriate_quotes()" Function:**
+
+### **Description:**
+**1.)** Removes any prepended quotes, from the supplied path, as well as matching ones, at the end of the path\
+**2.)** Replaces any OS-inappropriate quotes, with OS-appropriate ones\
+**3.)** Checks if the supplied path contains a space, if it does, the OS-appropriate quotes are added to the beginning and end, of the supplied path\
+**4.)** Returns an appropriately quoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.appropriate_quotes(PATH))\
+input('Press Enter: ')
+
+## **The "unquote_path()" Function:**
+
+### **Description:**
+**1.)** If the first and last characters, in the supplied path, are matching quotes, they are removed\
+**2.)** Returns an unquoted path
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+print(path2success.unquote_path(PATH))\
+input('Press Enter: ')
+
+## **The "recursive_files_and_bytes_total()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied path\
+**2.)** Recursively scans, for the total number of files and bytes, of data, with the help of the "os" module\
+**3.)** Returns the total number of files and bytes, of data\
+**Note:** path2success' "convert_bytes()" function, can convert the total bytes return value, to kilobytes, megabytes, gigabytes, or even terabytes
+
+### **Example Usage:**
+import path2success\
+PATH = input('Enter a path: ')\
+TOTAL_FILES, TOTAL_BYTES = path2success.recursive_files_and_bytes_total(PATH)\
+print(f'Total files: {TOTAL_FILES}')\
+print(f'Total bytes: {TOTAL_BYTES}')\
+input('Press Enter: ')
+
+## **The "convert_bytes()" Function:**
+
+### **Description:**
+**1.)** Accepts a number of bytes\
+**2.)** Returns the total b, Kb, Mb, Gb, or Tb (Max) value
+
+### **Example Usage:**
+import path2success\
+BYTES = input('Enter a number, of bytes: ')\
+CONVERTED_BYTES = path2success.convert_bytes(BYTES)\
+print(f'Converted bytes: {CONVERTED_BYTES}')\
+input('Press Enter: ')
+
+## **The "recursive_copy_with_progress()" Function:**
+
+### **Description:**
+**1.)** Uses path2success' "filter_path()" function, to filter the supplied source and destination paths\
+**2.)** Calculates and displays the total number of files and bytes, of data, to be copied, from the source path, using path2success' "recursive_files_and_bytes_total()" function and it's internal "convert_bytes()" function, along with the help, of the "os" module\
+**3.)** Creates a new directory, in the destination path, matching the source path's folder name, using the "os" module, if the folder does not already exist in the destination path, however,\
+if the folder does already exist in the destination path, a new directory with a new name is created, in the destination path\
+**4.)** Recursively copies all files and folders within the supplied source path, to the supplied destination path, while displaying a live progress bar and ETA until finished, with the help of the "sys" and "time" modules
+
+### **Example Usage:**
+import path2success\
+SOURCE_PATH = input('Enter a source path: ')\
+DESTINATION_PATH = input('Enter a destination path: ')\
+path2success.recursive_copy_with_progress(SOURCE_PATH, DESTINATION_PATH)\
+input('Press Enter: ')
+
+### **The "recursive_copy_with_progress()" function, CLI Usage:**
+python -m path2success recursive_copy_with_progress SOURCE_PATH DESTINATION_PATH

path2success-3.6/src/path2success.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/path2success/__init__.py
+src/path2success/__main__.py
+src/path2success/_internal.py
+src/path2success/main.py
+src/path2success.egg-info/PKG-INFO
+src/path2success.egg-info/SOURCES.txt
+src/path2success.egg-info/dependency_links.txt
+src/path2success.egg-info/top_level.txt

path2success-3.6/src/path2success.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

path2success-3.6/src/path2success.egg-info/top_level.txt

@@ -0,0 +1 @@
+path2success