command_line_args()

# Setup and package directories

global SETUP_DIR, PKG_DIR

setup_dir_name = ("cefpython3-{version}-{os}-setup"

.format(version=VERSION, os=OS_POSTFIX2))

SETUP_DIR = os.path.join(BUILD_DIR, setup_dir_name)

PKG_DIR = os.path.join(SETUP_DIR, "cefpython3")

# Print src and dest for file operations

print("[make_installer.py] Src: {src}".format(src=ROOT_DIR))

print("[make_installer.py] Dst: {dst}".format(dst=SETUP_DIR))

# Make directories

if os.path.exists(SETUP_DIR):

print("[make_installer.py] Delete: {dir}"

.format(dir=SETUP_DIR.replace(ROOT_DIR, "")))

shutil.rmtree(SETUP_DIR)

os.makedirs(SETUP_DIR)

os.makedirs(os.path.join(SETUP_DIR, "examples/"))

os.makedirs(PKG_DIR)

os.makedirs(os.path.join(PKG_DIR, "examples/"))

# Copy files from tools/installer/

copy_tools_installer_files(SETUP_DIR, PKG_DIR)

# Multiple copy operations using glob patterns

copy_operations = [

(ROOT_DIR, "License"), (PKG_DIR,),

(CEF_BINARIES_LIBRARIES, "*.txt"), (PKG_DIR,),

(CEF_BINARIES_LIBRARIES, "bin/*"), (PKG_DIR,),

(CEFPYTHON_BINARY, "*"), (PKG_DIR,),

(EXAMPLES_DIR, "*"), (PKG_DIR, "examples/"),

(EXAMPLES_DIR, "*"), (SETUP_DIR, "examples/"),

]

perform_copy_operations(copy_operations)

# Linux only operations

if LINUX:

copy_operations_linux = [

(LINUX_DIR, "binaries_64bit/kivy_.py"),

(PKG_DIR, "examples/"),

(LINUX_DIR, "binaries_64bit/kivy-select-boxes/*"),

(PKG_DIR, "examples/")

]

perform_copy_operations(copy_operations_linux)

# Create empty debug.log files so that package uninstalls cleanly

# in case examples or CEF tests were launched. See Issue #149.

create_empty_log_file(os.path.join(PKG_DIR, "debug.log"))

create_empty_log_file(os.path.join(PKG_DIR, "examples/debug.log"))

print("[make_installer.py] DONE. Installer package created: {setup_dir}"

.format(setup_dir=SETUP_DIR))

# Optional generation of wheel package

if WHEEL:

print("[make_installer.py] Create Wheel package")

if not len(WHEEL_ARGS):

print("[make_installer.py] ERROR: you must specify flags"

" eg. --python-tag cp27 or --universal")

sys.exit(1)

command = ("{python} setup.py bdist_wheel {wheel_args}"

.format(python=sys.executable,

wheel_args=" ".join(WHEEL_ARGS)))

print("[make_installer.py] Run command: '{0}' in setup directory"

.format(command))

subprocess.check_call(command, cwd=SETUP_DIR, shell=True)

dist_dir = os.path.join(SETUP_DIR, "dist")

files = glob.glob(os.path.join(dist_dir, "*.whl"))

assert len(files) == 1

print("[make_installer.py] DONE. Wheel package created: {0}"

global VERSION, WHEEL, WHEEL_ARGS

args = " ".join(sys.argv)

match = re.search(r"\d+\.\d+", args)

if match:

VERSION = match.group(0)

else:

print(__doc__)

sys.exit(1)

for arg in sys.argv:

if arg == VERSION:

continue

if arg == "--wheel":

WHEEL = True

continue

if WHEEL:

variables = dict()

variables["VERSION"] = VERSION

variables["SYSCONFIG_PLATFORM"] = sysconfig.get_platform()

shutil.copy(

os.path.join(INSTALLER_DIR, "cefpython3.README.txt"),

os.path.join(setup_dir, "README.txt"))

copy_template_file(

os.path.join(INSTALLER_DIR, "cefpython3.setup.py"),

os.path.join(setup_dir, "setup.py"),

variables)

copy_template_file(

os.path.join(INSTALLER_DIR, "cefpython3.__init__.py"),

os.path.join(pkg_dir, "__init__.py"),

"""Copy file and replaces template variables in that file."""

print("[make_installer.py] Copy_t: {src} ==> {dst}"

.format(src=short_src_path(src), dst=short_dst_path(dst)))

with open(src, "rb") as fo:

contents = fo.read().decode("utf-8")

contents = replace_template_vars(contents, variables)

with open(dst, "wb") as fo:

fo.write(contents.encode("utf-8"))

"""Replaces template variables like {{SOME}} in the string

orig_string = string

for key, value in dictionary.items():

string = string.replace("{{"+key+"}}", value)

if string == orig_string:

raise Exception("Nothing to format")

if re.search(r"\{\{[a-zA-Z0-9_]+\}\}", string):

raise Exception("Not all strings were formatted")

assert len(operations) % 2 == 0

count_ops = int(len(operations) / 2)

for op_i in range(count_ops):

# Refer to values by index

pattern = operations[op_i*2]

dst_dir = operations[op_i*2+1]

# Convert tuples to lists

pattern = list(pattern)

dst_dir = list(dst_dir)

# Join paths

pattern = os.path.join(*pattern)

dst_dir = os.path.join(*dst_dir)

dst_dir = os.path.abspath(dst_dir)

# Normalize unix slashes on Windows

pattern = pattern.replace("/", os.path.sep)

# dst_dir must be a directory

if not os.path.isdir(dst_dir):

raise Exception("Not a directory: {dst_dir}"

.format(dst_dir=dst_dir))

# Is pattern a file or a directory

if os.path.isfile(pattern):

if is_ignored_path(pattern):

raise Exception("Copy operation pattern is in ignore list:"

" {pattern}".format(pattern=pattern))

print("[make_installer.py] Copy: {file} ==> {dir}"

.format(file=short_src_path(pattern),

dir=short_dst_path(dst_dir)))

# Destination file must not exist

assert not os.path.exists(os.path.join(dst_dir,

os.path.basename(pattern)))

shutil.copy(pattern, dst_dir)

else:

# pattern is a glob pattern

base_dir = os.path.dirname(pattern)

assert base_dir

assert base_dir == os.path.abspath(base_dir)

paths = glob.glob(pattern)

if not len(paths):

raise Exception("No paths found in: {pattern}"

.format(pattern=pattern))

for path in paths:

# "path" variable contains absolute path

assert path == os.path.abspath(path)

if os.path.isfile(path):

if is_ignored_path(path):

continue

print("[make_installer.py] Copy: {file} ==> {dir}"

.format(file=short_src_path(path),

dir=short_dst_path(dst_dir)))

# Destination file must not exist

assert not os.path.exists(

os.path.join(dst_dir, os.path.basename(path)))

shutil.copy(path, dst_dir)

elif os.path.isdir(path):

if is_ignored_path(path):

continue

relative_dir = path.replace(base_dir, "")

assert relative_dir[0] == os.path.sep

relative_dir = relative_dir[1:]

perform_copy_recursively(base_dir, relative_dir, dst_dir)

else:

real_dir = os.path.join(base_dir, relative_dir)

assert os.path.exists(real_dir) and os.path.isdir(real_dir)

assert os.path.exists(new_dir) and os.path.isdir(new_dir)

# Create subdirectory

new_subdir = os.path.join(new_dir, relative_dir)

if not os.path.exists(new_subdir):

print("[make_installer.py] Create: {dir}"

.format(dir=short_dst_path(new_subdir)))

os.makedirs(new_subdir)

# List directory

paths = os.listdir(real_dir)

for path in paths:

# "path" variable contains relative path

real_path = os.path.join(real_dir, path)

path = os.path.join(relative_dir, path)

if os.path.isdir(real_path):

if is_ignored_path(real_path):

continue

perform_copy_recursively(base_dir, path, new_dir)

elif os.path.isfile(real_path):

if is_ignored_path(real_path):

continue

new_file = os.path.join(new_dir, path)

new_subdir = os.path.dirname(new_file)

if os.path.exists(new_file):

raise Exception("Path aready exists: {new_file}"

.format(new_file=short_dst_path(new_file)))

print("[make_installer.py] Copy: {file} ==> {dir}"

.format(file=short_src_path(real_path),

dir=short_dst_path(new_subdir)))

shutil.copy(real_path, new_subdir)

else:

basename = os.path.basename(path)

if basename in IGNORE_DIRS:

print("[make_installer.py] Ignore: {dir}"

.format(dir=short_src_path(path)))

return True

for ext in IGNORE_EXT:

if path.endswith(ext):

print("[make_installer.py] Ignore: {file}"

.format(file=short_src_path(path)))

return True

assert len(pattern) > 2

# Normalize unix slashes on Windows

pattern = pattern.replace("/", os.path.sep)

print("[make_installer.py] Delete: {pattern}"

.format(pattern=short_dst_path(pattern)))

files = glob.glob(pattern)

for f in files:

# Normalize unix slashes on Windows

log_file = log_file.replace("/", os.path.sep)

print("[make_installer.py] Create: {file}"

.format(file=short_dst_path(log_file)))

with open(log_file, "wb") as fo:

fo.write("".encode("utf-8"))

# On Linux and Mac chmod so that for cases when package is

# installed using sudo. When wheel package is created it

# will remember file permissions set.

if LINUX or MAC:

command = "chmod 666 {file}".format(file=log_file)

print("[make_installer.py] {command}"

.format(command=command.replace(SETUP_DIR, "")))

# Very long: \build\cef55_3.2883.1553.g80bd606_win32\

find = os.path.basename(CEF_BINARIES_LIBRARIES)

if len(find) > 12:

path = path.replace(find, find[:12] + "*")

path = path.replace(ROOT_DIR, "")