lazyloader_main() - Code Metrics - Inspection of "pylint runthrough" - thurask/bbarchivist - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Retried Inspection

Push — master ( 33284b...c56792 )

by John

created 2018-02-06 01:20 UTC

lazyloader_main() F

↳ Parent: bbarchivist.scripts.lazyloader

Complexity

Conditions

Size

Total Lines

124

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	15
c	0
b	0
f	0
dl	0
loc	124
rs	2

How to fix Long Method Complexity

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

import os  # path work
import subprocess  # autoloader running
import sys  # load arguments

import requests  # session
from bbarchivist import barutils  # file operations
from bbarchivist import bbconstants  # constants/versions
from bbarchivist import decorators  # timer
from bbarchivist import loadergen  # cap wrapper
from bbarchivist import networkutils  # download/lookup
from bbarchivist import scriptutils  # script stuff
from bbarchivist import utilities  # input validation

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


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

    Invoke :func:`lazyloader.lazyloader_main` with arguments.
    """
    if len(sys.argv) > 1:
        argflags = ("folder", "osr")
        parser = scriptutils.default_parser("bb-lazyloader", "Create one autoloader", argflags)
        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_getversions():
    """
    Get OS, radio, and software versions.
    """
    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): ")
    return osversion, radioversion, softwareversion


def questionnaire_check(softwareversion, radioversion):
    """
    Check software and radio versions.

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

    :param radioversion: Radio version, 10.x.y.zzzz.
    :type radioversion: str
    """
    if not softwareversion:
        softwareversion = None
    if not radioversion:
        radioversion = None
        altsw = None
    else:
        radioversion, altsw = questionnaire_radiocheck(radioversion, altsw)

    return softwareversion, radioversion, altsw


def questionnaire_radiocheck(radioversion, altsw):
    """
    Get radio information in working order.

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

    :param altsw: Radio software release, if not the same as OS.
    :type altsw: str
    """
    altcheck = utilities.i2b("USING ALTERNATE RADIO (Y/N)?: ")
    if altcheck:
        altsw = input("RADIO SOFTWARE RELEASE (PRESS ENTER TO GUESS): ")
        if not altsw:
            altsw = "checkme"
    return radioversion, altsw


def questionnaire_devices():
    """
    Ask about which device this script is to be run for.
    """
    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
    return device


def questionnaire_loader():
    """
    Ask about whether to run an autoloader.
    """
    if utilities.is_windows():
        autoloader = utilities.i2b("RUN AUTOLOADER - WILL WIPE YOUR DEVICE! (Y/N)?: ")
    else:
        autoloader = False
    return autoloader


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

thurask / bbarchivist

Push — master ( 33284b...c56792 )

lazyloader_main() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like