utilo 2.110.2__tar.gz → 2.112.0__tar.gz

{utilo-2.110.2/utilo.egg-info → utilo-2.112.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utilo
-Version: 2.110.2
+Version: 2.112.0
 Author-email: Helmut Konrad Schewe <helmutus@outlook.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/anaticulae/utilo
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: filelock<5.0.0,>=4.0.0
 Requires-Dist: utilosafe<2.0.0,>=1.0.0
 Provides-Extra: dev
 Requires-Dist: PyYAML<7.0.0,>=6.0.3; extra == "dev"

{utilo-2.110.2 → utilo-2.112.0}/pyproject.toml

@@ -7,13 +7,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utilo"
-version = "2.110.2"
+version = "2.112.0"
 description = ""
 requires-python = ">=3.12"
 authors = [
     { name = "Helmut Konrad Schewe", email = "helmutus@outlook.com" },
 ]
 dependencies = [
+    "filelock>=4.0.0,<5.0.0",
     "utilosafe>=1.0.0,<2.0.0",
 ]
 keywords = []

{utilo-2.110.2 → utilo-2.112.0}/tests/test_file.py

@@ -18,13 +18,13 @@ import utilo.file.securewrapper
 
 
 def test_file_append_assert(tmpdir):
-    first = os.path.join(tmpdir, 'abc.txt')
+    first = utilo.join(tmpdir, 'abc.txt')
     with pytest.raises(AssertionError):
         utilo.file_append(first, '')
 
 
 def test_file_append_create(tmpdir):
-    first = os.path.join(tmpdir, 'abc.txt')
+    first = utilo.join(tmpdir, 'abc.txt')
     utilo.file_append(first, 'BBB', create=True)
     assert os.path.exists(first)
 
@@ -40,7 +40,7 @@ def test_file_from_path_or_raw(tmpdir):
         load and write
     """
 
-    path = os.path.join(tmpdir, 'example.yaml')
+    path = utilo.join(tmpdir, 'example.yaml')
     utilo.file_create(path, content)
 
     from_path = utilo.from_raw_or_path(path)
@@ -122,13 +122,13 @@ def test_file_assert_html_files():
 @pytest.fixture
 def content_folder(tmpdir):
     root = str(tmpdir)
-    utilo.file_create(os.path.join(root, 'test.txt'))
-    utilo.file_create(os.path.join(root, 'abc.txt'))
-    utilo.file_create(os.path.join(root, 'www.txt'))
+    utilo.file_create(utilo.join(root, 'test.txt'))
+    utilo.file_create(utilo.join(root, 'abc.txt'))
+    utilo.file_create(utilo.join(root, 'www.txt'))
 
-    os.makedirs(os.path.join(root, 'abc', 'def', 'ghi', 'jklm'))
-    utilo.file_create(os.path.join(root, 'abc/def/ghi/www.txt'))
-    utilo.file_create(os.path.join(root, 'abc/def/ghi/jklm/ggg.txt'))
+    os.makedirs(utilo.join(root, 'abc', 'def', 'ghi', 'jklm'))
+    utilo.file_create(utilo.join(root, 'abc/def/ghi/www.txt'))
+    utilo.file_create(utilo.join(root, 'abc/def/ghi/jklm/ggg.txt'))
     return root
 
 
@@ -137,13 +137,13 @@ def test_file_copy_content_recursive(td, content_folder):  #pylint:disable=W0621
     goal = str(td)
     utilo.copy_content(content_folder, goal, recursive=True)
 
-    assert os.path.exists(os.path.join(goal, 'test.txt'))
-    assert os.path.exists(os.path.join(goal, 'abc.txt'))
-    assert os.path.exists(os.path.join(goal, 'www.txt'))
+    assert os.path.exists(utilo.join(goal, 'test.txt'))
+    assert os.path.exists(utilo.join(goal, 'abc.txt'))
+    assert os.path.exists(utilo.join(goal, 'www.txt'))
 
-    assert os.path.exists(os.path.join(goal, 'abc/def/ghi/jklm'))
-    assert os.path.exists(os.path.join(goal, 'abc/def/ghi/www.txt'))
-    assert os.path.exists(os.path.join(goal, 'abc/def/ghi/jklm/ggg.txt'))
+    assert os.path.exists(utilo.join(goal, 'abc/def/ghi/jklm'))
+    assert os.path.exists(utilo.join(goal, 'abc/def/ghi/www.txt'))
+    assert os.path.exists(utilo.join(goal, 'abc/def/ghi/jklm/ggg.txt'))
 
 
 def test_file_copy_content_verbose(td, content_folder, capsys):  #pylint:disable=W0621
@@ -162,11 +162,11 @@ def test_file_copy_content_recursive_false(td, content_folder):  #pylint:disable
     goal = str(td)
     utilo.copy_content(content_folder, goal, recursive=False)
 
-    assert os.path.exists(os.path.join(goal, 'test.txt'))
-    assert os.path.exists(os.path.join(goal, 'abc.txt'))
-    assert os.path.exists(os.path.join(goal, 'www.txt'))
+    assert os.path.exists(utilo.join(goal, 'test.txt'))
+    assert os.path.exists(utilo.join(goal, 'abc.txt'))
+    assert os.path.exists(utilo.join(goal, 'www.txt'))
 
-    assert os.path.exists(os.path.join(goal, 'abc'))
+    assert os.path.exists(utilo.join(goal, 'abc'))
 
 
 @pytest.mark.parametrize(
@@ -196,7 +196,7 @@ def test_file_copy_content_pattern(
     content_folder,
 ):  # pylint:disable=W0621
     source = content_folder
-    utilo.file_create(os.path.join(source, 'hallotxt'))
+    utilo.file_create(utilo.join(source, 'hallotxt'))
 
     root = str(td)
 
@@ -206,7 +206,7 @@ def test_file_copy_content_pattern(
 
 
 def test_file_replace_file(td):
-    path = os.path.join(str(td), 'file.txt')
+    path = utilo.join(str(td), 'file.txt')
     assert not os.path.exists(path)
 
     utilo.file_replace(path, 'Content')
@@ -226,17 +226,17 @@ def test_file_copy_content_file_to_directory(td):
     td = str(td)
     filename = 'abc.txt'
     utilo.file_create(filename)
-    destination = os.path.join(td, 'destination')
+    destination = utilo.join(td, 'destination')
     utilo.copy_content(filename, destination)
 
-    assert os.path.exists(os.path.join(destination, filename))
+    assert os.path.exists(utilo.join(destination, filename))
 
 
 def test_file_copy_content_file_to_file(td):
     td = str(td)
     filename = 'abc.txt'
     utilo.file_create(filename)
-    destination = os.path.join(td, 'cba.txt')
+    destination = utilo.join(td, 'cba.txt')
     utilo.copy_content(filename, destination)
 
     assert os.path.exists(destination)
@@ -246,7 +246,7 @@ def test_file_copy_content_directory_to_directory(td):
     td = str(td)
     folder = prepare_example(td)
 
-    goal = os.path.join(td, 'goal')
+    goal = utilo.join(td, 'goal')
     utilo.copy_content(folder, goal)
 
     assert len(os.listdir(goal)) == 3, os.listdir(goal)
@@ -276,15 +276,13 @@ def test_file_copy_content_access_error(
 
     TODO: refactor/simplify with: file_lock/file_unlock
     """
-    root = str(td)
-    source = os.path.join(root, 'source')
-    sink = os.path.join(root, 'sink')
-
+    source = utilo.join(td.tmpdir, 'source')
+    sink = utilo.join(td.tmpdir, 'sink')
     for item in (source, sink):
         os.makedirs(item)
-        pdf = os.path.join(item, 'single.pdf')
+        pdf = utilo.join(item, 'single.pdf')
         utilo.file_create(pdf)
-    notdouble = os.path.join(source, 'not_double.pdf')
+    notdouble = utilo.join(source, 'not_double.pdf')
     utilo.file_create(notdouble)
 
     def copy(source, _, private: bool = False):  # pylint:disable=W0613
@@ -330,11 +328,11 @@ def test_file_copy_lock_withlock(testdir):
 
 
 def prepare_example(directory):
-    folder = os.path.join(directory, 'first')
+    folder = utilo.join(directory, 'first')
 
-    folder_abc = os.path.join(folder, 'abc.txt')
-    folder_def = os.path.join(folder, 'def.txt')
-    folder_ghi = os.path.join(folder, 'ghi.txt')
+    folder_abc = utilo.join(folder, 'abc.txt')
+    folder_def = utilo.join(folder, 'def.txt')
+    folder_ghi = utilo.join(folder, 'ghi.txt')
 
     os.makedirs(folder)
     for item in (
@@ -412,8 +410,8 @@ def test_file_yaml_path_given():
 def test_file_compare(first_content, second_content, expected_result, td):
     root = str(td)
 
-    first = os.path.join(root, 'first')
-    second = os.path.join(root, 'second')
+    first = utilo.join(root, 'first')
+    second = utilo.join(root, 'second')
     utilo.file_create(first, first_content)
     utilo.file_create(second, second_content)
     equals = utilo.file_compare(first, second)
@@ -422,7 +420,7 @@ def test_file_compare(first_content, second_content, expected_result, td):
 
 def test_file_compare_binary_file(td):
     root = str(td)
-    utf32 = os.path.join(root, 'example.utf32')
+    utf32 = utilo.join(root, 'example.utf32')
     with open(utf32, mode='w', encoding='utf32') as fp:
         fp.write('\u1234')
     equal = utilo.file_compare(utf32, __file__)
@@ -440,7 +438,7 @@ def test_file_compare_not_exists():
 
 def test_file_lock(td):
     root = str(td)
-    first = os.path.join(root, 'locked.abc')
+    first = utilo.join(root, 'locked.abc')
     utilo.file_create(first, 'file to lock')
     assert not utilo.file_islocked(first)
     utilo.file_lock(first)
@@ -477,16 +475,16 @@ def test_file_make_package_root():
 
 def test_file_copy_single_file(td):
     root = str(td)
-    source = os.path.join(root, 'source')
-    dest = os.path.join(root, 'destination')
+    source = utilo.join(root, 'source')
+    dest = utilo.join(root, 'destination')
     os.makedirs(source)
     os.makedirs(dest)
 
-    sourcefile = os.path.join(source, 'hello')
+    sourcefile = utilo.join(source, 'hello')
     utilo.file_create(sourcefile)
 
     utilo.file_copy(sourcefile, dest)
-    assert os.path.exists(os.path.join(dest, 'hello'))
+    assert os.path.exists(utilo.join(dest, 'hello'))
 
 
 def test_file_copy_content_mult(td):
@@ -538,7 +536,7 @@ def test_file_tmpdir():
 
 
 def test_file_replace_binary(tmpdir):
-    path = os.path.join(tmpdir, 'file.hex')
+    path = utilo.join(tmpdir, 'file.hex')
     utilo.file_replace_binary(path, b'Helm')
     # replace content
     utilo.file_replace_binary(path, b'Helm2')
@@ -580,8 +578,8 @@ def test_make_tmpdir():
 def test_make_tmpdir_remove():
     with utilo.make_tmpdir(utilo.ROOT, remove=True) as tmp_dir:
         assert os.path.exists(tmp_dir)
-        os.makedirs(os.path.join(tmp_dir, 'recursive_path'))
-        utilo.file_create(os.path.join(tmp_dir, 'helm.txt'))
+        os.makedirs(utilo.join(tmp_dir, 'recursive_path'))
+        utilo.file_create(utilo.join(tmp_dir, 'helm.txt'))
     assert not os.path.exists(tmp_dir), tmp_dir
 
 
@@ -594,3 +592,13 @@ def test_inform_file_permission(tmpdir, capsys):
     with pytest.raises(PermissionError, match='Permission denied'):
         utilo.file_append(path, content='data')
     assert 'HINT: Ensure that' in utilotest.stderr(capsys)
+
+
+def test_file_create_owner(tmpdir):
+    path = utilo.join(tmpdir, 'file.txt')
+    utilo.file_create(path)
+    info = os.stat(path)
+    mode = info.st_mode
+    # -rw-rw-r-- local
+    # -rw-r--r-- github
+    assert mode in {33204, 33188}

{utilo-2.110.2 → utilo-2.112.0}/tests/test_logger.py

@@ -7,14 +7,12 @@
 # be prosecuted under federal law. Its content is company confidential.
 # =============================================================================
 
-import os
 import time
 
 import pytest
 import utilotest
 
 import utilo
-import utilo.logger
 
 
 def test_skipcollector():
@@ -166,7 +164,7 @@ def test_level_setup():
 
 
 def test_outfile(td):
-    logger = os.path.join(td.tmpdir, 'logging.txt')
+    logger = utilo.join(td.tmpdir, 'logging.txt')
     with utilo.outfile_tmp(logger):
         utilo.log('First Line')
         utilo.log('Second Line')
@@ -179,7 +177,7 @@ def test_outfile(td):
 
 
 def test_outfile_delete_double(td):
-    logger = os.path.join(td.tmpdir, 'logging.txt')
+    logger = utilo.join(td.tmpdir, 'logging.txt')
     with utilo.outfile_tmp(logger):
         utilo.outfile_setup(None)
         utilo.outfile_setup(None)

{utilo-2.110.2 → utilo-2.112.0}/tests/test_utils.py

@@ -48,7 +48,7 @@ def test_chdir(td):
     exceptions are handled correctly."""
     root = str(td)
 
-    folder = os.path.join(root, 'folder')
+    folder = utilo.join(root, 'folder')
     os.makedirs(folder)
     assert os.path.exists(folder)
 
@@ -75,7 +75,7 @@ def test_chdir_to_filepath(td):
     """Test to change to a file location with contextmanager."""
     root = str(td)
 
-    filepath = os.path.join(root, 'hello')
+    filepath = utilo.join(root, 'hello')
     utilo.file_create(filepath)
 
     assert os.path.exists(filepath)

{utilo-2.110.2 → utilo-2.112.0}/utilo/baw.py

@@ -15,17 +15,25 @@ import utilo
 BAW = '.baw'
 
 
-def baw_root(path: str) -> str:
+def baw_root(path: str, fail: bool = False) -> str:
     """Go upwards till project config file occurs.
 
     >>> baw_root(__file__)
     '...'
+    >>> baw_root('/does/not/exists/', fail=True)
+    Traceback (most recent call last):
+    ...
+    SystemExit: 1
+    >>> baw_root('/does/not/exists/', fail=False) is None
+    True
     """
     current = str(path)
-    while not utilo.exists(utilo.join(current, BAW)):  # pylint:disable=W0149
+    while not utilo.exists(utilo.join(current, BAW)):
         current, base = os.path.split(current)
         if not str(base).strip():
             # root of file sytem
+            if fail:
+                utilo.exitx('could not determine .baw file')
             return None
     return current
 

{utilo-2.110.2 → utilo-2.112.0}/utilo/file/__init__.py

@@ -21,6 +21,8 @@ import stat
 import sys
 import tempfile
 
+import filelock
+
 import utilo
 import utilo.file.securewrapper
 import utilo.typechecker
@@ -82,11 +84,22 @@ def file_append(path: str, content: str, create: bool = False, private: bool = F
         fp.write(content)
 
 
+@contextlib.contextmanager
+def lock_file(path: str, lock: bool = True):  # pylint:disable=unused-argument
+    if not lock:
+        yield
+        return
+    lockpath = utilo.tmpfile(root=tmp('/utilo'))
+    with filelock.FileLock(lockpath):
+        yield
+
+
 def file_create(
     path: str,
     content: str = '',
     private: bool = False,
-    base: str = None,
+    base: str | None = None,
+    lock: bool = True,
 ):
     """Create file `path` with the content `content`
 
@@ -94,23 +107,25 @@ def file_create(
         path(str): path to write file, path must not exists
         content(str): content to write in given `path`
         private(bool): if True, use encryption
-        base(str): add base to path
+        base(str | None): add base to path
+        lock(bool): if True use FileLock to protect file create
     Hint:
         If file exists, an assertion is raised.
     """
     if base:
         path = utilo.join(base, path)
-    parent = utilo.path_parent(path)
-    assert os.path.exists(parent) or not parent, f'{parent} does not exists'
-    assert not os.path.exists(path), f'{path} already exists'
-    with utilo.file.securewrapper.open(
-            path,
-            mode='w',
-            newline=utilo.NL,
-            encoding=utilo.U8,
-            private=private,
-    ) as fp:
-        fp.write(content)
+    with lock_file(path, lock=lock):
+        parent = utilo.path_parent(path)
+        assert os.path.exists(parent) or not parent, f'{parent} does not exists'
+        assert not os.path.exists(path), f'{path} already exists'
+        with utilo.file.securewrapper.open(
+                path,
+                mode='w',
+                newline=utilo.NL,
+                encoding=utilo.U8,
+                private=private,
+        ) as fp:
+            fp.write(content)
 
 
 def file_create_tmp(
@@ -141,40 +156,64 @@ def file_create_tmp(
     return path
 
 
-def file_create_binary(path: str, content: bytes = b'', private: bool = False):
+def file_create_binary(
+    path: str,
+    content: bytes = b'',
+    private: bool = False,
+    lock: bool = True,
+):
     """Create file `path` with the content `content`
 
     Args:
         path(str): path to write file, path must not exists
         content(str): content to write in given `path`
         private(bool): if True, use encryption
+        lock(bool): if True use FileLock to protect file create
     Hint:
         If file already exists, an assertion is raised.
     """
     parent = utilo.path_parent(path)
-    assert os.path.exists(parent) or not parent, f'{parent} does not exists'
-    assert not os.path.exists(path), f'{path} already exists'
-    with utilo.file.securewrapper.open(path, mode='wb', private=private) as fp:
-        fp.write(content)
-
-
-def file_read(path: str, size: int = -1, private: bool = False):
-    utilo.exists_assert(path)
-    with utilo.file.securewrapper.open(
-            path,
-            mode='r',
-            newline=utilo.NL,
-            encoding=utilo.U8,
-            private=private,
-    ) as fp:
-        return fp.read(size)
-
-
-def file_read_binary(path: str, size: int = -1, private: bool = False) -> bytes:
+    with lock_file(path, lock=lock):
+        assert os.path.exists(parent) or not parent, f'{parent} does not exists'
+        assert not os.path.exists(path), f'{path} already exists'
+        with utilo.file.securewrapper.open(
+                path,
+                mode='wb',
+                private=private,
+        ) as fp:
+            fp.write(content)
+
+
+def file_read(
+    path: str,
+    size: int = -1,
+    private: bool = False,
+    lock: bool = True,
+):
+    with lock_file(path, lock=lock):
+        utilo.exists_assert(path)
+        with utilo.file.securewrapper.open(
+                path,
+                mode='r',
+                newline=utilo.NL,
+                encoding=utilo.U8,
+                private=private,
+        ) as fp:
+            return fp.read(size)
+
+
+def file_read_binary(
+    path: str,
+    size: int = -1,
+    private: bool = False,
+    lock: bool = True,
+) -> bytes:
     """Read binary file content"""
-    utilo.exists_assert(path)
-    with utilo.file.securewrapper.open(path, mode='rb', private=private) as fp:
-        content = fp.read(size)
+    with lock_file(path, lock=lock):
+        utilo.exists_assert(path)
+        with utilo.file.securewrapper.open(path, mode='rb',
+                                           private=private) as fp:
+            content = fp.read(size)
     return content
 
 
@@ -186,33 +225,44 @@ def file_remove(path: str):
     os.remove(path)
 
 
-def file_replace(path: str, content: str, private: bool = False):
+def file_replace(
+    path: str,
+    content: str,
+    private: bool = False,
+    lock: bool = True,
+):
     """Replace file content.
 
     Args:
         path(str): path to file
         content(str): content to write
         private(bool): if True, use encryption
+        lock(bool): if True use FileLock to protect file create
 
     1. If not exit, create file
     2. If exists,   compare content, if changed than replace
                                      if not, do nothing
     """
-    if not os.path.exists(path):
-        file_create(path, content, private=private)
-        return
-    current_content = file_read(path, private=private)
-    if current_content == content:
-        return
-
-    with utilo.file.securewrapper.open(
-            path,
-            mode='w',
-            newline=utilo.NL,
-            encoding=utilo.U8,
-            private=private,
-    ) as fp:
-        fp.write(content)
+    with lock_file(path, lock=lock):
+        if not os.path.exists(path):
+            file_create(
+                path,
+                content,
+                private=private,
+                lock=False,
+            )
+            return
+        current_content = file_read(path, private=private)
+        if current_content == content:
+            return
+        with utilo.file.securewrapper.open(
+                path,
+                mode='w',
+                newline=utilo.NL,
+                encoding=utilo.U8,
+                private=private,
+        ) as fp:
+            fp.write(content)
 
 
 def file_replace_binary(path: str, content: bytes, private: bool = False):
@@ -227,15 +277,19 @@ def file_replace_binary(path: str, content: bytes, private: bool = False):
     2. If exists,   compare content, if changed than replace
                                      if not, do nothing
     """
-    if not os.path.exists(path):
-        file_create_binary(path, content, private=private)
-        return
-    current_content = file_read_binary(path, private=private)
-    if current_content == content:
-        return
-
-    with utilo.file.securewrapper.open(path, mode='wb', private=private) as fp:
-        fp.write(content)
+    with lock_file(path, lock=True):
+        if not os.path.exists(path):
+            file_create_binary(path, content, private=private)
+            return
+        current_content = file_read_binary(path, private=private)
+        if current_content == content:
+            return
+        with utilo.file.securewrapper.open(
+                path,
+                mode='wb',
+                private=private,
+        ) as fp:
+            fp.write(content)
 
 
 def file_compare(first: str, second: str) -> bool:
@@ -539,7 +593,7 @@ def tmpfile(root):
     Returns:
         filepath(str): to tempfile in TMPDIR
     """
-    assert root is None or os.path.exists(root)
+    assert root is None or os.path.exists(root), f'root: {root}'
     tmpfolder = tmp(root)
     name = tmpname()
     path = os.path.join(tmpfolder, name)

{utilo-2.110.2 → utilo-2.112.0}/utilo/file/securewrapper.py

@@ -110,12 +110,12 @@ def copy(src, dst, private: bool = False):
         COPY(src, dst)
         return
     header = utilo.file_read_binary(src)
-    header = header[0:len(utilo.file.securewrapper.HEADER_STR)]
-    if header == utilo.file.securewrapper.HEADER_STR:
+    header = header[0:len(HEADER_STR)]
+    if header == HEADER_STR:
         content = utilo.file_read(src, private=True)
         utilo.file_replace(dst, content, private=True)
         return
-    if header == utilo.file.securewrapper.HEADER_BIN:
+    if header == HEADER_BIN:
         content = utilo.file_read_binary(src, private=True)
         utilo.file_replace_binary(dst, content, private=True)
         return

{utilo-2.110.2 → utilo-2.112.0/utilo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utilo
-Version: 2.110.2
+Version: 2.112.0
 Author-email: Helmut Konrad Schewe <helmutus@outlook.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/anaticulae/utilo
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: filelock<5.0.0,>=4.0.0
 Requires-Dist: utilosafe<2.0.0,>=1.0.0
 Provides-Extra: dev
 Requires-Dist: PyYAML<7.0.0,>=6.0.3; extra == "dev"

{utilo-2.110.2 → utilo-2.112.0}/utilo.egg-info/requires.txt

@@ -1,3 +1,4 @@
+filelock<5.0.0,>=4.0.0
 utilosafe<2.0.0,>=1.0.0
 
 [dev]