execute_args() - Code Metrics - Inspection of "breakout part of lazyloader" - thurask/bbarchivist - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2cdcee...ec0a58 )

by John

created 2017-08-20 03:34 UTC

execute_args() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

#!/usr/bin/env python3
"""Create one autoloader for personal use."""

import argparse  # parse arguments

import sys  # load arguments
import os  # path work
import subprocess  # autoloader running
import requests  # session
from bbarchivist import scriptutils  # script stuff
from bbarchivist import decorators  # timer
from bbarchivist import utilities  # input validation
from bbarchivist import barutils  # file operations
from bbarchivist import bbconstants  # constants/versions
from bbarchivist import networkutils  # download/lookup
from bbarchivist import loadergen  # cap wrapper

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


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

    Invoke :func:`lazyloader.lazyloader_main` with arguments.
    """
    if len(sys.argv) > 1:
        parser = scriptutils.default_parser("bb-lazyloader", "Create one autoloader", ("folder", "osr"))
        devgroup = parser.add_argument_group(
            "devices",
            "Device to load (one required)")
        compgroup = devgroup.add_mutually_exclusive_group()
        compgroup.add_argument(
            "--stl100-1",
            dest="device",
            help="STL100-1",
            action="store_const",
            const=0)
        compgroup.add_argument(
            "--stl100-x",
            dest="device",
            help="STL100-2/3, P'9982",
            action="store_const",
            const=1)
        compgroup.add_argument(
            "--stl100-4",
            dest="device",
            help="STL100-4",
            action="store_const",
            const=2)
        compgroup.add_argument(
            "--q10",
            dest="device",
            help="Q10, Q5, P'9983",
            action="store_const",
            const=3)
        compgroup.add_argument(
            "--z30",
            dest="device",
            help="Z30, Classic, Leap",
            action="store_const",
            const=4)
        compgroup.add_argument(
            "--z3",
            dest="device",
            help="Z3",
            action="store_const",
            const=5)
        compgroup.add_argument(
            "--passport",
            dest="device",
            help="Passport",
            action="store_const",
            const=6)
        parser.add_argument(
            "--run-loader",
            dest="autoloader",
            help="Run autoloader after creation",
            action="store_true",
            default=False)
        parser.add_argument(
            "-n",
            "--no-download",
            dest="download",
            help="Don't download files",
            action="store_false",
            default=True)
        parser.add_argument(
            "-r",
            "--radiosw",
            dest="altsw",
            metavar="SW",
            help="Radio software version; use without software to guess",
            nargs="?",
            const="checkme",
            default=None)
        parser.add_argument(
            "-c",
            "--core",
            dest="core",
            help="Make core/radio loader",
            default=False,
            action="store_true")
        parser.set_defaults(device=None)
        args = parser.parse_args(sys.argv[1:])
        execute_args(args)
    else:
        questionnaire()


def execute_args(args):
    """
    Get args and decide what to do with them.

    :param args: Arguments.
    :type args: argparse.Namespace
    """
    args.folder = scriptutils.generate_workfolder(args.folder)
    if not utilities.is_windows():
        args.autoloader = False
    scriptutils.arg_verify_none(args.os, "No OS specified!")
    scriptutils.arg_verify_none(args.device, "No device specified!")
    lazyloader_main(args.device, args.os, args.radio, args.swrelease, args.folder, args.autoloader, args.download, args.altsw, args.core)


def questionnaire():
    """
    Questions to ask if no arguments given.
    """
    localdir = os.getcwd()
    while True:
        osversion = input("OS VERSION (REQUIRED): ")
        if osversion:
            break
    radioversion = input("RADIO VERSION (PRESS ENTER TO GUESS): ")
    softwareversion = input("OS SOFTWARE RELEASE (PRESS ENTER TO GUESS): ")
    if not softwareversion:
        softwareversion = None
    if not radioversion:
        radioversion = None
        altcheck = False
        altsw = None
    else:
        altcheck = utilities.s2b(input("USING ALTERNATE RADIO (Y/N)?: "))
        if altcheck:
            altsw = input("RADIO SOFTWARE RELEASE (PRESS ENTER TO GUESS): ")
            if not altsw:
                altsw = "checkme"
    print("DEVICES:")
    devlist = ["0=STL100-1",
               "1=STL100-2/3/P9982",
               "2=STL100-4",
               "3=Q10/Q5/P9983",
               "4=Z30/CLASSIC/LEAP",
               "5=Z3",
               "6=PASSPORT"]
    utilities.lprint(devlist)
    while True:
        device = int(input("SELECTED DEVICE: "))
        if not 0 <= device <= len(devlist) - 1:
            continue
        else:
            break
    if utilities.is_windows():
        autoloader = utilities.s2b(
            input("RUN AUTOLOADER - WILL WIPE YOUR DEVICE! (Y/N)?: "))
    else:
        autoloader = False
    print(" ")
    lazyloader_main(
        device,
        osversion,
        radioversion,
        softwareversion,
        localdir,
        autoloader,
        True,
        altsw,
        False)


def lazyloader_main(device, osversion, radioversion=None,
                    softwareversion=None, localdir=None, autoloader=False,
                    download=True, altsw=None, core=False):
    """
    Wrap the tools necessary to make one autoloader.

    :param device: Device family to create loader for.
    :type device: int

    :param osversion: OS version, 10.x.y.zzzz.
    :type osversion: str

    :param radioversion: Radio version, 10.x.y.zzzz.
    :type radioversion: str

    :param softwareversion: Software version, 10.x.y.zzzz.
    :type softwareversion: str

    :param localdir: Working path. Default is local dir.
    :type localdir: str

    :param autoloader: Whether to run loader. Default is false. Windows-only.
    :type autoloader: bool

    :param download: Whether to download files. Default is true.
    :type download: bool

    :param altsw: Radio software release, if not the same as OS.
    :type altsw: str

    :param core: Whether to create a core/radio loader. Default is false.
    :type core: bool
    """
    radioversion = scriptutils.return_radio_version(osversion, radioversion)
    softwareversion, swc = scriptutils.return_sw_checked(softwareversion, osversion)
    if altsw == "checkme":
        altsw, altchecked = scriptutils.return_radio_sw_checked(altsw, radioversion)
    scriptutils.standard_preamble("lazyloader", osversion, softwareversion, radioversion, altsw)
    print("DEVICE: {0}".format(bbconstants.DEVICES[device]))

    # Make dirs
    bd_o, bd_r, ld_o, ld_r, zd_o, zd_r = barutils.make_dirs(localdir, osversion, radioversion)
    osurl = radiourl = None

    # Create download URLs
    baseurl = utilities.create_base_url(softwareversion)
    if altsw:
        alturl = utilities.create_base_url(altsw)
    osurl, radiourl = utilities.generate_lazy_urls(softwareversion, osversion, radioversion, device)
    if altsw:
        radiourl = radiourl.replace(baseurl, alturl)
    if core:
        osurl = osurl.replace(".desktop", "")

    #Terminate if device is STL100-1 and OS >= 10.3.3
    splitos = [int(i) for i in osversion.split(".")]
    if device == 0 and utilities.newer_103(splitos, 3):
        print("STL100-1 UNSUPPORTED IN 10.3.3+!")
        print("\nEXITING...")
        raise SystemExit

    if download:
        # Check availability of software releases
        scriptutils.check_sw(baseurl, softwareversion, swc)
        if altsw:
            scriptutils.check_radio_sw(alturl, altsw, altchecked)

        # Check availability of OS, radio
        scriptutils.check_os_single(osurl, osversion, device)
        radiourl, radioversion = scriptutils.check_radio_single(radiourl, radioversion)
    dllist = [osurl, radiourl]

    # Check cached
    osfile = os.path.join(localdir, bd_o, os.path.basename(osurl))
    radfile = os.path.join(localdir, bd_r, os.path.basename(radiourl))

    if download:
        # Download files
        print("DOWNLOADING...")
        sess = requests.Session()
        networkutils.download_bootstrap(dllist, outdir=localdir, workers=2, session=sess)
    elif all(os.path.exists(x) for x in [osfile, radfile]):
        # Already downloaded in previous session
        print("USING CACHED OS/RADIO...")
        barutils.replace_bar_pair(localdir, osfile, radfile)

    # Test bar files
    scriptutils.test_bar_files(localdir, dllist)

    # Extract bar files
    print("EXTRACTING...")
    barutils.extract_bars(localdir)

    # Test signed files
    scriptutils.test_signed_files(localdir)

    # Move bar files
    print("MOVING BAR FILES...")
    barutils.move_bars(localdir, bd_o, bd_r)

    # Generate loader
    altradio = radioversion if altsw else None
    loadergen.generate_lazy_loader(osversion, device, os.path.abspath(localdir), altradio, core)

    # Test loader
    suffix = loadergen.format_suffix(bool(altradio), altradio, core)
    loadername = loadergen.generate_filename(device, osversion, suffix)
    loaderpath = os.path.join(localdir, loadername)
    scriptutils.test_single_loader(loaderpath)

    # Remove signed files
    print("REMOVING SIGNED FILES...")
    barutils.remove_signed_files(localdir)

    # Move loaders
    print("MOVING LOADERS...")
    barutils.move_loaders(localdir, ld_o, ld_r, zd_o, zd_r)
    loadername = os.path.join(ld_o, loadername)

    # Delete empty folders
    print("REMOVING EMPTY FOLDERS...")
    barutils.remove_empty_folders(localdir)

    if autoloader:
        subprocess.call(loadername)
    print("\nFINISHED!!!")


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


1			#!/usr/bin/env python3
2			"""Create one autoloader for personal use."""
3
4			import argparse # parse arguments
			0 ignored issues – show Unused Code introduced 2017-08-20 03:37 UTC by Report Bug Copy Issue Report The import `argparse` seems to be unused. Loading history...
5			import sys # load arguments
6			import os # path work
7			import subprocess # autoloader running
8			import requests # session
9			from bbarchivist import scriptutils # script stuff
10			from bbarchivist import decorators # timer
11			from bbarchivist import utilities # input validation
12			from bbarchivist import barutils # file operations
13			from bbarchivist import bbconstants # constants/versions
14			from bbarchivist import networkutils # download/lookup
15			from bbarchivist import loadergen # cap wrapper
16
17			__author__ = "Thurask"
18			__license__ = "WTFPL v2"
19			__copyright__ = "2015-2017 Thurask"
20
21
22			@decorators.timer
23			def grab_args():
24			"""
25			Parse arguments from argparse/questionnaire.
26
27			Invoke :func:`lazyloader.lazyloader_main` with arguments.
28			"""
29			if len(sys.argv) > 1:
30			parser = scriptutils.default_parser("bb-lazyloader", "Create one autoloader", ("folder", "osr"))
31			devgroup = parser.add_argument_group(
32			"devices",
33			"Device to load (one required)")
34			compgroup = devgroup.add_mutually_exclusive_group()
35			compgroup.add_argument(
36			"--stl100-1",
37			dest="device",
38			help="STL100-1",
39			action="store_const",
40			const=0)
41			compgroup.add_argument(
42			"--stl100-x",
43			dest="device",
44			help="STL100-2/3, P'9982",
45			action="store_const",
46			const=1)
47			compgroup.add_argument(
48			"--stl100-4",
49			dest="device",
50			help="STL100-4",
51			action="store_const",
52			const=2)
53			compgroup.add_argument(
54			"--q10",
55			dest="device",
56			help="Q10, Q5, P'9983",
57			action="store_const",
58			const=3)
59			compgroup.add_argument(
60			"--z30",
61			dest="device",
62			help="Z30, Classic, Leap",
63			action="store_const",
64			const=4)
65			compgroup.add_argument(
66			"--z3",
67			dest="device",
68			help="Z3",
69			action="store_const",
70			const=5)
71			compgroup.add_argument(
72			"--passport",
73			dest="device",
74			help="Passport",
75			action="store_const",
76			const=6)
77			parser.add_argument(
78			"--run-loader",
79			dest="autoloader",
80			help="Run autoloader after creation",
81			action="store_true",
82			default=False)
83			parser.add_argument(
84			"-n",
85			"--no-download",
86			dest="download",
87			help="Don't download files",
88			action="store_false",
89			default=True)
90			parser.add_argument(
91			"-r",
92			"--radiosw",
93			dest="altsw",
94			metavar="SW",
95			help="Radio software version; use without software to guess",
96			nargs="?",
97			const="checkme",
98			default=None)
99			parser.add_argument(
100			"-c",
101			"--core",
102			dest="core",
103			help="Make core/radio loader",
104			default=False,
105			action="store_true")
106			parser.set_defaults(device=None)
107			args = parser.parse_args(sys.argv[1:])
108			execute_args(args)
109			else:
110			questionnaire()
111
112
113			def execute_args(args):
114			"""
115			Get args and decide what to do with them.
116
117			:param args: Arguments.
118			:type args: argparse.Namespace
119			"""
120			args.folder = scriptutils.generate_workfolder(args.folder)
121			if not utilities.is_windows():
122			args.autoloader = False
123			scriptutils.arg_verify_none(args.os, "No OS specified!")
124			scriptutils.arg_verify_none(args.device, "No device specified!")
125			lazyloader_main(args.device, args.os, args.radio, args.swrelease, args.folder, args.autoloader, args.download, args.altsw, args.core)
126
127
128			def questionnaire():
129			"""
130			Questions to ask if no arguments given.
131			"""
132			localdir = os.getcwd()
133			while True:
134			osversion = input("OS VERSION (REQUIRED): ")
135			if osversion:
136			break
137			radioversion = input("RADIO VERSION (PRESS ENTER TO GUESS): ")
138			softwareversion = input("OS SOFTWARE RELEASE (PRESS ENTER TO GUESS): ")
139			if not softwareversion:
140			softwareversion = None
141			if not radioversion:
142			radioversion = None
143			altcheck = False
144			altsw = None
145			else:
146			altcheck = utilities.s2b(input("USING ALTERNATE RADIO (Y/N)?: "))
147			if altcheck:
148			altsw = input("RADIO SOFTWARE RELEASE (PRESS ENTER TO GUESS): ")
149			if not altsw:
150			altsw = "checkme"
151			print("DEVICES:")
152			devlist = ["0=STL100-1",
153			"1=STL100-2/3/P9982",
154			"2=STL100-4",
155			"3=Q10/Q5/P9983",
156			"4=Z30/CLASSIC/LEAP",
157			"5=Z3",
158			"6=PASSPORT"]
159			utilities.lprint(devlist)
160			while True:
161			device = int(input("SELECTED DEVICE: "))
162			if not 0 <= device <= len(devlist) - 1:
163			continue
164			else:
165			break
166			if utilities.is_windows():
167			autoloader = utilities.s2b(
168			input("RUN AUTOLOADER - WILL WIPE YOUR DEVICE! (Y/N)?: "))
169			else:
170			autoloader = False
171			print(" ")
172			lazyloader_main(
173			device,
174			osversion,
175			radioversion,
176			softwareversion,
177			localdir,
178			autoloader,
179			True,
180			altsw,
181			False)
182
183
184			def lazyloader_main(device, osversion, radioversion=None,
185			softwareversion=None, localdir=None, autoloader=False,
186			download=True, altsw=None, core=False):
187			"""
188			Wrap the tools necessary to make one autoloader.
189
190			:param device: Device family to create loader for.
191			:type device: int
192
193			:param osversion: OS version, 10.x.y.zzzz.
194			:type osversion: str
195
196			:param radioversion: Radio version, 10.x.y.zzzz.
197			:type radioversion: str
198
199			:param softwareversion: Software version, 10.x.y.zzzz.
200			:type softwareversion: str
201
202			:param localdir: Working path. Default is local dir.
203			:type localdir: str
204
205			:param autoloader: Whether to run loader. Default is false. Windows-only.
206			:type autoloader: bool
207
208			:param download: Whether to download files. Default is true.
209			:type download: bool
210
211			:param altsw: Radio software release, if not the same as OS.
212			:type altsw: str
213
214			:param core: Whether to create a core/radio loader. Default is false.
215			:type core: bool
216			"""
217			radioversion = scriptutils.return_radio_version(osversion, radioversion)
218			softwareversion, swc = scriptutils.return_sw_checked(softwareversion, osversion)
219			if altsw == "checkme":
220			altsw, altchecked = scriptutils.return_radio_sw_checked(altsw, radioversion)
221			scriptutils.standard_preamble("lazyloader", osversion, softwareversion, radioversion, altsw)
222			print("DEVICE: {0}".format(bbconstants.DEVICES[device]))
223
224			# Make dirs
225			bd_o, bd_r, ld_o, ld_r, zd_o, zd_r = barutils.make_dirs(localdir, osversion, radioversion)
226			osurl = radiourl = None
227
228			# Create download URLs
229			baseurl = utilities.create_base_url(softwareversion)
230			if altsw:
231			alturl = utilities.create_base_url(altsw)
232			osurl, radiourl = utilities.generate_lazy_urls(softwareversion, osversion, radioversion, device)
233			if altsw:
234			radiourl = radiourl.replace(baseurl, alturl)
235			if core:
236			osurl = osurl.replace(".desktop", "")
237
238			#Terminate if device is STL100-1 and OS >= 10.3.3
239			splitos = [int(i) for i in osversion.split(".")]
240			if device == 0 and utilities.newer_103(splitos, 3):
241			print("STL100-1 UNSUPPORTED IN 10.3.3+!")
242			print("\nEXITING...")
243			raise SystemExit
244
245			if download:
246			# Check availability of software releases
247			scriptutils.check_sw(baseurl, softwareversion, swc)
248			if altsw:
249			scriptutils.check_radio_sw(alturl, altsw, altchecked)
250
251			# Check availability of OS, radio
252			scriptutils.check_os_single(osurl, osversion, device)
253			radiourl, radioversion = scriptutils.check_radio_single(radiourl, radioversion)
254			dllist = [osurl, radiourl]
255
256			# Check cached
257			osfile = os.path.join(localdir, bd_o, os.path.basename(osurl))
258			radfile = os.path.join(localdir, bd_r, os.path.basename(radiourl))
259
260			if download:
261			# Download files
262			print("DOWNLOADING...")
263			sess = requests.Session()
264			networkutils.download_bootstrap(dllist, outdir=localdir, workers=2, session=sess)
265			elif all(os.path.exists(x) for x in [osfile, radfile]):
266			# Already downloaded in previous session
267			print("USING CACHED OS/RADIO...")
268			barutils.replace_bar_pair(localdir, osfile, radfile)
269
270			# Test bar files
271			scriptutils.test_bar_files(localdir, dllist)
272
273			# Extract bar files
274			print("EXTRACTING...")
275			barutils.extract_bars(localdir)
276
277			# Test signed files
278			scriptutils.test_signed_files(localdir)
279
280			# Move bar files
281			print("MOVING BAR FILES...")
282			barutils.move_bars(localdir, bd_o, bd_r)
283
284			# Generate loader
285			altradio = radioversion if altsw else None
286			loadergen.generate_lazy_loader(osversion, device, os.path.abspath(localdir), altradio, core)
287
288			# Test loader
289			suffix = loadergen.format_suffix(bool(altradio), altradio, core)
290			loadername = loadergen.generate_filename(device, osversion, suffix)
291			loaderpath = os.path.join(localdir, loadername)
292			scriptutils.test_single_loader(loaderpath)
293
294			# Remove signed files
295			print("REMOVING SIGNED FILES...")
296			barutils.remove_signed_files(localdir)
297
298			# Move loaders
299			print("MOVING LOADERS...")
300			barutils.move_loaders(localdir, ld_o, ld_r, zd_o, zd_r)
301			loadername = os.path.join(ld_o, loadername)
302
303			# Delete empty folders
304			print("REMOVING EMPTY FOLDERS...")
305			barutils.remove_empty_folders(localdir)
306
307			if autoloader:
308			subprocess.call(loadername)
309			print("\nFINISHED!!!")
310
311
312			if __name__ == "__main__":
313			grab_args()
314			decorators.enter_to_exit(True)
315

thurask / bbarchivist

Push — master ( 2cdcee...ec0a58 )

execute_args() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like