def parse_args()

in analysis/webservice/algorithms/Tomogram3D.py [0:0]

• 99 lines of code
• 18 McCabe index (conditional complexity)

    def parse_args(self, compute_options):
        try:
            ds = compute_options.get_dataset()[0]
        except:
            raise NexusProcessingException(reason="'ds' argument is required", code=400)

        parameter_s = compute_options.get_argument('parameter', None)

        try:
            bounding_poly = compute_options.get_bounding_polygon()
        except:
            raise NexusProcessingException(reason='Missing required parameter: b', code=400)

        def get_required_float(name):
            val = compute_options.get_float_arg(name, None)

            if val is None:
                raise NexusProcessingException(reason=f'Missing required parameter: {name}', code=400)

            return val

        min_elevation = get_required_float('minElevation')
        max_elevation = get_required_float('maxElevation')

        output = compute_options.get_argument('output', None)

        if output is not None:
            output = output.upper()

        if output not in ['PNG', 'GIF', 'CSV', 'NETCDF']:
            raise NexusProcessingException(reason=f'Missing or invalid required parameter: output = {output}', code=400)

        orbit_params = compute_options.get_argument('orbit', '30,10')
        view_params = compute_options.get_argument('viewAngle', '30,45')

        frame_duration = compute_options.get_int_arg('frameDuration', 100)

        if output == 'GIF':
            try:
                orbit_params = orbit_params.split(',')
                assert len(orbit_params) == 2
                orbit_elev, orbit_step = tuple([int(p) for p in orbit_params])

                assert -180 <= orbit_elev <= 180
                assert 1 <= orbit_step <= 90
                assert frame_duration >= 100
            except:
                raise NexusProcessingException(
                    reason=f'Invalid orbit parameters: {orbit_params} & {frame_duration}',
                    code=400
                )

            view_azim, view_elev = None, None
        else:
            try:
                view_params = view_params.split(',')
                assert len(view_params) == 2
                view_azim, view_elev = tuple([int(p) for p in view_params])

                assert 0 <= view_azim <= 359
                assert -180 <= view_elev <= 180
            except:
                raise NexusProcessingException(reason=f'Invalid view angle string: {orbit_params}', code=400)

            orbit_elev, orbit_step = None, None

        ch_ds = compute_options.get_argument('canopy_ds', None)
        g_ds = compute_options.get_argument('ground_ds', None)

        percentiles = compute_options.get_boolean_arg('elevPercentiles')

        if percentiles and (ch_ds is None or g_ds is None):
            raise NexusProcessingException(
                code=400,
                reason='\'elevPercentiles\' argument requires \'canopy_ds\' and \'ground_ds\' be set'
            )

        render_rh = compute_options.get_int_arg('renderRH', default=None)

        if render_rh is not None and not 0 <= render_rh <= 100:
            raise NexusProcessingException(
                code=400,
                reason="'renderRH' must be between 0 and 100"
            )

        filter_arg = compute_options.get_argument('filter') if not percentiles else None

        if filter_arg is not None:
            try:
                filter_arg = filter_arg.split(',')
                assert len(filter_arg) == 2
                vmin, vmax = filter_arg

                if vmin != '':
                    vmin = float(vmin)
                else:
                    vmin = None

                if vmax != '':
                    vmax = float(vmax)
                else:
                    vmax = None

                filter_arg = (vmin, vmax)
            except:
                raise NexusProcessingException(
                    reason='Invalid filter arg, must be of format [number],[number]',
                    code=400
                )
        else:
            filter_arg = (None, None)

        render_type = compute_options.get_argument('renderType', 'scatter').lower() if not percentiles else 'scatter'

        if render_type not in ['scatter', 'peak']:
            raise NexusProcessingException(
                reason='renderType must be either scatter or peak',
                code=400
            )

        hide_basemap = compute_options.get_boolean_arg('hideBasemap')

        cmap = mpl.colormaps.get(
            compute_options.get_argument('cmap', 'viridis'),
            mpl.colormaps['viridis']
        )

        return (ds, parameter_s, bounding_poly, min_elevation, max_elevation,
                (orbit_elev, orbit_step, frame_duration, view_azim, view_elev), filter_arg, render_type, hide_basemap,
                ch_ds, g_ds, percentiles, output, render_rh, cmap)