file.py

create_dir

create_dir(dir: str) -> str

Try to create an output directory if one doesn't exist.

Throws an exception if the directory cannot be created. Returns quietly if the directory already exists.

Parameters:

dir
(str) –

name of directory

Returns:

str –

path to directory.

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def create_dir(dir: str) -> str:
    """
    Try to create an output directory if one doesn't exist.

    Throws an exception if the directory cannot be created.
    Returns quietly if the directory already exists.

    Args:
        dir: 
            name of directory

    Returns:
        path to directory.
    """
    try:
        if not exists(dir):
            mkdir(dir)
        else:
            return dir
    except OSError:
        print(f'Cannot create directory "{realpath(dir)}"')
        raise
    except Exception:
        print(Exception)
        raise
    return dir

create_directories

create_directories(
    results_path: Sequence = ("..", "experiments"),
    results_dir: str = "Demo",
    do_clean: bool = False,
) -> str

Create results parent and target directory.

Parameters:

results_path
(Sequence, default: ('..', 'experiments') ) –

path to parent results directory (to be created if necessary)
results_dir
(str, default: 'Demo' ) –

target results directory (to be created)

Returns:

str –

path to target results directory.

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def create_directories(
        results_path: Sequence = ("..", "experiments",), 
        results_dir: str = "Demo",
        do_clean: bool=False,
    ) -> str:
    """
    Create results parent and target directory.

    Args:
        results_path: path to parent results directory
            (to be created if necessary)
        results_dir: target results directory (to be created)

    Returns:
        path to target results directory.
    """
    results_path_ = ["."] + list(results_path)
    create_dir(join(*results_path_))
    results_dir_ = results_path_ + [results_dir]
    if do_clean and exists(join(*results_dir_)):
        rmtree(join(*results_dir_))
    return create_dir(join(*results_dir_))

export_info

export_info(
    info_dir: str,
    file_name: str,
    source_dict: dict,
    module: Any,
    suffix: str | None = None,
    encoding: str = "utf-8",
) -> tuple[dict, str]

Export results dictionary to JSON file.

Tries to ensure all dictionary entries are serializable by running latex on keys and converting values to floats.

Parameters:

info_dir
(str) –

target parent folder
file_name
(str) –

name of output JSON file
module
(Any) –

dplvn or other class module
source_dict
(dict) –

dictionary of results, possibly requiring conversion from latex form such that serialization into a JSON file is possible
suffix
(str | None, default: None ) –

to append to filename prior to addition of '.json' extension

Returns:

tuple[dict, str] –

serialized dictionary and the file path string

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def export_info(
        info_dir: str, 
        file_name: str, 
        source_dict: dict, 
        module: Any,
        suffix: str | None = None,
        encoding: str = "utf-8", #"latin-1"
    ) -> tuple[dict, str]:
    """
    Export results dictionary to JSON file.

    Tries to ensure all dictionary entries are
    serializable by running `latex`
    on keys and converting values to floats.

    Args:
        info_dir: target parent folder
        file_name: name of output JSON file
        module: dplvn or other class module
        source_dict: dictionary of results, possibly requiring conversion
            from latex form such that serialization into a JSON file
            is possible
        suffix: to append to filename prior to addition of '.json' extension

    Returns:
        serialized dictionary and the file path string
    """
    # A bit of recursion for a change
    def render_serializable(source, module,) -> dict:
        serialized: dict = {}
        for item_ in source.items():
            if type(item_[1]) is dict:
                serialized.update(
                    {item_[0]: render_serializable(item_[1], module,)}
                )
            else:
                serialized.update(
                    {item_[0]: to_serializable(item_[1], module,)}
                )
        return serialized

    serializable_dict: dict = render_serializable(source_dict, module,)
    info_path = [str(info_dir)] + [
        str(file_name) + ("_"+suffix if suffix is not None else "") + ".json"
    ]

    file: TextIOWrapper
    with open(join(*info_path), "w", encoding=encoding) as file:
        logging.info(join(*info_path))
        dump(serializable_dict, file, indent=4, ensure_ascii=False,) #separators=(", \n", ": ")
    return (serializable_dict, info_dir,)

export_plot

export_plot(
    fig_name: str,
    fig: Any,
    results_dir: str,
    file_type: str = "pdf",
    suffix: str = "",
    dpi: int | None = None,
) -> None

Export plot to PDF or other format file.

Parameters:

fig_name
(str) –

name to be used for file (extension auto-appended)
fig
(Any) –

figure object
results_dir
(str) –

name of output directory
file_type
(str, default: 'pdf' ) –

file format
suffix
(str, default: '' ) –

filename suffix
dpi
(int | None, default: None ) –

output image resolution

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def export_plot(
        fig_name: str,
        fig: Any,
        results_dir: str,
        file_type: str = "pdf", 
        suffix: str = "",
        dpi: int | None = None,
    ) -> None:
    """
    Export plot to PDF or other format file.

    Args:
        fig_name: name to be used for file (extension auto-appended)
        fig: figure object
        results_dir: name of output directory
        file_type: file format
        suffix: filename suffix
        dpi: output image resolution
    """
    fig_name_ = f"{fig_name}{suffix}.{file_type.lower()}"
    # print(f"{fig_name_} exists: {exists(join(results_dir, fig_name_))}")
    try:
        # logging.info(f'dpi={dpi}')
        fig.savefig(
            join(results_dir, fig_name_),
            bbox_inches="tight",
            pad_inches=0.05,
            dpi=dpi,
            format=file_type,
        )
        logging.info(f'export_plot: Exported "{fig_name_}"')
    except OSError:
        logging.info(
            f'export_plot: Failed to export figure "{fig_name_}"'
        )
        raise
    except:
        raise

export_plots

export_plots(
    fig_dict: dict,
    results_dir: str,
    file_types: list[str] | tuple[str] | str = "png",
    suffix: str = "",
    dpi: int = 150,
    do_verbose: bool = False,
) -> str

Export plots to PDF or other format files.

Parameters:

fig_dict
(dict) –

dictionary of figures
results_dir
(str) –

name of output directory
file_types
(list[str] | tuple[str] | str, default: 'png' ) –

file format (or list of file formats)
suffix
(str, default: '' ) –

filename suffix
dpi
(int, default: 150 ) –

output image resolution
do_verbose
(bool, default: False ) –

use tqdm progress bar to track

Returns:

str –

the supplied export directory

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def export_plots(
        fig_dict: dict,
        results_dir: str,
        file_types: list[str] | tuple[str] | str = "png",
        suffix: str = "",
        dpi: int = 150,
        do_verbose: bool=False,
    ) -> str:
    """
    Export plots to PDF or other format files.

    Args:
        fig_dict: dictionary of figures
        results_dir: name of output directory
        file_types: file format (or list of file formats)
        suffix: filename suffix
        dpi: output image resolution
        do_verbose: use tqdm progress bar to track 

    Returns:
        the supplied export directory
    """
    results_path: str = realpath(results_dir)
    logging.info(
        "gmplib.save.export_plots:\n   " + f'Writing to dir: "{results_path}"'
    )
    file_types_: List[str] = (
        file_types if isinstance(file_types, list) else [str(file_types)]
    )
    progress_bar: Callable = (
        progress if do_verbose else progress_disabled
    )
    for file_type in file_types_:
        # logging.info(f'Image file type: "{file_type}"')
        for fig_name, fig in progress_bar(fig_dict.items(),):
            export_plot(
                fig_name, fig,
                results_path,
                file_type=file_type,
                suffix=suffix,
                dpi=dpi,
            )
    return results_dir

import_info

import_info(info_dir: str, file_name: str, module: Any) -> dict

Read and adapt parameters specified in a JSON file.

Parameters:

info_dir
(str) –

parent folder of JSON file
file_name
(str) –

JSON file name.
module
(Any) –

dplvn or other class module

Returns: info as dictionary.

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def import_info(
        info_dir: str, 
        file_name: str,
        module: Any,
    ) -> dict:
    """
    Read and adapt parameters specified in a JSON file.

    Args:
        info_dir: parent folder of JSON file
        file_name:  JSON file name.
        module: dplvn or other class module

    Returns: info as dictionary.
    """
    file: TextIOWrapper
    raw_info: dict
    info_path = [str(info_dir)] + [f"{file_name}.json"]
    with open(join(*info_path), "r",) as file:
        raw_info = load(file)
    parameters: dict = {}
    for item_ in raw_info["Parameters"].items():
        parameters.update({item_[0]: from_serializable(item_[1], module)})
    info: dict = {
        "Analysis": raw_info["Analysis"],
        "Parameters": parameters,
        "Misc":  raw_info["Misc"]
    }
    return info

read_info

read_info(path: Sequence[str], module: Any) -> tuple[str, dict]

Wrapper around method to import info dictionary.

Parameters:

path
(Sequence[str]) –

to info JSON file.
module
(Any) –

dplvn or other class module

Returns:

tuple[str, dict] –

path to file and imported dictionary

Source code in .venv/lib/python3.14/site-packages/lvn/base/file.py

def read_info(
        path: Sequence[str],
        module: Any,
    ) -> tuple[str, dict]:
    """
    Wrapper around method to import info dictionary.

    Args:
        path: to info JSON file.
        module: dplvn or other class module

    Returns:
        path to file and imported dictionary
    """
    full_path: str = join(pardir, *path,)
    info: dict = import_info(full_path, "Info", module,)
    return (full_path, info,)

file.py

create_dir

`dir`

create_directories

`results_path`

`results_dir`

export_info

`info_dir`

`file_name`

`module`

`source_dict`

`suffix`

export_plot

`fig_name`

`fig`

`results_dir`

`file_type`

`suffix`

`dpi`

export_plots

`fig_dict`

`results_dir`

`file_types`

`suffix`

`dpi`

`do_verbose`

import_info

`info_dir`

`file_name`

`module`

read_info

`path`

`module`