tclloader_filename() - Code Metrics - Inspection of "clean tclloader script" - thurask/bbarchivist - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d9d086...32d755 )

by John

created 2017-08-18 16:45 UTC

tclloader_filename() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
dl	0
loc	17
rs	9.4285
c	0
b	0
f	0

#!/usr/bin/env python3
"""Generate autoloader from TCL autoloader template."""

import os  # path work
import shutil  # directory work
import sys  # load arguments
from bbarchivist import archiveutils  # zip work
from bbarchivist import decorators  # enter to exit
from bbarchivist import loadergen  # packing loader
from bbarchivist import networkutils  # download android tools
from bbarchivist import scriptutils  # default parser
from bbarchivist import utilities  # argument filters

__author__ = "Thurask"
__license__ = "WTFPL v2"
__copyright__ = "2017 Thurask"


def grab_args():
    """
    Parse arguments from argparse/questionnaire.

    Invoke :func:`tclloader.tclloader_main` with those arguments.
    """
    parser = scriptutils.default_parser("bb-tclloader", "Create autoloaders from TCL templates")
    parser.add_argument("loaderfile",
        help="Loader zip file or directory",
        type=utilities.file_exists)
    parser.add_argument(
        "-n",
        "--name",
        dest="loadername",
        help="Manually specify loader name",
        metavar="NAME",
        default=None)
    parser.add_argument(
        "-d",
        "--directory",
        dest="directory",
        help="Use a directory instead of a zip file",
        action="store_true",
        default=False)
    parser.add_argument(
        "-l",
        "--localtools",
        dest="localtools",
        help="Use local fastboot tools instead of remote",
        action="store_true",
        default=False)
    parser.add_argument(
        "-c",
        "--compress",
        dest="compress",
        help="Compress final autoloader",
        action="store_true",
        default=False)
    args = parser.parse_args(sys.argv[1:])
    parser.set_defaults()
    tclloader_main(args.loaderfile, args.loadername, args.directory, args.localtools, args.compress)


def tclloader_prep(loaderfile, directory=False):
    """
    Prepare directory name and OS version.

    :param loaderfile: Path to input file/folder.
    :type loaderfile: str

    :param directory: If the input file is a folder. Default is False.
    :type directory: bool
    """
    loaderdir = loaderfile if directory else loaderfile.replace(".zip", "")
    osver = loaderdir.split("-")[-1]
    return loaderdir, osver


def tclloader_extract(loaderfile, loaderdir, directory=False):
    """
    Extract autoloader template zip if needed.

    :param loaderfile: Path to input file.
    :type loaderfile: str

    :param loaderdir: Path to output folder.
    :type loaderdir: str

    :param directory: If the input file is a folder. Default is False.
    :type directory: bool
    """
    if not directory:
        print("EXTRACTING FILE")
        archiveutils.extract_zip(loaderfile, loaderdir)


def tclloader_fastboot(localtools=False):
    """
    Download fastboot if needed.

    :param localtools: If fastboot is to be copied from the input itself. Default is False.
    :type localtools: bool
    """
    if not localtools:
        print("DOWNLOADING FASTBOOT")
        networkutils.download_android_tools("plattools")
        print("VERIFYING FASTBOOT")
        andver = archiveutils.verify_android_tools("plattools")
        if andver:
            print("FASTBOOT OK, EXTRACTING")
            archiveutils.extract_android_tools("plattools")
        else:
            print("FASTBOOT DOWNLOAD FAILED, REVERTING TO LOCAL")
            localtools = True
    return localtools


def tclloader_filename(loaderdir, osver, loadername=None):
    """
    Prepare platform and filename.

    :param loaderdir: Path to input folder.
    :type loaderdir: str

    :param osver: OS version.
    :type osver: str

    :param loadername: Name of final autoloader. Default is auto-generated.
    :type loadername: str
    """
    platform = os.listdir(os.path.join(loaderdir, "target", "product"))[0]
    if loadername is None:
        loadername = "{0}_autoloader_user-all-{1}".format(platform, osver)
    return loadername, platform


def tclloader_compress(compress=False, loadername=None):
    """
    Compress the final autoloader if needed.

    :param compress: If the final loader is to be compressed. Default is False.
    :type compress: bool

    :param loadername: Name of final autoloader.
    :type loadername: str
    """
    if compress:
        print("PACKING LOADER")
        archiveutils.pack_tclloader(loadername, loadername)
        print("COMPRESSION FINISHED")


def tclloader_main(loaderfile, loadername=None, directory=False, localtools=False, compress=False):
    """
    Scan every PRD and produce latest versions.

    :param loaderfile: Path to input file/folder.
    :type loaderfile: str

    :param loadername: Name of final autoloader. Default is auto-generated.
    :type loadername: str

    :param directory: If the input file is a folder. Default is False.
    :type directory: bool

    :param localtools: If fastboot is to be copied from the input itself. Default is False.
    :type localtools: bool

    :param compress: If the final loader is to be compressed. Default is False.
    :type compress: bool
    """
    scriptutils.slim_preamble("TCLLOADER")
    loaderdir, osver = tclloader_prep(loaderfile, directory)
    tclloader_extract(loaderfile, loaderdir, directory)
    localtools = tclloader_fastboot(localtools)
    loadername, platform = tclloader_filename(loaderdir, osver, loadername)
    print("CREATING LOADER")
    loadergen.generate_tclloader(loaderdir, loadername, platform, localtools)
    shutil.rmtree("plattools")
    tclloader_compress(compress, loadername)
    print("LOADER COMPLETE!")


if __name__ == "__main__":
    grab_args()
    decorators.enter_to_exit(False)


1			#!/usr/bin/env python3
2			"""Generate autoloader from TCL autoloader template."""
3
4			import os # path work
5			import shutil # directory work
6			import sys # load arguments
7			from bbarchivist import archiveutils # zip work
8			from bbarchivist import decorators # enter to exit
9			from bbarchivist import loadergen # packing loader
10			from bbarchivist import networkutils # download android tools
11			from bbarchivist import scriptutils # default parser
12			from bbarchivist import utilities # argument filters
13
14			__author__ = "Thurask"
15			__license__ = "WTFPL v2"
16			__copyright__ = "2017 Thurask"
17
18
19			def grab_args():
20			"""
21			Parse arguments from argparse/questionnaire.
22
23			Invoke :func:`tclloader.tclloader_main` with those arguments.
24			"""
25			parser = scriptutils.default_parser("bb-tclloader", "Create autoloaders from TCL templates")
26			parser.add_argument("loaderfile",
27			help="Loader zip file or directory",
28			type=utilities.file_exists)
29			parser.add_argument(
30			"-n",
31			"--name",
32			dest="loadername",
33			help="Manually specify loader name",
34			metavar="NAME",
35			default=None)
36			parser.add_argument(
37			"-d",
38			"--directory",
39			dest="directory",
40			help="Use a directory instead of a zip file",
41			action="store_true",
42			default=False)
43			parser.add_argument(
44			"-l",
45			"--localtools",
46			dest="localtools",
47			help="Use local fastboot tools instead of remote",
48			action="store_true",
49			default=False)
50			parser.add_argument(
51			"-c",
52			"--compress",
53			dest="compress",
54			help="Compress final autoloader",
55			action="store_true",
56			default=False)
57			args = parser.parse_args(sys.argv[1:])
58			parser.set_defaults()
59			tclloader_main(args.loaderfile, args.loadername, args.directory, args.localtools, args.compress)
60
61
62			def tclloader_prep(loaderfile, directory=False):
63			"""
64			Prepare directory name and OS version.
65
66			:param loaderfile: Path to input file/folder.
67			:type loaderfile: str
68
69			:param directory: If the input file is a folder. Default is False.
70			:type directory: bool
71			"""
72			loaderdir = loaderfile if directory else loaderfile.replace(".zip", "")
73			osver = loaderdir.split("-")[-1]
74			return loaderdir, osver
75
76
77			def tclloader_extract(loaderfile, loaderdir, directory=False):
78			"""
79			Extract autoloader template zip if needed.
80
81			:param loaderfile: Path to input file.
82			:type loaderfile: str
83
84			:param loaderdir: Path to output folder.
85			:type loaderdir: str
86
87			:param directory: If the input file is a folder. Default is False.
88			:type directory: bool
89			"""
90			if not directory:
91			print("EXTRACTING FILE")
92			archiveutils.extract_zip(loaderfile, loaderdir)
93
94
95			def tclloader_fastboot(localtools=False):
96			"""
97			Download fastboot if needed.
98
99			:param localtools: If fastboot is to be copied from the input itself. Default is False.
100			:type localtools: bool
101			"""
102			if not localtools:
103			print("DOWNLOADING FASTBOOT")
104			networkutils.download_android_tools("plattools")
105			print("VERIFYING FASTBOOT")
106			andver = archiveutils.verify_android_tools("plattools")
107			if andver:
108			print("FASTBOOT OK, EXTRACTING")
109			archiveutils.extract_android_tools("plattools")
110			else:
111			print("FASTBOOT DOWNLOAD FAILED, REVERTING TO LOCAL")
112			localtools = True
113			return localtools
114
115
116			def tclloader_filename(loaderdir, osver, loadername=None):
117			"""
118			Prepare platform and filename.
119
120			:param loaderdir: Path to input folder.
121			:type loaderdir: str
122
123			:param osver: OS version.
124			:type osver: str
125
126			:param loadername: Name of final autoloader. Default is auto-generated.
127			:type loadername: str
128			"""
129			platform = os.listdir(os.path.join(loaderdir, "target", "product"))[0]
130			if loadername is None:
131			loadername = "{0}_autoloader_user-all-{1}".format(platform, osver)
132			return loadername, platform
133
134
135			def tclloader_compress(compress=False, loadername=None):
136			"""
137			Compress the final autoloader if needed.
138
139			:param compress: If the final loader is to be compressed. Default is False.
140			:type compress: bool
141
142			:param loadername: Name of final autoloader.
143			:type loadername: str
144			"""
145			if compress:
146			print("PACKING LOADER")
147			archiveutils.pack_tclloader(loadername, loadername)
148			print("COMPRESSION FINISHED")
149
150
151			def tclloader_main(loaderfile, loadername=None, directory=False, localtools=False, compress=False):
152			"""
153			Scan every PRD and produce latest versions.
154
155			:param loaderfile: Path to input file/folder.
156			:type loaderfile: str
157
158			:param loadername: Name of final autoloader. Default is auto-generated.
159			:type loadername: str
160
161			:param directory: If the input file is a folder. Default is False.
162			:type directory: bool
163
164			:param localtools: If fastboot is to be copied from the input itself. Default is False.
165			:type localtools: bool
166
167			:param compress: If the final loader is to be compressed. Default is False.
168			:type compress: bool
169			"""
170			scriptutils.slim_preamble("TCLLOADER")
171			loaderdir, osver = tclloader_prep(loaderfile, directory)
172			tclloader_extract(loaderfile, loaderdir, directory)
173			localtools = tclloader_fastboot(localtools)
174			loadername, platform = tclloader_filename(loaderdir, osver, loadername)
175			print("CREATING LOADER")
176			loadergen.generate_tclloader(loaderdir, loadername, platform, localtools)
177			shutil.rmtree("plattools")
178			tclloader_compress(compress, loadername)
179			print("LOADER COMPLETE!")
180
181
182			if __name__ == "__main__":
183			grab_args()
184			decorators.enter_to_exit(False)
185

thurask / bbarchivist

Push — master ( d9d086...32d755 )

tclloader_filename() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like