dcicutils 8.8.4.1b30__tar.gz → 8.9.0.0b0__tar.gz

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.8.4.1b30
+Version: 8.9.0.0b0
 Summary: Utility package for interacting with the 4DN Data Portal and other 4DN resources
 Home-page: https://github.com/4dn-dcic/utils
 License: MIT
 Author: 4DN-DCIC Team
 Author-email: support@4dnucleome.org
-Requires-Python: >=3.8,<3.13
+Requires-Python: >=3.8,<3.12
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -24,10 +24,9 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Database :: Database Engines/Servers
 Requires-Dist: PyJWT (>=2.6.0,<3.0.0)
 Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
-Requires-Dist: appdirs (>=1.4.4,<2.0.0)
 Requires-Dist: aws-requests-auth (>=0.4.2,<1)
-Requires-Dist: boto3 (>=1.34.93,<2.0.0)
-Requires-Dist: botocore (>=1.34.93,<2.0.0)
+Requires-Dist: boto3 (>=1.28.57,<2.0.0)
+Requires-Dist: botocore (>=1.31.57,<2.0.0)
 Requires-Dist: chardet (>=5.2.0,<6.0.0)
 Requires-Dist: docker (>=4.4.4,<5.0.0)
 Requires-Dist: elasticsearch (==7.13.4)
@@ -43,7 +42,6 @@ Requires-Dist: pytz (>=2020.4)
 Requires-Dist: redis (>=4.5.1,<5.0.0)
 Requires-Dist: requests (>=2.21.0,<3.0.0)
 Requires-Dist: rfc3986 (>=1.4.0,<2.0.0)
-Requires-Dist: shortuuid (>=1.0.13,<2.0.0)
 Requires-Dist: structlog (>=19.2.0,<20.0.0)
 Requires-Dist: toml (>=0.10.1,<1)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/dcicutils/ff_utils.py

@@ -895,12 +895,9 @@ def _get_es_metadata(uuids, es_client, filters, sources, chunk_size, auth):
     used to create the generator.
     Should NOT be used directly
     """
-    def get_es_host_local() -> Optional[str]:
-        return os.environ.get("ES_HOST_LOCAL", None)
     health = get_health_page(key=auth)
     if es_client is None:
-        if not (es_url := get_es_host_local()):
-            es_url = health['elasticsearch']
+        es_url = health['elasticsearch']
         es_client = es_utils.create_es_client(es_url, use_aws_auth=True)
     namespace_star = health.get('namespace', '') + '*'
     # match all given uuids to _id fields

dcicutils-8.9.0.0b0/dcicutils/file_utils.py

@@ -0,0 +1,58 @@
+import glob
+import os
+import pathlib
+from typing import List, Optional, Union
+
+
+def search_for_file(file: str,
+                    location: Union[str, Optional[List[str]]] = None,
+                    recursive: bool = False,
+                    single: bool = False) -> Union[List[str], Optional[str]]:
+    """
+    Searches for the existence of the given file name, first directly in the given directory or list
+    of directories, if specified, and if not then just in the current (working) directory; if the
+    given recursive flag is True then also searches all sub-directories of these directories;
+    returns the full path name to the file if found. If the single flag is True then just the
+    first file which is found is returns (as a string), or None if none; if the single flag
+    is False, then all matched files are returned in a list, or and empty list if none.
+    """
+    if file and isinstance(file, (str, pathlib.PosixPath)):
+        if os.path.isabs(file):
+            if os.path.exists(file):
+                return file if single else [file]
+            return None if single else []
+        files_found = []
+        if not location:
+            location = ["."]
+        elif isinstance(location, (str, pathlib.PosixPath)):
+            location = [location]
+        elif not isinstance(location, list):
+            location = []
+        for directory in location:
+            if not directory:
+                continue
+            if isinstance(directory, (str, pathlib.PosixPath)) and os.path.exists(os.path.join(directory, file)):
+                file_found = os.path.abspath(os.path.normpath(os.path.join(directory, file)))
+                if single:
+                    return file_found
+                if file_found not in files_found:
+                    files_found.append(file_found)
+        if recursive:
+            for directory in location:
+                if not directory:
+                    continue
+                if not directory.endswith("/**") and not file.startswith("**/"):
+                    path = f"{directory}/**/{file}"
+                else:
+                    path = f"{directory}/{file}"
+                files = glob.glob(path, recursive=recursive)
+                if files:
+                    for file_found in files:
+                        file_found = os.path.abspath(file_found)
+                        if single:
+                            return file_found
+                        if file_found not in files_found:
+                            files_found.append(file_found)
+        if files_found:
+            return files_found[0] if single else files_found
+        return None if single else []

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/dcicutils/misc_utils.py

@@ -3,7 +3,6 @@ This file contains functions that might be generally useful.
 """
 
 from collections import namedtuple
-import appdirs
 import contextlib
 import datetime
 import functools
@@ -14,12 +13,10 @@ import json
 import logging
 import math
 import os
-import platform
 import pytz
 import re
 import rfc3986.validators
 import rfc3986.exceptions
-import shortuuid
 import time
 import uuid
 import warnings
@@ -1525,7 +1522,7 @@ def right_trim(list_or_tuple: Union[List[Any], Tuple[Any]],
 def create_dict(**kwargs) -> dict:
     result = {}
     for name in kwargs:
-        if not (kwargs[name] is None):
+        if kwargs[name]:
             result[name] = kwargs[name]
     return result
 
@@ -2551,19 +2548,6 @@ def normalize_spaces(value: str) -> str:
     return re.sub(r"\s+", " ", value).strip()
 
 
-def normalize_string(value: Optional[str]) -> Optional[str]:
-    """
-    Strips leading/trailing spaces, and converts multiple consecutive spaces to a single space
-    in the given string value and returns the result. If the given value is None returns an
-    empty string. If the given value is not actually even a string then return None.
-    """
-    if value is None:
-        return ""
-    elif isinstance(value, str):
-        return re.sub(r"\s+", " ", value).strip()
-    return None
-
-
 def find_nth_from_end(string: str, substring: str, nth: int) -> int:
     """
     Returns the index of the nth occurrence of the given substring within
@@ -2686,48 +2670,3 @@ class JsonLinesReader:
                 yield line
             else:
                 raise Exception(f"If the first line is not a list, all lines must be dictionaries: {line!r}")
-
-
-def get_app_specific_directory() -> str:
-    """
-    Returns the standard system application specific directory:
-    - On MacOS this directory: is: ~/Library/Application Support
-    - On Linux this directory is: ~/.local/share
-    - On Windows this directory is: %USERPROFILE%\AppData\Local  # noqa
-    N.B. This is has been tested on MacOS and Linux but not on Windows.
-    """
-    return appdirs.user_data_dir()
-
-
-def get_os_name() -> str:
-    if os_name := platform.system():
-        if os_name == "Darwin": return "osx"  # noqa
-        elif os_name == "Linux": return "linux"  # noqa
-        elif os_name == "Windows": return "windows"  # noqa
-    return ""
-
-
-def get_cpu_architecture_name() -> str:
-    if os_architecture_name := platform.machine():
-        if os_architecture_name == "x86_64": return "amd64"  # noqa
-        return os_architecture_name
-    return ""
-
-
-def create_uuid(nodash: bool = False, upper: bool = False) -> str:
-    value = str(uuid.uuid4())
-    if nodash is True:
-        value = value.replace("-", "")
-    if upper is True:
-        value = value.upper()
-    return value
-
-
-def create_short_uuid(length: Optional[int] = None, upper: bool = False):
-    # Not really techincally a uuid of course.
-    if (length is None) or (not isinstance(length, int)) or (length < 1):
-        length = 16
-    value = shortuuid.ShortUUID().random(length=length)
-    if upper is True:
-        value = value.upper()
-    return value

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/dcicutils/schema_utils.py

@@ -24,6 +24,7 @@ class JsonSchemaConstants:
 
 
 class EncodedSchemaConstants:
+    DESCRIPTION = "description"
     IDENTIFYING_PROPERTIES = "identifyingProperties"
     LINK_TO = "linkTo"
     MERGE_REF = "$merge"
@@ -187,6 +188,21 @@ def get_one_of_formats(schema: Dict[str, Any]) -> List[str]:
     ]
 
 
+def is_link(property_schema: Dict[str, Any]) -> bool:
+    """Is property schema a link?"""
+    return property_schema.get(SchemaConstants.LINK_TO, False)
+
+
+def get_enum(property_schema: Dict[str, Any]) -> List[str]:
+    """Return the enum of a property schema."""
+    return property_schema.get(SchemaConstants.ENUM, [])
+
+
+def get_description(schema: Dict[str, Any]) -> str:
+    """Return the description of a schema."""
+    return schema.get(SchemaConstants.DESCRIPTION, "")
+
+
 class Schema:
 
     def __init__(self, schema: dict, type: Optional[str] = None) -> None:

dcicutils-8.9.0.0b0/dcicutils/tmpfile_utils.py

@@ -0,0 +1,36 @@
+from contextlib import contextmanager
+import os
+import shutil
+import tempfile
+from typing import List, Optional, Union
+
+
+@contextmanager
+def temporary_directory() -> str:
+    try:
+        with tempfile.TemporaryDirectory() as tmp_directory_name:
+            yield tmp_directory_name
+    finally:
+        remove_temporary_directory(tmp_directory_name)
+
+
+@contextmanager
+def temporary_file(name: Optional[str] = None, suffix: Optional[str] = None,
+                   content: Optional[Union[str, bytes, List[str]]] = None) -> str:
+    with temporary_directory() as tmp_directory_name:
+        tmp_file_name = os.path.join(tmp_directory_name, name or tempfile.mktemp(dir="")) + (suffix or "")
+        with open(tmp_file_name, "wb" if isinstance(content, bytes) else "w") as tmp_file:
+            if content is not None:
+                tmp_file.write("\n".join(content) if isinstance(content, list) else content)
+        yield tmp_file_name
+
+
+def remove_temporary_directory(tmp_directory_name: str) -> None:
+    def is_temporary_directory(path: str) -> bool:
+        try:
+            tmpdir = tempfile.gettempdir()
+            return os.path.commonpath([path, tmpdir]) == tmpdir and os.path.exists(path) and os.path.isdir(path)
+        except Exception:
+            return False
+    if is_temporary_directory(tmp_directory_name):  # Guard against errant deletion.
+        shutil.rmtree(tmp_directory_name)

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/dcicutils/zip_utils.py

@@ -2,9 +2,7 @@ from contextlib import contextmanager
 from dcicutils.tmpfile_utils import temporary_directory, temporary_file
 import gzip
 import os
-import shutil
 import tarfile
-import tempfile
 from typing import List, Optional
 import zipfile
 
@@ -47,28 +45,3 @@ def unpack_gz_file_to_temporary_file(file: str, suffix: Optional[str] = None) ->
                     outputf.write(inputf.read())
                     outputf.close()
                     yield tmp_file_name
-
-
-def extract_file_from_zip(zip_file: str, file_to_extract: str,
-                          destination_file: str, raise_exception: bool = True) -> bool:
-    """
-    Extracts from the given zip file, the given file to extract, writing it to the
-    given destination file. Returns True if all is well, otherwise False, or if the
-    raise_exception argument is True (the default), then raises and exception on error.
-    """
-    try:
-        if not (destination_directory := os.path.dirname(destination_file)):
-            destination_directory = os.getcwd()
-            destination_file = os.path.join(destination_directory, destination_file)
-        with tempfile.TemporaryDirectory() as tmp_directory_name:
-            with zipfile.ZipFile(zip_file, "r") as zipf:
-                if file_to_extract not in zipf.namelist():
-                    return False
-                zipf.extract(file_to_extract, path=tmp_directory_name)
-                os.makedirs(destination_directory, exist_ok=True)
-                shutil.move(os.path.join(tmp_directory_name, file_to_extract), destination_file)
-            return True
-    except Exception as e:
-        if raise_exception:
-            raise e
-    return False

{dcicutils-8.8.4.1b30 → dcicutils-8.9.0.0b0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.8.4.1b30"  # TODO: To become 8.8.5
+version = "8.9.0.0b0"
 description = "Utility package for interacting with the 4DN Data Portal and other 4DN resources"
 authors = ["4DN-DCIC Team <support@4dnucleome.org>"]
 license = "MIT"
@@ -37,13 +37,12 @@ classifiers = [
 
 
 [tool.poetry.dependencies]
-python = ">=3.8,<3.13"
-boto3 = "^1.34.93"
-botocore = "^1.34.93"
+python = ">=3.8,<3.12"
+boto3 = "^1.28.57"
+botocore = "^1.31.57"
 # The DCIC portals (cgap-portal and fourfront) are very particular about which ElasticSearch version.
 # This value is intentionally pinned and must not be changed casually.
 elasticsearch = "7.13.4"
-appdirs = "^1.4.4"
 aws-requests-auth = ">=0.4.2,<1"
 chardet = "^5.2.0"
 docker = "^4.4.4"
@@ -61,7 +60,6 @@ pyperclip = "^1.8.2"
 PyYAML = "^6.0.1"
 requests = "^2.21.0"
 rfc3986 = "^1.4.0"
-shortuuid = "^1.0.13"
 structlog = "^19.2.0"
 toml = ">=0.10.1,<1"
 tqdm = "^4.66.2"
@@ -71,8 +69,8 @@ webtest = "^2.0.34"
 
 
 [tool.poetry.dev-dependencies]
-boto3-stubs = "^1.34.93"
-botocore-stubs = "^1.34.93"
+boto3-stubs = "^1.28.57"
+botocore-stubs = "^1.31.57"
 coverage = ">=7.2.3"
 # Loaded manually in GA workflow for coverage because a dependency on 2to3
 # in its docopts dependency makes a problem for laoding it here in poetry. -kmp 7-Apr-2023

dcicutils-8.8.4.1b30/dcicutils/file_utils.py

@@ -1,267 +0,0 @@
-import glob
-import hashlib
-import io
-import os
-import pathlib
-from datetime import datetime
-import random
-import string
-from tempfile import gettempdir as get_temporary_directory
-from typing import List, Optional, Union
-from uuid import uuid4 as uuid
-
-HOME_DIRECTORY = str(pathlib.Path().home())
-
-
-def search_for_file(file: str,
-                    location: Union[str, Optional[List[str]]] = None,
-                    recursive: bool = False,
-                    single: bool = False,
-                    order: bool = True) -> Union[List[str], Optional[str]]:
-    """
-    Searches for the existence of the given file name, first directly in the given directory or list
-    of directories, if specified, and if not then just in the current (working) directory; if the
-    given recursive flag is True then also searches all sub-directories of these directories;
-    returns the full path name to the file if found. If the single flag is True then just the
-    first file which is found is returns (as a string), or None if none; if the single flag
-    is False, then all matched files are returned in a list, or and empty list if none.
-    """
-    def order_by_fewest_number_of_paths_and_then_alphabetically(paths: List[str]) -> List[str]:
-        def order_by(path: str):
-            return len(path.split(os.path.sep)), path
-        return sorted(paths, key=order_by)
-
-    if not (file and isinstance(file, (str, pathlib.PosixPath))):
-        return None if single is True else []
-    if os.path.isabs(file):
-        if os.path.exists(file):
-            return file if single is True else [file]
-        return None if single is True else []
-    files_found = []
-    if not location:
-        location = ["."]
-    elif isinstance(location, (str, pathlib.PosixPath)):
-        location = [location]
-    elif not isinstance(location, list):
-        location = []
-    location_pruned = []
-    for directory in location:
-        if not isinstance(directory, str):
-            if not isinstance(directory, pathlib.PosixPath):
-                continue
-            directory = str(directory)
-        if not (directory := directory.strip()):
-            continue
-        if os.path.isfile(directory := os.path.abspath(os.path.normpath(directory))):
-            # Allow a file; assume its parent directory was intended.
-            if not (directory := os.path.dirname(directory)):
-                continue
-        if directory not in location_pruned:
-            location_pruned.append(directory)
-    location = location_pruned
-    for directory in location:
-        if os.path.exists(os.path.join(directory, file)):
-            file_found = os.path.abspath(os.path.normpath(os.path.join(directory, file)))
-            if single is True:
-                return file_found
-            if file_found not in files_found:
-                files_found.append(file_found)
-    if recursive is True:
-        for directory in location:
-            if not directory.endswith("/**") and not file.startswith("**/"):
-                path = f"{directory}/**/{file}"
-            else:
-                path = f"{directory}/{file}"
-            files = glob.glob(path, recursive=True if recursive is True else False)
-            if files:
-                for file_found in files:
-                    file_found = os.path.abspath(file_found)
-                    if single is True:
-                        return file_found
-                    if file_found not in files_found:
-                        files_found.append(file_found)
-    if single is True:
-        return files_found[0] if files_found else None
-    elif order is True:
-        return order_by_fewest_number_of_paths_and_then_alphabetically(files_found)
-    else:
-        return files_found
-
-
-def normalize_path(value: Union[str, pathlib.Path], absolute: bool = False, expand_home: Optional[bool] = None) -> str:
-    """
-    Normalizes the given path value and returns the result; does things like remove redundant
-    consecutive directory separators and redundant parent paths. If the given absolute argument
-    is True than converts the path to an absolute path. If the given expand_home argument is False
-    and if the path can reasonably be represented with a home directory indicator (i.e. "~"), then
-    converts it to such. If the expand_home argument is True and path starts with the home directory
-    indicator (i.e. "~") then expands it to the actual (absolute) home path of the caller. If the
-    given path value is not actually even a string (or pathlib.Path) then returns an empty string.
-    """
-    if isinstance(value, pathlib.Path):
-        value = str(value)
-    elif not isinstance(value, str):
-        return ""
-    if not (value := value.strip()) or not (value := os.path.normpath(value)):
-        return ""
-    if expand_home is True:
-        value = os.path.expanduser(value)
-    elif (expand_home is False) and (os.name == "posix"):
-        if value.startswith(home := HOME_DIRECTORY + os.sep):
-            value = "~/" + value[len(home):]
-        elif value == HOME_DIRECTORY:
-            value = "~"
-    if absolute is True:
-        value = os.path.abspath(value)
-    return value
-
-
-def get_file_size(file: str, raise_exception: bool = True) -> Optional[int]:
-    try:
-        return os.path.getsize(file) if isinstance(file, str) else None
-    except Exception:
-        if raise_exception is True:
-            raise
-        return None
-
-
-def get_file_modified_datetime(file: str, raise_exception: bool = True) -> Optional[datetime]:
-    try:
-        return datetime.fromtimestamp(os.path.getmtime(file)) if isinstance(file, str) else None
-    except Exception:
-        if raise_exception is True:
-            raise
-        return None
-
-
-def are_files_equal(filea: str, fileb: str, raise_exception: bool = True) -> bool:
-    """
-    Returns True iff the contents of the two given files are exactly the same.
-    """
-    try:
-        with open(filea, "rb") as fa:
-            with open(fileb, "rb") as fb:
-                chunk_size = 4096
-                while True:
-                    chunka = fa.read(chunk_size)
-                    chunkb = fb.read(chunk_size)
-                    if chunka != chunkb:
-                        return False
-                    if not chunka:
-                        break
-        return True
-    except Exception:
-        if raise_exception is True:
-            raise
-        return False
-
-
-def compute_file_md5(file: str, raise_exception: bool = True) -> str:
-    """
-    Returns the md5 checksum for the given file.
-    """
-    if not isinstance(file, str):
-        return ""
-    try:
-        md5 = hashlib.md5()
-        with open(file, "rb") as file:
-            for chunk in iter(lambda: file.read(4096), b""):
-                md5.update(chunk)
-        return md5.hexdigest()
-    except Exception:
-        if raise_exception is True:
-            raise
-        return ""
-
-
-def compute_file_etag(file: str, raise_exception: bool = True) -> Optional[str]:
-    """
-    Returns the AWS S3 "etag" for the given file; this value is md5-like but
-    not the same as a normal md5. We use this to compare that a file in S3
-    appears to be the exact the same file as a local file.
-    """
-    try:
-        with io.open(file, "rb") as f:
-            return _compute_file_etag(f)
-    except Exception:
-        if raise_exception is True:
-            raise
-        return None
-
-
-def _compute_file_etag(f: io.BufferedReader) -> str:
-    # See: https://stackoverflow.com/questions/75723647/calculate-md5-from-aws-s3-etag
-    MULTIPART_THRESHOLD = 8388608
-    MULTIPART_CHUNKSIZE = 8388608
-    # BUFFER_SIZE = 1048576
-    # Verify some assumptions are correct
-    # assert(MULTIPART_CHUNKSIZE >= MULTIPART_THRESHOLD)
-    # assert((MULTIPART_THRESHOLD % BUFFER_SIZE) == 0)
-    # assert((MULTIPART_CHUNKSIZE % BUFFER_SIZE) == 0)
-    hash = hashlib.md5()
-    read = 0
-    chunks = None
-    while True:
-        # Read some from stdin, if we're at the end, stop reading
-        bits = f.read(1048576)
-        if len(bits) == 0:
-            break
-        read += len(bits)
-        hash.update(bits)
-        if chunks is None:
-            # We're handling a multi-part upload, so switch to calculating
-            # hashes of each chunk
-            if read >= MULTIPART_THRESHOLD:
-                chunks = b''
-        if chunks is not None:
-            if (read % MULTIPART_CHUNKSIZE) == 0:
-                # Dont with a chunk, add it to the list of hashes to hash later
-                chunks += hash.digest()
-                hash = hashlib.md5()
-    if chunks is None:
-        # Normal upload, just output the MD5 hash
-        etag = hash.hexdigest()
-    else:
-        # Multipart upload, need to output the hash of the hashes
-        if (read % MULTIPART_CHUNKSIZE) != 0:
-            # Add the last part if we have a partial chunk
-            chunks += hash.digest()
-        etag = hashlib.md5(chunks).hexdigest() + "-" + str(len(chunks) // 16)
-    return etag
-
-
-def create_random_file(file: Optional[str] = None, prefix: Optional[str] = None, suffix: Optional[str] = None,
-                       nbytes: int = 1024, binary: bool = False, line_length: Optional[int] = None) -> str:
-    """
-    Write to the given file (name/path) some random content. If the given file is None then writes
-    to a temporary file. In either case, returns the file written to. The of bytes written is 1024
-    by default be can be specified with the nbytes argument; default to writing ASCII text but if
-    the binary argument is True then writes binary data as well; if not binary the content is in
-    lines of 80 characters each; use the line_length argumetn in this case to change the line length.
-    """
-    if not isinstance(nbytes, int) or nbytes < 0:
-        nbytes = 0
-    if not isinstance(file, str) or not file:
-        if not isinstance(prefix, str):
-            prefix = ""
-        if not isinstance(suffix, str):
-            suffix = ""
-        file = f"{datetime.utcnow().strftime('%Y%m%d%H%M%S')}{str(uuid()).replace('-', '')}"
-        file = os.path.join(get_temporary_directory(), file)
-    with open(file, "wb" if binary is True else "w") as f:
-        if binary is True:
-            f.write(os.urandom(nbytes))
-        else:
-            if (not isinstance(line_length, int)) or (line_length < 1):
-                line_length = 80
-            line_length += 1
-            nlines = nbytes // line_length
-            nremainder = nbytes % line_length
-            for n in range(nlines):
-                f.write("".join(random.choices(string.ascii_letters + string.digits, k=line_length - 1)))
-                f.write("\n")
-            if nremainder > 1:
-                f.write("".join(random.choices(string.ascii_letters + string.digits, k=nremainder - 1)))
-            if nremainder > 0:
-                f.write("\n")
-    return file

dcicutils-8.8.4.1b30/dcicutils/http_utils.py

@@ -1,39 +0,0 @@
-from contextlib import contextmanager
-import requests
-from typing import Callable, Optional
-from dcicutils.tmpfile_utils import temporary_file
-
-
-@contextmanager
-def download(url: str, suffix: Optional[str] = None, binary: bool = True,
-             progress: Optional[Callable] = None) -> Optional[str]:
-    """
-    Context manager to download the given URL into a temporary file and yields the file
-    path to it. An optional file suffix may be specified for this temporary file name.
-    Defaults to binary file mode; if not desired then pass False as the binary argument.
-    """
-    with temporary_file(suffix=suffix) as file:
-        download_to(url, file, binary=binary, progress=progress)
-        yield file
-
-
-def download_to(url: str, file: str, binary: bool = True, progress: Optional[Callable] = None) -> None:
-    """
-    Download the given URL into the given file. Defaults to binary
-    file mode; if not desired then pass False as the binary argument.
-    """
-    if not callable(progress):
-        progress = None
-    response = requests.get(url, stream=True)
-    if progress:
-        nbytes = 0
-        nbytes_total = None
-        if isinstance(content_length := response.headers.get("Content-Length"), str) and content_length.isdigit():
-            nbytes_total = int(content_length)
-    with open(file, "wb" if binary is True else "w") as f:
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                f.write(chunk)
-            if progress:
-                nbytes += len(chunk)
-                progress(nbytes, nbytes_total)

dcicutils-8.8.4.1b30/dcicutils/tmpfile_utils.py

@@ -1,74 +0,0 @@
-from contextlib import contextmanager
-from datetime import datetime
-import os
-import shutil
-import tempfile
-from uuid import uuid4 as uuid
-from typing import List, Optional, Union
-from dcicutils.file_utils import create_random_file
-
-
-@contextmanager
-def temporary_directory() -> str:
-    try:
-        with tempfile.TemporaryDirectory() as tmp_directory_name:
-            yield tmp_directory_name
-    finally:
-        remove_temporary_directory(tmp_directory_name)
-
-
-@contextmanager
-def temporary_file(name: Optional[str] = None, prefix: Optional[str] = None, suffix: Optional[str] = None,
-                   content: Optional[Union[str, bytes, List[str]]] = None) -> str:
-    with temporary_directory() as tmp_directory_name:
-        tmp_file_name = f"{prefix or ''}{name or tempfile.mktemp(dir='')}{suffix or ''}"
-        tmp_file_path = os.path.join(tmp_directory_name, tmp_file_name)
-        with open(tmp_file_path, "wb" if isinstance(content, bytes) else "w") as tmp_file:
-            if content is not None:
-                tmp_file.write("\n".join(content) if isinstance(content, list) else content)
-        yield tmp_file_path
-
-
-def create_temporary_file_name(prefix: Optional[str] = None, suffix: Optional[str] = None) -> str:
-    """
-    Generates and returns the full path to file within the system temporary directory.
-    """
-    random_string = f"{datetime.utcnow().strftime('%Y%m%d%H%M%S')}{str(uuid()).replace('-', '')}"
-    tmp_file_name = f"{prefix or ''}{random_string}{suffix or ''}"
-    return os.path.join(tempfile.gettempdir(), tmp_file_name)
-
-
-@contextmanager
-def temporary_random_file(prefix: Optional[str] = None, suffix: Optional[str] = None,
-                          nbytes: int = 1024, binary: bool = False, line_length: Optional[int] = None) -> str:
-    with temporary_file(prefix=prefix, suffix=suffix) as tmp_file_path:
-        create_random_file(tmp_file_path, nbytes=nbytes, binary=binary, line_length=line_length)
-        yield tmp_file_path
-
-
-def remove_temporary_directory(tmp_directory_name: str) -> None:
-    """
-    Removes the given directory, recursively; but ONLY if it is (somewhere) within the system temporary directory.
-    """
-    def is_temporary_directory(path: str) -> bool:
-        try:
-            tmpdir = tempfile.gettempdir()
-            return os.path.commonpath([path, tmpdir]) == tmpdir and os.path.exists(path) and os.path.isdir(path)
-        except Exception:
-            return False
-    if is_temporary_directory(tmp_directory_name):  # Guard against errant deletion.
-        shutil.rmtree(tmp_directory_name)
-
-
-def remove_temporary_file(tmp_file_name: str) -> bool:
-    """
-    Removes the given file; but ONLY if it is (somewhere) within the system temporary directory.
-    """
-    try:
-        tmpdir = tempfile.gettempdir()
-        if (os.path.commonpath([tmpdir, tmp_file_name]) == tmpdir) and os.path.isfile(tmp_file_name):
-            os.remove(tmp_file_name)
-            return True
-        return False
-    except Exception:
-        return False