def read_param_file_to_dict(file_name):
        """Loads a text file to a python dictionary using '=' as the delimiter

        :param file_name: the name and path of the text file
        """
        data = loadtxt(file_name, delimiter='=', dtype=scipy.string0)
        data_dict = dict(data)
        for key in data_dict.keys():
            data_dict[key] = data_dict[key].strip()
            data_dict[key.strip()] = data_dict[key]
            del data_dict[key]

        return data_dict

def read_param_file_to_dict ( file_name ) : data = loadtxt ( file_name , delimiter = '=' , dtype = scipy . string0 ) data_dict = dict ( data ) for key in data_dict . keys ( ) : data_dict [ key ] = data_dict [ key ] . strip ( ) data_dict [ key . strip ( ) ] = data_dict [ key ] del data_dict [ key ] return data_dict

Loads a text file to a python dictionary using = as the delimiter


def string_to_float_list(string_var):
        """Pull comma separated string values out of a text file and converts them to float list"""
        try:
            return [float(s) for s in string_var.strip('[').strip(']').split(', ')]
        except:
            return [float(s) for s in string_var.strip('[').strip(']').split(',')]

def
string_to_float_list
(
string_var
)
:
try
:
return
[
float
(
s
)
for
s
in
string_var
.
strip
(
'['
)
.
strip
(
']'
)
.
split
(
', '
)
]
except
:
return
[
float
(
s
)
for
s
in
string_var
.
strip
(
'['
)
.
strip
(
']'
)
.
split
(
','
)
]


def read_pr_report(self, filename):
        """Reads in a PlanarRad generated report

        Saves the single line reported parameters as a python dictionary

        :param filename: The name and path of the PlanarRad generated file
        :returns self.data_dictionary: python dictionary with the key and values from the report
        """
        done = False
        f = open(filename)
        while f:
        #for line in open(filename):
            line = f.readline()
            if not line:
                done = True
                break

            if "# Quad solid angle mean point theta table (rows are horizontal, columns are vertical):" in line.strip():
                # read in the bunch of lines.
                tmp = []
                for i_iter in range(0, len(self.data_dictionary['theta_points_deg']) - 2):
                    tmp.append(f.readline())

                self.data_dictionary['Quad_solid_angle_mean_point_theta'] = tmp

            elif '#' not in line or not line.strip():
                element = line.split(',')
                self.data_dictionary[element[0]] = element[1:]

            if "# Quad solid angle mean point phi table (rows are horizontal, columns are vertical):" in line.strip():
                # read in the bunch of lines.
                tmp = []
                for i_iter in range(0, len(self.data_dictionary['theta_points_deg']) - 2):
                    tmp.append(f.readline())

                self.data_dictionary['Quad_solid_angle_mean_point_phi'] = tmp

            elif '#' not in line or not line.strip():
                element = line.split(',')
                self.data_dictionary[element[0]] = element[1:]

            if "L_w band" in line.strip():

                for i_iter in range(0, int(self.data_dictionary['band_count'][1])):
                    tmp = []
                    for j_iter in range(0, len(self.data_dictionary['theta_points_deg']) - 2):
                        tmp.append(f.readline())

                    self.data_dictionary['L_w_band_' + str(i_iter + 1)] = tmp
                    f.readline()
                    f.readline()  # skip the next 2 lines

            if "L_it band" in line.strip():

                for i_iter in range(0, int(self.data_dictionary['band_count'][1])):
                    tmp = []
                    for j_iter in range(0, len(self.data_dictionary['theta_points_deg']) - 2):
                        tmp.append(f.readline())

                    self.data_dictionary['L_it_band_' + str(i_iter + 1)] = tmp
                    f.readline()
                    f.readline()  # skip the next 2 lines

        return self.data_dictionary


def set_handler(self, signals, handler=signal.SIG_DFL):
        """ Takes a list of signals and sets a handler for them """
        for sig in signals:
            self.log.debug("Creating handler for signal: {0}".format(sig))
            signal.signal(sig, handler)

def
set_handler
(
self
,
signals
,
handler
=
signal
.
SIG_DFL
)
:
for
sig
in
signals
:
self
.
log
.
debug
(
"Creating handler for signal: {0}"
.
format
(
sig
)
)
signal
.
signal
(
sig
,
handler
)


def pseudo_handler(self, signum, frame):
        """ Pseudo handler placeholder while signal is beind processed """
        self.log.warn("Received sigal {0} but system is already busy processing a previous signal, current frame: {1}".format(signum, str(frame)))


def default_handler(self, signum, frame):
        """ Default handler, a generic callback method for signal processing"""
        self.log.debug("Signal handler called with signal: {0}".format(signum))
        # 1. If signal is HUP restart the python process
        # 2. If signal is TERM, INT or QUIT we try to cleanup then exit with -1
        # 3. If signal is STOP or TSTP we pause
        # 4. If signal is CONT or USR1 we continue
        # 5. If signal is INFO we print status
        # 6. If signal is USR2 we we abort and then exit with -1

        if signum in self.restart_signals:
            self.set_handler(self.handled_signals, self.pseudo_handler)
            self._cleanup()
            os.execl('python', 'python', * sys.argv)
        elif signum in self.abort_signals:
            self.abort(signum)
        elif signum in self.pause_signals:
            self.pause(signum)
        elif signum in self.resume_signals:
            self.resume(signum)
        elif signum in self.status_signals:
            self.status(signum)
        elif signum in self.error_signals:
            self.log.error('Signal handler received error signal from an external process, aborting')
            self.abort(signum)
        else:
            self.log.error("Unhandled signal received: {0}".format(signum))
            raise

Default handler a generic callback method for signal processing


def pause(self, signum, seconds=0, callback_function=None):
        """
        Pause execution, execution will resume in X seconds or when the
        appropriate resume signal is received. Execution will jump to the
        callback_function, the default callback function is the handler
        method which will run all tasks registered with the reg_on_resume
        methodi.
        Returns True if timer expired, otherwise returns False
        """
        if callback_function is None:
            callback_function = self.default_handler
        if seconds > 0:
            self.log.info("Signal handler pausing for {0} seconds or until it receives SIGALRM or SIGCONT".format(seconds))
            signal.signal(signal.SIGALRM, callback_function)
            signal.alarm(seconds)
        else:
            self.log.info('Signal handler pausing until it receives SIGALRM or SIGCONT')
        signal.signal(signal.SIGCONT, callback_function)
        signal.pause()
        self.log.info('Signal handler resuming from pause')
        if signum == signal.SIGALRM:
            return True
        else:
            return False

Pause execution execution will resume in X seconds or when the appropriate resume signal is received . Execution will jump to the callback_function the default callback function is the handler method which will run all tasks registered with the reg_on_resume methodi . Returns True if timer expired otherwise returns False


def abort(self, signum):
        """ Run all abort tasks, then all exit tasks, then exit with error
        return status"""
        self.log.info('Signal handler received abort request')
        self._abort(signum)
        self._exit(signum)
        os._exit(1)

def
abort
(
self
,
signum
)
:
self
.
log
.
info
(
'Signal handler received abort request'
)
self
.
_abort
(
signum
)
self
.
_exit
(
signum
)
os
.
_exit
(
1
)

Run all abort tasks then all exit tasks then exit with error return status


def status(self, signum):
        """ Run all status tasks, then run all tasks in the resume queue"""
        self.log.debug('Signal handler got status signal')
        new_status_callbacks = []
        for status_call in self.status_callbacks:
            # If callback is non persistent we remove it
            try:
                self.log.debug("Calling {0}({1},{2})".format(status_call['function'].__name__, status_call['args'], status_call['kwargs']))
            except AttributeError:
                self.log.debug("Calling unbound function/method {0}".format(str(status_call)))

            apply(status_call['function'], status_call['args'], status_call['kwargs'])
            if status_call['persistent']:
                new_status_callbacks.append(status_call)
        self.status_callbacks = new_status_callbacks
        self._resume(signum)

def
status
(
self
,
signum
)
:
self
.
log
.
debug
(
'Signal handler got status signal'
)
new_status_callbacks
=
[
]
for
status_call
in
self
.
status_callbacks
:
try
:
self
.
log
.
debug
(
"Calling {0}({1},{2})"
.
format
(
status_call
[
'function'
]
.
__name__
,
status_call
[
'args'
]
,
status_call
[
'kwargs'
]
)
)
except
AttributeError
:
self
.
log
.
debug
(
"Calling unbound function/method {0}"
.
format
(
str
(
status_call
)
)
)
apply
(
status_call
[
'function'
]
,
status_call
[
'args'
]
,
status_call
[
'kwargs'
]
)
if
status_call
[
'persistent'
]
:
new_status_callbacks
.
append
(
status_call
)
self
.
status_callbacks
=
new_status_callbacks
self
.
_resume
(
signum
)

Run all status tasks then run all tasks in the resume queue


def _unreg_event(self, event_list, event):
        """ Tries to remove a registered event without triggering it """
        try:
            self.log.debug("Removing event {0}({1},{2})".format(event['function'].__name__, event['args'], event['kwargs']))
        except AttributeError:
            self.log.debug("Removing event {0}".format(str(event)))

        try:
            event_list.remove(event)
        except ValueError:
            try:
                self.log.warn("Unable to remove event {0}({1},{2}) , not found in list: {3}".format(event['function'].__name__, event['args'], event['kwargs'], event_list))
            except AttributeError:
                self.log.debug("Unable to remove event {0}".format(str(event)))
            raise KeyError('Unable to unregister the specified event from the signals specified')


def fetch_metric(self, metric, start, end, tags={}, aggregator="sum",
        downsample=None, ms_resolution=True):
        """Fetch time series data from OpenTSDB

        Parameters:
            metric:
                A string representing a valid OpenTSDB metric.

            tags:
                A dict mapping tag names to tag values. Tag names and values are
                always strings.

                { 'user_id': '44' }

            start:
                A datetime.datetime-like object representing the start of the
                range to query over.

            end:
                A datetime.datetime-like object representing the end of the
                range to query over.

            aggregator:
                The function for merging multiple time series together. For
                example, if the "user_id" tag is not specified, this aggregator
                function is used to combine all heart rate time series into one
                time series. (Yes, this isn't very useful.)

                For queries that return only one time series, this parameter is
                not relevant.

                Valid values: "sum", "min", "max", "avg", "dev"

                See: http://opentsdb.net/docs/build/html/user_guide/query/aggregators.html

            downsampling:
                A relative time interval to "downsample". This isn't true
                downsampling; rather, if you specify a downsampling of "5m"
                (five minutes), OpenTSDB will split data into five minute
                intervals, and return one data point in the middle of each
                interval whose value is the average of all data points within
                that interval.

                Valid relative time values are strings of the following format:

                    "<amount><time_unit>"

                Valid time units: "ms", "s", "m", "h", "d", "w", "n", "y"

                Date and time format: http://opentsdb.net/docs/build/html/user_guide/query/dates.html

            ms_resolution:
                Whether or not to output data point timestamps in milliseconds
                or seconds. If this flag is false and there are multiple
                data points within a second, those data points will be down
                sampled using the query's aggregation function.

        Returns:
            A dict mapping timestamps to data points
        """
        query = "{aggregator}:{downsample}{metric}{{{tags}}}".format(
            aggregator=aggregator,
            downsample=downsample + "-avg:" if downsample else "",
            metric=metric,
            tags=','.join("%s=%s" % (k, v) for k, v in tags.items())
        )
        params = {
            'ms': ms_resolution,
            'start': '{0:.3f}'.format(start.timestamp()),
            'end': '{0:.3f}'.format(end.timestamp()),
            'm': query
        }
        response = self.__request("/query", params)

        if response.status_code == 200:
            try:
                return response.json()[0]['dps']
            except IndexError:
                # empty data set
                return {}

        raise QueryError(response.json())


def fetch_sorted_metric(self, *args, **kwargs):
        """Fetch and sort time series data from OpenTSDB

        Takes the same parameters as `fetch_metric`, but returns a list of
        (timestamp, value) tuples sorted by timestamp.
        """
        return sorted(self.fetch_metric(*args, **kwargs).items(),
            key=lambda x: float(x[0]))

def fetch_sorted_metric ( self , * args , ** kwargs ) : return sorted ( self . fetch_metric ( * args , ** kwargs ) . items ( ) , key = lambda x : float ( x [ 0 ] ) )


def pfcollect(iterable, n=None):
    """Collects and returns a list of values from the given iterable.  If
    the n parameter is not specified, collects all values from the
    iterable.

    :param iterable: An iterable yielding values for the list
    :param n: An optional maximum number of items to collect
    :rtype: List of values from the iterable

    Example::

        >>> @pointfree
        ... def fibonaccis():
        ...     a, b = 0, 1
        ...     while True:
        ...         a, b = b, a+b
        ...         yield a

        >>> (pfcollect(n=10) * fibonaccis)()
        [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

    """

    if n:
        return list(itertools.islice(iterable, n))
    else:
        return list(iterable)

def pfcollect ( iterable , n = None ) : if n : return list ( itertools . islice ( iterable , n ) ) else : return list ( iterable )

Collects and returns a list of values from the given iterable . If the n parameter is not specified collects all values from the iterable .


def pfprint(item, end='\n', file=None):
    """Prints an item.

    :param item: The item to print
    :param end: String to append to the end of printed output
    :param file: File to which output is printed
    :rtype: None

    Example::

        >>> from operator import add

        >>> fn = pfreduce(add, initial=0) >> pfprint
        >>> fn([1, 2, 3, 4])
        10

    """

    # Can't just make sys.stdout the file argument's default value, because
    # then we would be capturing the stdout file descriptor, and then
    # doctest -- which works by redefining sys.stdout -- would fail:
    if file is None:
        file = sys.stdout

    print(item, end=end, file=file)

def pfprint ( item , end = '\n' , file = None ) : if file is None : file = sys . stdout print ( item , end = end , file = file )


def pfprint_all(iterable, end='\n', file=None):
    """Prints each item from an iterable.

    :param iterable: An iterable yielding values to print
    :param end: String to append to the end of printed output
    :param file: File to which output is printed
    :rtype: None

    Example::

        >>> @pointfree
        ... def prefix_all(prefix, iterable):
        ...     for item in iterable:
        ...         yield "%s%s" % (prefix, item)

        >>> fn = prefix_all("An item: ") >> pfprint_all

        >>> fn(["foo", "bar", "baz"])
        An item: foo
        An item: bar
        An item: baz

    """

    for item in iterable:
        pfprint(item, end=end, file=file)

def pfprint_all ( iterable , end = '\n' , file = None ) : for item in iterable : pfprint ( item , end = end , file = file )


def __sig_from_func(self, func):
        """Extract function signature, default arguments, keyword-only
        arguments, and whether or not variable positional or keyword
        arguments are allowed.  This also supports calling unbound instance
        methods by passing an object instance as the first argument;
        however, unbound classmethod and staticmethod objects are not
        callable, so we do not attempt to support them here."""

        if isinstance(func, types.MethodType):
            # A bound instance or class method.
            argspec = getfullargspec(func.__func__)
            self.pargl = argspec[0][1:]
        else:
            # A regular function, an unbound instance method, or a
            # bound static method.
            argspec = getfullargspec(func)
            self.pargl = argspec[0][:]

        if argspec[3] is not None:
            def_offset = len(self.pargl) - len(argspec[3])
            self.def_argv = dict((self.pargl[def_offset+i],argspec[3][i]) \
                                     for i in range(len(argspec[3])))
        else:
            self.def_argv = {}

        self.var_pargs = argspec[1] is not None
        self.var_kargs = argspec[2] is not None
        self.kargl     = argspec[4]

        # We need keyword-only arguments' default values too.
        if argspec[5] is not None:
            self.def_argv.update(argspec[5])

def __sig_from_func ( self , func ) : if isinstance ( func , types . MethodType ) : argspec = getfullargspec ( func . __func__ ) self . pargl = argspec [ 0 ] [ 1 : ] else : argspec = getfullargspec ( func ) self . pargl = argspec [ 0 ] [ : ] if argspec [ 3 ] is not None : def_offset = len ( self . pargl ) - len ( argspec [ 3 ] ) self . def_argv = dict ( ( self . pargl [ def_offset + i ] , argspec [ 3 ] [ i ] ) for i in range ( len ( argspec [ 3 ] ) ) ) else : self . def_argv = { } self . var_pargs = argspec [ 1 ] is not None self . var_kargs = argspec [ 2 ] is not None self . kargl = argspec [ 4 ] if argspec [ 5 ] is not None : self . def_argv . update ( argspec [ 5 ] )

Extract function signature default arguments keyword - only arguments and whether or not variable positional or keyword arguments are allowed . This also supports calling unbound instance methods by passing an object instance as the first argument ; however unbound classmethod and staticmethod objects are not callable so we do not attempt to support them here .


def __sig_from_partial(self, inst):
        """Extract function signature from an existing partial instance."""

        self.pargl     = list(inst.pargl)
        self.kargl     = list(inst.kargl)
        self.def_argv  = inst.def_argv.copy()
        self.var_pargs = inst.var_pargs
        self.var_kargs = inst.var_kargs

def __sig_from_partial ( self , inst ) : self . pargl = list ( inst . pargl ) self . kargl = list ( inst . kargl ) self . def_argv = inst . def_argv . copy ( ) self . var_pargs = inst . var_pargs self . var_kargs = inst . var_kargs

Extract function signature from an existing partial instance .


def __new_argv(self, *new_pargs, **new_kargs):
        """Calculate new argv and extra_argv values resulting from adding
        the specified positional and keyword arguments."""

        new_argv = self.argv.copy()
        new_extra_argv = list(self.extra_argv)

        for v in new_pargs:
            arg_name = None
            for name in self.pargl:
                if not name in new_argv:
                    arg_name = name
                    break

            if arg_name:
                new_argv[arg_name] = v
            elif self.var_pargs:
                new_extra_argv.append(v)
            else:
                num_prev_pargs = len([name for name in self.pargl if name in self.argv])
                raise TypeError("%s() takes exactly %d positional arguments (%d given)" \
                                    % (self.__name__,
                                       len(self.pargl),
                                       num_prev_pargs + len(new_pargs)))

        for k,v in new_kargs.items():
            if not (self.var_kargs or (k in self.pargl) or (k in self.kargl)):
                raise TypeError("%s() got an unexpected keyword argument '%s'" \
                                    % (self.__name__, k))
            new_argv[k] = v

        return (new_argv, new_extra_argv)

Calculate new argv and extra_argv values resulting from adding the specified positional and keyword arguments .


def ignore_certain_metainf_files(filename):
    """
    We do not support multiple signatures in XPI signing because the client
    side code makes some pretty reasonable assumptions about a single signature
    on any given JAR.  This function returns True if the file name given is one
    that we dispose of to prevent multiple signatures.
    """
    ignore = ("META-INF/manifest.mf",
              "META-INF/*.sf",
              "META-INF/*.rsa",
              "META-INF/*.dsa",
              "META-INF/ids.json")

    for glob in ignore:
        # Explicitly match against all upper case to prevent the kind of
        # runtime errors that lead to https://bugzil.la/1169574
        if fnmatch.fnmatchcase(filename.upper(), glob.upper()):
            return True
    return False

def ignore_certain_metainf_files ( filename ) : ignore = ( "META-INF/manifest.mf" , "META-INF/*.sf" , "META-INF/*.rsa" , "META-INF/*.dsa" , "META-INF/ids.json" ) for glob in ignore : if fnmatch . fnmatchcase ( filename . upper ( ) , glob . upper ( ) ) : return True return False

We do not support multiple signatures in XPI signing because the client side code makes some pretty reasonable assumptions about a single signature on any given JAR . This function returns True if the file name given is one that we dispose of to prevent multiple signatures .


def file_key(filename):
    '''Sort keys for xpi files

    The filenames in a manifest are ordered so that files not in a
    directory come before files in any directory, ordered
    alphabetically but ignoring case, with a few exceptions
    (install.rdf, chrome.manifest, icon.png and icon64.png come at the
    beginning; licenses come at the end).

    This order does not appear to affect anything in any way, but it
    looks nicer.
    '''
    prio = 4
    if filename == 'install.rdf':
        prio = 1
    elif filename in ["chrome.manifest", "icon.png", "icon64.png"]:
        prio = 2
    elif filename in ["MPL", "GPL", "LGPL", "COPYING",
                      "LICENSE", "license.txt"]:
        prio = 5
    return (prio, os.path.split(filename.lower()))

def file_key ( filename ) : prio = 4 if filename == 'install.rdf' : prio = 1 elif filename in [ "chrome.manifest" , "icon.png" , "icon64.png" ] : prio = 2 elif filename in [ "MPL" , "GPL" , "LGPL" , "COPYING" , "LICENSE" , "license.txt" ] : prio = 5 return ( prio , os . path . split ( filename . lower ( ) ) )


def vlq2int(data):
    """Read one VLQ-encoded integer value from an input data stream."""
    # The VLQ is little-endian.
    byte = ord(data.read(1))
    value = byte & 0x7F
    shift = 1
    while byte & 0x80 != 0:
        byte = ord(data.read(1))
        value = ((byte & 0x7F) << shift * 7) | value
        shift += 1
    return value

def vlq2int ( data ) : byte = ord ( data . read ( 1 ) ) value = byte & 0x7F shift = 1 while byte & 0x80 != 0 : byte = ord ( data . read ( 1 ) ) value = ( ( byte & 0x7F ) << shift * 7 ) | value shift += 1 return value

Read one VLQ - encoded integer value from an input data stream .


def read_table(data, fields):
    """Read a table structure.

    These are used by Blizzard to collect pieces of data together. Each
    value is prefixed by two bytes, first denoting (doubled) index and the
    second denoting some sort of key -- so far it has always been '09'. The
    actual value follows as a Variable-Length Quantity, also known as uintvar.
    The actual value is also doubled.

    In some tables the keys might jump from 0A 09 to 04 09 for example.
    I have no idea why this happens, as the next logical key is 0C. Perhaps
    it's a table in a table? Some sort of headers might exist for these
    tables, I'd imagine at least denoting length. Further research required.
    """
    def read_field(field_name):
        data.read(2)
        table[field_name] = vlq2int(data) / 2
        # Discard unknown fields.
        if field_name == 'unknown':
            del table[field_name]

    table = {}
    for field in fields:
        read_field(field)
    return table

def read_table ( data , fields ) : def read_field ( field_name ) : data . read ( 2 ) table [ field_name ] = vlq2int ( data ) / 2 if field_name == 'unknown' : del table [ field_name ] table = { } for field in fields : read_field ( field ) return table


def _parse_header(self):
        """Parse the user data header portion of the replay."""
        header = OrderedDict()
        user_data_header = self.archive.header['user_data_header']['content']
        if re.search(r'StarCraft II replay', user_data_header):
            user_data_header = StringIO.StringIO(user_data_header)
            user_data_header.seek(30) # Just skip the beginning.
            header.update(read_table(user_data_header, ['release_flag',
                                                        'major_version',
                                                        'minor_version',
                                                        'maintenance_version',
                                                        'build_number',
                                                        'unknown',
                                                        'unknown',
                                                        'duration']))

            # Some post processing is required.
            header['version'] = '%s.%s.%s.%s' % (header['major_version'],
                                                 header['minor_version'],
                                                 header['maintenance_version'],
                                                 header['build_number'])
            if not header['release_flag']:
                header['version'] += ' (dev)'

            # Duration is actually stored as 1/16th of a seconds. Go figure.
            header['duration'] /= 16
        else:
            raise ValueError("The given file is not a StarCraft II replay.")
        return header

Parse the user data header portion of the replay .


def get_duration(self, seconds):
        """Transform duration into a human-readable form."""
        duration = ""
        minutes, seconds = divmod(seconds, 60)
        if minutes >= 60:
            hours, minutes = divmod(minutes, 60)
            duration = "%sh " % hours
        duration += "%sm %ss" % (minutes, seconds)
        return duration

def
get_duration
(
self
,
seconds
)
:
duration
=
""
minutes
,
seconds
=
divmod
(
seconds
,
60
)
if
minutes
>=
60
:
hours
,
minutes
=
divmod
(
minutes
,
60
)
duration
=
"%sh "
%
hours
duration
+=
"%sm %ss"
%
(
minutes
,
seconds
)
return
duration

Transform duration into a human - readable form .


def print_details(self):
        """Print a summary of the game details."""
        print 'Map      ', self.map
        print 'Duration ', self.duration
        print 'Version  ', self.version
        print 'Team  Player       Race       Color'
        print '-----------------------------------'
        for player in self.players:
            print '{team:<5} {name:12} {race:10} {color}'.format(**player)

def
print_details
(
self
)
:
print
'Map      '
,
self
.
map
print
'Duration '
,
self
.
duration
print
'Version  '
,
self
.
version
print
'Team  Player       Race       Color'
print
'-----------------------------------'
for
player
in
self
.
players
:
print
'{team:<5} {name:12} {race:10} {color}'
.
format
(
**
player
)


def data(self):
        """
        This function gets back data that the user typed.
        """
        self.batch_name_value = self.ui.batch_name_value.text()
        self.saa_values = self.ui.saa_values.text()
        self.sza_values = self.ui.sza_values.text()
        self.p_values = self.ui.p_values.text()
        self.x_value = self.ui.x_value.text()
        self.y_value = self.ui.y_value.text()
        self.g_value = self.ui.g_value.text()
        self.s_value = self.ui.s_value.text()
        self.z_value = self.ui.z_value.text()
        self.wavelength_values = self.ui.wavelength_values.text()
        self.verbose_value = self.ui.verbose_value.text()
        self.phytoplankton_path = self.ui.phyto_path.text()
        self.bottom_path = self.ui.bottom_path.text()
        self.executive_path = self.ui.exec_path.text()
        self.nb_cpu = self.ui.nb_cpu.currentText()
        self.report_parameter_value = str(self.ui.report_parameter_value.text())

def data ( self ) : self . batch_name_value = self . ui . batch_name_value . text ( ) self . saa_values = self . ui . saa_values . text ( ) self . sza_values = self . ui . sza_values . text ( ) self . p_values = self . ui . p_values . text ( ) self . x_value = self . ui . x_value . text ( ) self . y_value = self . ui . y_value . text ( ) self . g_value = self . ui . g_value . text ( ) self . s_value = self . ui . s_value . text ( ) self . z_value = self . ui . z_value . text ( ) self . wavelength_values = self . ui . wavelength_values . text ( ) self . verbose_value = self . ui . verbose_value . text ( ) self . phytoplankton_path = self . ui . phyto_path . text ( ) self . bottom_path = self . ui . bottom_path . text ( ) self . executive_path = self . ui . exec_path . text ( ) self . nb_cpu = self . ui . nb_cpu . currentText ( ) self . report_parameter_value = str ( self . ui . report_parameter_value . text ( ) )

This function gets back data that the user typed .


def search_file_result(self):
        """
        This function once the file found, display data's file and the graphic associated.
        """
        if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:
            self.result_file = self.file_dialog.getOpenFileName(caption=str("Open Report File"), directory="./outputs")
            if not self.result_file == '':
                self.ui.show_all_curves.setDisabled(False)
                self.ui.show_grid.setDisabled(False)
                self.data_processing()
                self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)
                self.authorized_display = True

def
search_file_result
(
self
)
:
if
self
.
ui
.
tabWidget
.
currentIndex
(
)
==
TabWidget
.
NORMAL_MODE
:
self
.
result_file
=
self
.
file_dialog
.
getOpenFileName
(
caption
=
str
(
"Open Report File"
)
,
directory
=
"./outputs"
)
if
not
self
.
result_file
==
''
:
self
.
ui
.
show_all_curves
.
setDisabled
(
False
)
self
.
ui
.
show_grid
.
setDisabled
(
False
)
self
.
data_processing
(
)
self
.
display_the_graphic
(
self
.
num_line
,
self
.
wavelength
,
self
.
data_wanted
,
self
.
information
)
self
.
authorized_display
=
True

This function once the file found display data s file and the graphic associated .


def write_to_file(self):
        """
        This function calls "gui_batch.py" with inputs values to write the batch file.
        """
        bt = BatchFile(self.batch_name_value, self.p_values, self.x_value, self.y_value, self.g_value, self.s_value,
                       self.z_value, self.wavelength_values, self.verbose_value, self.phytoplankton_path,
                       self.bottom_path, self.nb_cpu, self.executive_path, self.saa_values,
                       self.sza_values, self.report_parameter_value)
        # bt.write_batch_to_file(str(self.batch_name_value + "_batch.txt"))
        bt.write_batch_to_file(str(self.batch_name_value + "_batch.txt"))

def write_to_file ( self ) : bt = BatchFile ( self . batch_name_value , self . p_values , self . x_value , self . y_value , self . g_value , self . s_value , self . z_value , self . wavelength_values , self . verbose_value , self . phytoplankton_path , self . bottom_path , self . nb_cpu , self . executive_path , self . saa_values , self . sza_values , self . report_parameter_value ) bt . write_batch_to_file ( str ( self . batch_name_value + "_batch.txt" ) )

This function calls gui_batch . py with inputs values to write the batch file .


def data_processing(self):
        """
        This function separates data, from the file to display curves, and will put them in the good arrays.
        """
        the_file_name = str(self.result_file)
        the_file = open(the_file_name, 'r')

        lines = the_file.readlines()

        # We put all lines in an array and we put each cell of the line in a column.
        lines_array = []
        for line in lines:
            line = line.split(',')  # Each time there is a tabulation, there is a new cell
            lines_array.append(line)

        labels_line = lines_array[0]
        cell_labels_line = 0  # Iterator on each cell of the line labels_line.
        flag = True  # Become FALSE when we find the word which separate data from wavelength values.

        try:
            while flag:  # While it is TRUE, so if the word doesn't match, it's an infinite loop,
                if "wave length (nm)" in labels_line[cell_labels_line]:
                    index = labels_line.index(labels_line[cell_labels_line])  # Find the index of the string searched.
                    flag = False
                else:
                    cell_labels_line += 1
        except IndexError:  # In case of an infinite loop.
            raise sys.exit("Warning : There is no value named 'wavelength' in the file used to plot curves. "
                           "So, I can't separate data to plot curves and data about tests linking with these curves.")

        self.information = []  # This array will contain the data displayed under the curves.
        data_wavelength = []  # This array will contain the data to plot curves.
        self.num_line = 0  # Iterator on each line of lines_array,
        # The array containing data about information and wavelength.
        for line in lines_array:
            cell_line = 0  # Iterator on each cell of the line.
            self.information.append([])
            data_wavelength.append([])
            while cell_line < len(line):
                if cell_line < index:
                    self.information[self.num_line].append(line[cell_line])
                elif cell_line > index:
                    data_wavelength[self.num_line].append(line[cell_line])
                cell_line += 1
            self.num_line += 1

        # We transform wavelengths from strings to floats.
        line_wavelength = 0  # Iterator on each line of data_wavelength
        for row_data_wavelength in data_wavelength:
            row_data_wavelength = [float(item.strip('\n').strip('\"')) for item in row_data_wavelength]
            data_wavelength[line_wavelength] = row_data_wavelength
            line_wavelength += 1

        self.wavelength = data_wavelength[0]  # The first line contains wavelength
        self.data_wanted = data_wavelength[1:]  # The others contain data useful to plot curves.

        the_file.close()

This function separates data from the file to display curves and will put them in the good arrays .


def display_the_graphic_connection(self):
        """
        The following permits to attribute the function "display_the_graphic" to the slider.
        Because, to make a connection, we can not have parameters for the function, but "display_the_graphic" has some.
        """
        self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)

def display_the_graphic_connection ( self ) : self . display_the_graphic ( self . num_line , self . wavelength , self . data_wanted , self . information )

The following permits to attribute the function display_the_graphic to the slider . Because to make a connection we can not have parameters for the function but display_the_graphic has some .


def print_graphic_information(self, num_curve, information):
        """
        This function displays information about curves.
        Inputs ; num_curve ; The index of the curve's line that we have to display.
                 information ; The array which contains the information, of all curves to display.
        """
        """In this function, the best would to create labels each time we need to create one,
        following the number of labels in label_information.
        #self.essai = QtGui.QLabel(self.ui.tab)
        #self.essai.setGeometry(PyQt4.QtCore.QRect(870,650,111,16))
        #self.essai.setText("ESSAI")
        """

        label_information = information[0]
        data_information = information[1:]

        count_nb_label = 0  # Iterator on all labels of label_information
        nb_label = len(label_information)
        while count_nb_label <= nb_label:
            self.ui.column1_label.setText(label_information[0].strip('\"'))
            self.ui.column2_label.setText(label_information[1].strip('\"'))
            self.ui.column3_label.setText(label_information[2].strip('\"'))
            self.ui.column4_label.setText(label_information[3].strip('\"'))
            self.ui.column5_label.setText(label_information[4].strip('\"'))
            self.ui.column6_label.setText(label_information[5].strip('\"'))
            self.ui.column7_label.setText(label_information[6].strip('\"'))
            self.ui.column8_label.setText(label_information[7].strip('\"'))
            count_nb_label += 1

        line_of_data = 0  # Iterator on each line of data_information.
        while line_of_data < len(data_information):
            if line_of_data == num_curve:
                self.ui.column1_result.setText(data_information[line_of_data][0])
                self.ui.column2_result.setText(data_information[line_of_data][1])
                self.ui.column3_result.setText(data_information[line_of_data][2])
                self.ui.column4_result.setText(data_information[line_of_data][3])
                self.ui.column5_result.setText(data_information[line_of_data][4])
                self.ui.column6_result.setText(data_information[line_of_data][5])
                self.ui.column7_result.setText(data_information[line_of_data][6])
                self.ui.column8_result.setText(data_information[line_of_data][7])
            line_of_data += 1

def print_graphic_information ( self , num_curve , information ) : label_information = information [ 0 ] data_information = information [ 1 : ] count_nb_label = 0 nb_label = len ( label_information ) while count_nb_label <= nb_label : self . ui . column1_label . setText ( label_information [ 0 ] . strip ( '\"' ) ) self . ui . column2_label . setText ( label_information [ 1 ] . strip ( '\"' ) ) self . ui . column3_label . setText ( label_information [ 2 ] . strip ( '\"' ) ) self . ui . column4_label . setText ( label_information [ 3 ] . strip ( '\"' ) ) self . ui . column5_label . setText ( label_information [ 4 ] . strip ( '\"' ) ) self . ui . column6_label . setText ( label_information [ 5 ] . strip ( '\"' ) ) self . ui . column7_label . setText ( label_information [ 6 ] . strip ( '\"' ) ) self . ui . column8_label . setText ( label_information [ 7 ] . strip ( '\"' ) ) count_nb_label += 1 line_of_data = 0 while line_of_data < len ( data_information ) : if line_of_data == num_curve : self . ui . column1_result . setText ( data_information [ line_of_data ] [ 0 ] ) self . ui . column2_result . setText ( data_information [ line_of_data ] [ 1 ] ) self . ui . column3_result . setText ( data_information [ line_of_data ] [ 2 ] ) self . ui . column4_result . setText ( data_information [ line_of_data ] [ 3 ] ) self . ui . column5_result . setText ( data_information [ line_of_data ] [ 4 ] ) self . ui . column6_result . setText ( data_information [ line_of_data ] [ 5 ] ) self . ui . column7_result . setText ( data_information [ line_of_data ] [ 6 ] ) self . ui . column8_result . setText ( data_information [ line_of_data ] [ 7 ] ) line_of_data += 1

This function displays information about curves . Inputs ; num_curve ; The index of the curve s line that we have to display . information ; The array which contains the information of all curves to display .


def display_error_message(self):
        """
        This function displays an error message when a wrong value is typed.
        """
        self.ui.error_label.setScaledContents(True)  # Warning image shown.
        self.ui.error_text_label.show()  # Warning message shown.
        self.ui.error_text_label.setStyleSheet('color: red')

def
display_error_message
(
self
)
:
self
.
ui
.
error_label
.
setScaledContents
(
True
)
self
.
ui
.
error_text_label
.
show
(
)
self
.
ui
.
error_text_label
.
setStyleSheet
(
'color: red'
)

This function displays an error message when a wrong value is typed .


def hide_error_message(self):
        """
        This function hides the error message when all values are correct.
        """
        self.ui.error_label.setScaledContents(False)  # Warning image hiden.
        self.ui.error_text_label.hide()

def hide_error_message ( self ) : self . ui . error_label . setScaledContents ( False ) self . ui . error_text_label . hide ( )

This function hides the error message when all values are correct .


def run(self):
        """
        This function executes planarRad using the batch file.
        """

        """
        Error when planarRad start : /bin/sh: 1: ../planarrad.py: not found
        """
        print('Executing planarrad')
        # If we are not in the reverse_mode :
        if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:
            self.data()
            self.check_values()

            if self.without_error == False:
                self.display_error_message()
            elif self.without_error == True:
                self.is_running = True
                self.hide_error_message()
                self.write_to_file()
                os.chdir('./')
                self.progress_bar()
                this_dir = os.path.dirname(os.path.realpath(__file__)).rstrip('gui/')
                batch_file = os.path.join(this_dir, "inputs/batch_files/" + str(self.batch_name_value) + "_batch.txt")
                print(batch_file)
                self.p = subprocess.Popen(
                    ["./planarrad.py -i " + batch_file],
                    shell=True)
                if self.ui.progressBar.value() == 100:
                    self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)

def
run
(
self
)
:
print
(
'Executing planarrad'
)
if
self
.
ui
.
tabWidget
.
currentIndex
(
)
==
TabWidget
.
NORMAL_MODE
:
self
.
data
(
)
self
.
check_values
(
)
if
self
.
without_error
==
False
:
self
.
display_error_message
(
)
elif
self
.
without_error
==
True
:
self
.
is_running
=
True
self
.
hide_error_message
(
)
self
.
write_to_file
(
)
os
.
chdir
(
'./'
)
self
.
progress_bar
(
)
this_dir
=
os
.
path
.
dirname
(
os
.
path
.
realpath
(
__file__
)
)
.
rstrip
(
'gui/'
)
batch_file
=
os
.
path
.
join
(
this_dir
,
"inputs/batch_files/"
+
str
(
self
.
batch_name_value
)
+
"_batch.txt"
)
print
(
batch_file
)
self
.
p
=
subprocess
.
Popen
(
[
"./planarrad.py -i "
+
batch_file
]
,
shell
=
True
)
if
self
.
ui
.
progressBar
.
value
(
)
==
100
:
self
.
display_the_graphic
(
self
.
num_line
,
self
.
wavelength
,
self
.
data_wanted
,
self
.
information
)

This function executes planarRad using the batch file .


def cancel_planarrad(self):
        """
        This function cancels PlanarRad.
        """

        """
        This function needs to be tested. We don't know if she works.
        """

        if (self.is_running == True) & (self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE):
            cancel = QtGui.QMessageBox.question(self.ui.cancel, 'Cancel PlanarRad', "Are you sure to cancel ?",
                                                QtGui.QMessageBox.Yes,
                                                QtGui.QMessageBox.No)

            if cancel == QtGui.QMessageBox.Yes:
                self.is_running = False
                os.kill(self.p.pid, signal.SIGTERM)

                print("Necessary to check if cancel_planarrad works well !")
                self.ui.progressBar.reset()
            else:
                pass


def quit(self):
        """
        This function quits PlanarRad, checking if PlanarRad is running before.
        """

        """
        Nothing programmed for displaying a message box when the user clicks on the window cross in order to quit.
        """

        if self.is_running == True:
            warning_planarrad_running = QtGui.QMessageBox.warning(self.ui.quit, 'Warning !',
                                                                  "PlanarRad is running. Stop it before quit !",
                                                                  QtGui.QMessageBox.Ok)

        else:
            quit = QtGui.QMessageBox.question(self.ui.quit, 'Quit PlanarRad', "Are you sure to quit ?",
                                              QtGui.QMessageBox.Yes,
                                              QtGui.QMessageBox.No)
            if quit == QtGui.QMessageBox.Yes:
                QtGui.qApp.quit()

This function quits PlanarRad checking if PlanarRad is running before .


def save_figure(self):
        """
        This function programs the button to save the figure displayed
        and save it in a png file in the current repository.
        """

        """
        Increment the name of the figure in order to not erase the previous figure if the user use always this method.
        The png file is put in the "Artists_saved" file localized in the "planarradpy" folder.
        """

        default_name = 'Default_figure.png'
        self.ui.graphic_widget.canvas.print_figure(default_name)

        src = './' + default_name
        dst = './Artists_saved'
        os.system("mv" + " " + src + " " + dst)

def
save_figure
(
self
)
:
default_name
=
'Default_figure.png'
self
.
ui
.
graphic_widget
.
canvas
.
print_figure
(
default_name
)
src
=
'./'
+
default_name
dst
=
'./Artists_saved'
os
.
system
(
"mv"
+
" "
+
src
+
" "
+
dst
)

This function programs the button to save the figure displayed and save it in a png file in the current repository .


def open_log_file(self):
        """
        The following opens the log file of PlanarRad.
        """
        """
        TO DO.
        """
        # webbrowser.open('https://marrabld.github.io/planarradpy/')
        f = open(os.path.expanduser('~/.planarradpy/log/libplanarradpy.log'))
        # self.uiLog.textEdit.setText(str(f.readlines()))
        self.uiLog.textEdit.setPlainText(str(f.read()))
        self.log_window.show()

def open_log_file ( self ) : f = open ( os . path . expanduser ( '~/.planarradpy/log/libplanarradpy.log' ) ) self . uiLog . textEdit . setPlainText ( str ( f . read ( ) ) ) self . log_window . show ( )

The following opens the log file of PlanarRad .


def open_documentation(self):
        """
        The following opens the documentation file.
        """
        """
        TO DO.
        """
        # webbrowser.open('https://marrabld.github.io/planarradpy/')

        window = Window()
        html = QtCore.QUrl.fromLocalFile(os.path.join(os.getcwd(), './docs/_build/html/index.html')) #open('./docs/_build/html/index.html').read()
        #window.show()
        window.view.load(html)
        window.show()
        window.exec_()

def open_documentation ( self ) : window = Window ( ) html = QtCore . QUrl . fromLocalFile ( os . path . join ( os . getcwd ( ) , './docs/_build/html/index.html' ) ) window . view . load ( html ) window . show ( ) window . exec_ ( )

The following opens the documentation file .


def prerequisite_actions(self):
        """
        This function does all required actions at the beginning when we run the GUI.
        """
        self.hide_error_message()

        self.ui.show_all_curves.setDisabled(True)
        self.ui.sens.setDisabled(True)
        self.ui.show_grid.setDisabled(True)

        pathname = os.path.dirname(sys.argv[0])
        path = os.path.abspath(pathname)
        # self.phytoplankton_path = self.ui.phyto_path.setText(path.replace('gui', 'inputs/iop_files'))
        # self.bottom_path = self.ui.bottom_path.setText(path.replace('gui', 'inputs/bottom_files'))
        # self.executive_path = self.ui.exec_path.setText("Decide where will be 'jude2_install/bin'")
        self.verbose_value = self.ui.verbose_value.setText("6")
        self.report_parameter_value = self.ui.report_parameter_value.setText("Rrs")

        self.ui.progressBar.reset()

def prerequisite_actions ( self ) : self . hide_error_message ( ) self . ui . show_all_curves . setDisabled ( True ) self . ui . sens . setDisabled ( True ) self . ui . show_grid . setDisabled ( True ) pathname = os . path . dirname ( sys . argv [ 0 ] ) path = os . path . abspath ( pathname ) self . verbose_value = self . ui . verbose_value . setText ( "6" ) self . report_parameter_value = self . ui . report_parameter_value . setText ( "Rrs" ) self . ui . progressBar . reset ( )

This function does all required actions at the beginning when we run the GUI .


def click(self, event):
        """
        This function intercepts the mouse's right click and its position.
        """
        if event.button == 3:
            if self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE:
                self.pos = QtGui.QCursor().pos()
                self.graphic_context_menu(self.pos)

def click ( self , event ) : if event . button == 3 : if self . ui . tabWidget . currentIndex ( ) == TabWidget . NORMAL_MODE : self . pos = QtGui . QCursor ( ) . pos ( ) self . graphic_context_menu ( self . pos )

This function intercepts the mouse s right click and its position .


def mouse_move(self, event):
        """
        The following gets back coordinates of the mouse on the canvas.
        """
        if (self.ui.tabWidget.currentIndex() == TabWidget.NORMAL_MODE):
            self.posX = event.xdata
            self.posY = event.ydata

            self.graphic_target(self.posX, self.posY)

def mouse_move ( self , event ) : if ( self . ui . tabWidget . currentIndex ( ) == TabWidget . NORMAL_MODE ) : self . posX = event . xdata self . posY = event . ydata self . graphic_target ( self . posX , self . posY )

The following gets back coordinates of the mouse on the canvas .


def graphic_target(self, x, y):
        """
        The following update labels about mouse coordinates.
        """

        if self.authorized_display == True:
            try:
                self.display_the_graphic(self.num_line, self.wavelength, self.data_wanted, self.information)
                self.ui.mouse_coordinate.setText("(%0.3f, %0.3f)" % (x, y))
            except:
                pass

def
graphic_target
(
self
,
x
,
y
)
:
if
self
.
authorized_display
==
True
:
try
:
self
.
display_the_graphic
(
self
.
num_line
,
self
.
wavelength
,
self
.
data_wanted
,
self
.
information
)
self
.
ui
.
mouse_coordinate
.
setText
(
"(%0.3f, %0.3f)"
%
(
x
,
y
)
)
except
:
pass

The following update labels about mouse coordinates .


def genesis_signing_lockset(genesis, privkey):
    """
    in order to avoid a complicated bootstrapping, we define
    the genesis_signing_lockset as a lockset with one vote by any validator.
    """
    v = VoteBlock(0, 0, genesis.hash)
    v.sign(privkey)
    ls = LockSet(num_eligible_votes=1)
    ls.add(v)
    assert ls.has_quorum
    return ls

def genesis_signing_lockset ( genesis , privkey ) : v = VoteBlock ( 0 , 0 , genesis . hash ) v . sign ( privkey ) ls = LockSet ( num_eligible_votes = 1 ) ls . add ( v ) assert ls . has_quorum return ls

in order to avoid a complicated bootstrapping we define the genesis_signing_lockset as a lockset with one vote by any validator .


def sign(self, privkey):
        """Sign this with a private key"""
        if self.v:
            raise InvalidSignature("already signed")

        if privkey in (0, '', '\x00' * 32):
            raise InvalidSignature("Zero privkey cannot sign")
        rawhash = sha3(rlp.encode(self, self.__class__.exclude(['v', 'r', 's'])))

        if len(privkey) == 64:
            privkey = encode_privkey(privkey, 'bin')

        pk = PrivateKey(privkey, raw=True)
        signature = pk.ecdsa_recoverable_serialize(pk.ecdsa_sign_recoverable(rawhash, raw=True))

        signature = signature[0] + chr(signature[1])

        self.v = ord(signature[64]) + 27
        self.r = big_endian_to_int(signature[0:32])
        self.s = big_endian_to_int(signature[32:64])

        self._sender = None
        return self

def
sign
(
self
,
privkey
)
:
if
self
.
v
:
raise
InvalidSignature
(
"already signed"
)
if
privkey
in
(
0
,
''
,
'\x00'
*
32
)
:
raise
InvalidSignature
(
"Zero privkey cannot sign"
)
rawhash
=
sha3
(
rlp
.
encode
(
self
,
self
.
__class__
.
exclude
(
[
'v'
,
'r'
,
's'
]
)
)
)
if
len
(
privkey
)
==
64
:
privkey
=
encode_privkey
(
privkey
,
'bin'
)
pk
=
PrivateKey
(
privkey
,
raw
=
True
)
signature
=
pk
.
ecdsa_recoverable_serialize
(
pk
.
ecdsa_sign_recoverable
(
rawhash
,
raw
=
True
)
)
signature
=
signature
[
0
]
+
chr
(
signature
[
1
]
)
self
.
v
=
ord
(
signature
[
64
]
)
+
27
self
.
r
=
big_endian_to_int
(
signature
[
0
:
32
]
)
self
.
s
=
big_endian_to_int
(
signature
[
32
:
64
]
)
self
.
_sender
=
return
self


def hash(self):
        "signatures are non deterministic"
        if self.sender is None:
            raise MissingSignatureError()

        class HashSerializable(rlp.Serializable):
            fields = [(field, sedes) for field, sedes in self.fields
                      if field not in ('v', 'r', 's')] + [('_sender', binary)]
            _sedes = None
        return sha3(rlp.encode(self, HashSerializable))

def
hash
(
self
)
:
"signatures are non deterministic"
if
self
.
sender
is
:
raise
MissingSignatureError
(
)
class
HashSerializable
(
rlp
.
Serializable
)
:
fields
=
[
(
field
,
sedes
)
for
field
,
sedes
in
self
.
fields
if
field
not
in
(
'v'
,
'r'
,
's'
)
]
+
[
(
'_sender'
,
binary
)
]
_sedes
=
return
sha3
(
rlp
.
encode
(
self
,
HashSerializable
)
)


def check(self):
        "either invalid or one of quorum, noquorum, quorumpossible"
        if not self.is_valid:
            return True
        test = (self.has_quorum, self.has_quorum_possible, self.has_noquorum)
        assert 1 == len([x for x in test if x is not None])
        return True

either invalid or one of quorum noquorum quorumpossible


def issue_funds(ctx, amount='uint256', rtgs_hash='bytes32', returns=STATUS):
        "In the IOU fungible the supply is set by Issuer, who issue funds."
        # allocate new issue as result of a new cash entry
        ctx.accounts[ctx.msg_sender] += amount
        ctx.issued_amounts[ctx.msg_sender] += amount
        # Store hash(rtgs)
        ctx.Issuance(ctx.msg_sender, rtgs_hash, amount)
        return OK

In the IOU fungible the supply is set by Issuer who issue funds .


def last_lock(self):
        "highest lock on height"
        rs = list(self.rounds)
        assert len(rs) < 2 or rs[0] > rs[1]  # FIXME REMOVE
        for r in self.rounds:  # is sorted highest to lowest
            if self.rounds[r].lock is not None:
                return self.rounds[r].lock

def
last_lock
(
self
)
:
"highest lock on height"
rs
=
list
(
self
.
rounds
)
assert
len
(
rs
)
<
2
or
rs
[
0
]
>
rs
[
1
]
for
r
in
self
.
rounds
:
if
self
.
rounds
[
r
]
.
lock
is
not
:
return
self
.
rounds
[
r
]
.
lock


def last_voted_blockproposal(self):
        "the last block proposal node voted on"
        for r in self.rounds:
            if isinstance(self.rounds[r].proposal, BlockProposal):
                assert isinstance(self.rounds[r].lock, Vote)
                if self.rounds[r].proposal.blockhash == self.rounds[r].lock.blockhash:
                    return self.rounds[r].proposal

def
last_voted_blockproposal
(
self
)
:
"the last block proposal node voted on"
for
r
in
self
.
rounds
:
if
isinstance
(
self
.
rounds
[
r
]
.
proposal
,
BlockProposal
)
:
assert
isinstance
(
self
.
rounds
[
r
]
.
lock
,
Vote
)
if
self
.
rounds
[
r
]
.
proposal
.
blockhash
==
self
.
rounds
[
r
]
.
lock
.
blockhash
:
return
self
.
rounds
[
r
]
.
proposal


def last_valid_lockset(self):
        "highest valid lockset on height"
        for r in self.rounds:
            ls = self.rounds[r].lockset
            if ls.is_valid:
                return ls
        return None

def
last_valid_lockset
(
self
)
:
"highest valid lockset on height"
for
r
in
self
.
rounds
:
ls
=
self
.
rounds
[
r
]
.
lockset
if
ls
.
is_valid
:
return
ls
return


def get_timeout(self):
        "setup a timeout for waiting for a proposal"
        if self.timeout_time is not None or self.proposal:
            return
        now = self.cm.chainservice.now
        round_timeout = ConsensusManager.round_timeout
        round_timeout_factor = ConsensusManager.round_timeout_factor
        delay = round_timeout * round_timeout_factor ** self.round
        self.timeout_time = now + delay
        return delay


def on_proposal(self, proposal, proto):
        "called to inform about synced peers"
        assert isinstance(proto, HDCProtocol)
        assert isinstance(proposal, Proposal)
        if proposal.height >= self.cm.height:
            assert proposal.lockset.is_valid
            self.last_active_protocol = proto

def
on_proposal
(
self
,
proposal
,
proto
)
:
"called to inform about synced peers"
assert
isinstance
(
proto
,
HDCProtocol
)
assert
isinstance
(
proposal
,
Proposal
)
if
proposal
.
height
>=
self
.
cm
.
height
:
assert
proposal
.
lockset
.
is_valid
self
.
last_active_protocol
=
proto


def mk_privkeys(num):
    "make privkeys that support coloring, see utils.cstr"
    privkeys = []
    assert num <= num_colors
    for i in range(num):
        j = 0
        while True:
            k = sha3(str(j))
            a = privtoaddr(k)
            an = big_endian_to_int(a)
            if an % num_colors == i:
                break
            j += 1
        privkeys.append(k)
    return privkeys

make privkeys that support coloring see utils . cstr


def delay(self, sender, receiver, packet, add_delay=0):
        """
        bandwidths are inaccurate, as we don't account for parallel transfers here
        """
        bw = min(sender.ul_bandwidth, receiver.dl_bandwidth)
        delay = sender.base_latency + receiver.base_latency
        delay += len(packet) / bw
        delay += add_delay
        return delay

def delay ( self , sender , receiver , packet , add_delay = 0 ) : bw = min ( sender . ul_bandwidth , receiver . dl_bandwidth ) delay = sender . base_latency + receiver . base_latency delay += len ( packet ) / bw delay += add_delay return delay

bandwidths are inaccurate as we don t account for parallel transfers here


def deliver(self, sender, receiver, packet):
        "deliver on edge of timeout_window"
        to = ConsensusManager.round_timeout
        assert to > 0
        print "in slow transport deliver"
        super(SlowTransport, self).deliver(sender, receiver, packet, add_delay=to)

def
deliver
(
self
,
sender
,
receiver
,
packet
)
:
"deliver on edge of timeout_window"
to
=
ConsensusManager
.
round_timeout
assert
to
>
0
print
"in slow transport deliver"
super
(
SlowTransport
,
self
)
.
deliver
(
sender
,
receiver
,
packet
,
add_delay
=
to
)


def chain_nac_proxy(chain, sender, contract_address, value=0):
    "create an object which acts as a proxy for the contract on the chain"
    klass = registry[contract_address].im_self
    assert issubclass(klass, NativeABIContract)

    def mk_method(method):
        def m(s, *args):
            data = abi_encode_args(method, args)
            block = chain.head_candidate
            output = test_call(block, sender, contract_address, data)
            if output is not None:
                return abi_decode_return_vals(method, output)
        return m

    class cproxy(object):
        pass
    for m in klass._abi_methods():
        setattr(cproxy, m.__func__.func_name, mk_method(m))

    return cproxy()


def address_to_native_contract_class(self, address):
        "returns class._on_msg_unsafe, use x.im_self to get class"
        assert isinstance(address, bytes) and len(address) == 20
        assert self.is_instance_address(address)
        nca = self.native_contract_address_prefix + address[-4:]
        return self.native_contracts[nca]

returns class . _on_msg_unsafe use x . im_self to get class


def register(self, contract):
        "registers NativeContract classes"
        assert issubclass(contract, NativeContractBase)
        assert len(contract.address) == 20
        assert contract.address.startswith(self.native_contract_address_prefix)
        if self.native_contracts.get(contract.address) == contract._on_msg:
            log.debug("already registered", contract=contract, address=contract.address)
            return
        assert contract.address not in self.native_contracts, 'address already taken'
        self.native_contracts[contract.address] = contract._on_msg
        log.debug("registered native contract", contract=contract, address=contract.address)

def
register
(
self
,
contract
)
:
"registers NativeContract classes"
assert
issubclass
(
contract
,
NativeContractBase
)
assert
len
(
contract
.
address
)
==
20
assert
contract
.
address
.
startswith
(
self
.
native_contract_address_prefix
)
if
self
.
native_contracts
.
get
(
contract
.
address
)
==
contract
.
_on_msg
:
log
.
debug
(
"already registered"
,
contract
=
contract
,
address
=
contract
.
address
)
return
assert
contract
.
address
not
in
self
.
native_contracts
,
'address already taken'
self
.
native_contracts
[
contract
.
address
]
=
contract
.
_on_msg
log
.
debug
(
"registered native contract"
,
contract
=
contract
,
address
=
contract
.
address
)


def update(self, data):
        "returns True if unknown"
        if data not in self.filter:
            self.filter.append(data)
            if len(self.filter) > self.max_items:
                self.filter.pop(0)
            return True
        else:
            self.filter.append(self.filter.pop(0))
            return False

def
update
(
self
,
data
)
:
"returns True if unknown"
if
data
not
in
self
.
filter
:
self
.
filter
.
append
(
data
)
if
len
(
self
.
filter
)
>
self
.
max_items
:
self
.
filter
.
pop
(
0
)
return
True
else
:
self
.
filter
.
append
(
self
.
filter
.
pop
(
0
)
)
return
False


def on_receive_transactions(self, proto, transactions):
        "receives rlp.decoded serialized"
        log.debug('----------------------------------')
        log.debug('remote_transactions_received', count=len(transactions), remote_id=proto)

        def _add_txs():
            for tx in transactions:
                self.add_transaction(tx, origin=proto)
        gevent.spawn(_add_txs)

def
on_receive_transactions
(
self
,
proto
,
transactions
)
:
"receives rlp.decoded serialized"
log
.
debug
(
'----------------------------------'
)
log
.
debug
(
'remote_transactions_received'
,
count
=
len
(
transactions
)
,
remote_id
=
proto
)
def
_add_txs
(
)
:
for
tx
in
transactions
:
self
.
add_transaction
(
tx
,
origin
=
proto
)
gevent
.
spawn
(
_add_txs
)


Decondition an image from the VGG16 model.

Decondition an image from the VGG16 model .


Condition an image for use with the VGG16 model.

Condition an image for use with the VGG16 model .


def get_f_layer(self, layer_name):
        '''Create a function for the response of a layer.'''
        inputs = [self.net_input]
        if self.learning_phase is not None:
            inputs.append(K.learning_phase())
        return K.function(inputs, [self.get_layer_output(layer_name)])

def get_f_layer ( self , layer_name ) : inputs = [ self . net_input ] if self . learning_phase is not None : inputs . append ( K . learning_phase ( ) ) return K . function ( inputs , [ self . get_layer_output ( layer_name ) ] )

Create a function for the response of a layer .


def get_layer_output(self, name):
        '''Get symbolic output of a layer.'''
        if not name in self._f_layer_outputs:
            layer = self.net.get_layer(name)
            self._f_layer_outputs[name] = layer.output
        return self._f_layer_outputs[name]

def get_layer_output ( self , name ) : if not name in self . _f_layer_outputs : layer = self . net . get_layer ( name ) self . _f_layer_outputs [ name ] = layer . output return self . _f_layer_outputs [ name ]


def get_features(self, x, layers):
        '''Evaluate layer outputs for `x`'''
        if not layers:
            return None
        inputs = [self.net.input]
        if self.learning_phase is not None:
            inputs.append(self.learning_phase)
        f = K.function(inputs, [self.get_layer_output(layer_name) for layer_name in layers])
        feature_outputs = f([x])
        features = dict(zip(layers, feature_outputs))
        return features

def get_features ( self , x , layers ) : if not layers : return None inputs = [ self . net . input ] if self . learning_phase is not None : inputs . append ( self . learning_phase ) f = K . function ( inputs , [ self . get_layer_output ( layer_name ) for layer_name in layers ] ) feature_outputs = f ( [ x ] ) features = dict ( zip ( layers , feature_outputs ) ) return features


def create_key_file(path):
    """
    Creates a new encryption key in the path provided and sets the file
    permissions.  Setting the file permissions currently does not work
    on Windows platforms because of the differences in how file
    permissions are read and modified.
    """
    iv = "{}{}".format(os.urandom(32), time.time())
    new_key = generate_key(ensure_bytes(iv))
    with open(path, "wb") as f:
        f.write(base64.b64encode(new_key))
    os.chmod(path, 0o400)

def create_key_file ( path ) : iv = "{}{}" . format ( os . urandom ( 32 ) , time . time ( ) ) new_key = generate_key ( ensure_bytes ( iv ) ) with open ( path , "wb" ) as f : f . write ( base64 . b64encode ( new_key ) ) os . chmod ( path , 0o400 )

Creates a new encryption key in the path provided and sets the file permissions . Setting the file permissions currently does not work on Windows platforms because of the differences in how file permissions are read and modified .


def finish(self):
        """
        Finishes the load job. Called automatically when the connection closes.

        :return: The exit code returned when applying rows to the table
        """
        if self.finished:
            return self.exit_code
        checkpoint_status = self.checkpoint()
        self.exit_code = self._exit_code()
        if self.exit_code != 0:
            raise TeradataPTError("BulkLoad job finished with return code '{}'".format(self.exit_code))
        # TODO(chris): should this happen every time?
        if self.applied_count > 0:
            self._end_acquisition()
            self._apply_rows()
        self.exit_code = self._exit_code()
        if self.exit_code != 0:
            raise TeradataPTError("BulkLoad job finished with return code '{}'".format(self.exit_code))
        self.finished = True
        return self.exit_code

Finishes the load job . Called automatically when the connection closes .


def from_file(self, filename, table=None, delimiter='|', null='NULL',
            panic=True, quotechar='"', parse_dates=False):
        """
        Load from a file into the target table, handling each step of the
        load process.

        Can load from text files, and properly formatted giraffez archive
        files. In both cases, if Gzip compression is detected the file will be
        decompressed while reading and handled appropriately. The encoding is
        determined automatically by the contents of the file.

        It is not necessary to set the columns in use prior to loading from a file.
        In the case of a text file, the header is used to determine column names
        and their order. Valid delimiters include '|', ',', and '\\t' (tab). When
        loading an archive file, the column information is decoded alongside the data.

        :param str filename: The location of the file to be loaded
        :param str table: The name of the target table, if it was not specified
            to the constructor for the isntance
        :param str null: The string that indicates a null value in the rows being
            inserted from a file. Defaults to 'NULL'
        :param str delimiter: When loading a file, indicates that fields are
            separated by this delimiter. Defaults to :code:`None`, which causes the
            delimiter to be determined from the header of the file. In most
            cases, this behavior is sufficient
        :param str quotechar: The character used to quote fields containing special characters,
            like the delimiter.
        :param bool panic: If :code:`True`, when an error is encountered it will be
            raised. Otherwise, the error will be logged and :code:`self.error_count`
            is incremented.
        :return: The output of the call to
            :meth:`~giraffez.load.TeradataBulkLoad.finish`
        :raises `giraffez.errors.GiraffeError`: if table was not set and :code:`table`
            is :code:`None`, or if a Teradata error ocurred while retrieving table info.
        :raises `giraffez.errors.GiraffeEncodeError`: if :code:`panic` is :code:`True` and there
            are format errors in the row values.
        """
        if not self.table:
            if not table:
                raise GiraffeError("Table must be set or specified to load a file.")
            self.table = table
        if not isinstance(null, basestring):
            raise GiraffeError("Expected 'null' to be str, received {}".format(type(null)))
        with Reader(filename, delimiter=delimiter, quotechar=quotechar) as f:
            if not isinstance(f.delimiter, basestring):
                raise GiraffeError("Expected 'delimiter' to be str, received {}".format(type(delimiter)))
            self.columns = f.header
            if isinstance(f, ArchiveFileReader):
                self.mload.set_encoding(ROW_ENCODING_RAW)
                self.preprocessor = lambda s: s
            if parse_dates:
                self.preprocessor = DateHandler(self.columns)
            self._initiate()
            self.mload.set_null(null)
            self.mload.set_delimiter(delimiter)
            i = 0
            for i, line in enumerate(f, 1):
                self.put(line, panic=panic)
                if i % self.checkpoint_interval == 1:
                    log.info("\rBulkLoad", "Processed {} rows".format(i), console=True)
                    checkpoint_status = self.checkpoint()
                    self.exit_code = self._exit_code()
                    if self.exit_code != 0:
                        return self.exit_code
            log.info("\rBulkLoad", "Processed {} rows".format(i))
            return self.finish()

Load from a file into the target table handling each step of the load process .


def put(self, items, panic=True):
        """
        Load a single row into the target table.

        :param list items: A list of values in the row corresponding to the
            fields specified by :code:`self.columns`
        :param bool panic: If :code:`True`, when an error is encountered it will be
            raised. Otherwise, the error will be logged and :code:`self.error_count`
            is incremented.
        :raises `giraffez.errors.GiraffeEncodeError`: if :code:`panic` is :code:`True` and there
            are format errors in the row values.
        :raises `giraffez.errors.GiraffeError`: if table name is not set.
        :raises `giraffez.TeradataPTError`: if there is a problem
            connecting to Teradata.
        """
        if not self.initiated:
            self._initiate()
        try:
            row_status = self.mload.put_row(self.preprocessor(items))
            self.applied_count += 1
        except (TeradataPTError, EncoderError) as error:
            self.error_count += 1
            if panic:
                raise error
            log.info("BulkLoad", error)

def put ( self , items , panic = True ) : if not self . initiated : self . _initiate ( ) try : row_status = self . mload . put_row ( self . preprocessor ( items ) ) self . applied_count += 1 except ( TeradataPTError , EncoderError ) as error : self . error_count += 1 if panic : raise error log . info ( "BulkLoad" , error )

Load a single row into the target table .


def release(self):
        """
        Attempt release of target mload table.

        :raises `giraffez.errors.GiraffeError`: if table was not set by
            the constructor, the :code:`TeradataBulkLoad.table`, or
            :meth:`~giraffez.load.TeradataBulkLoad.from_file`.
        """
        if self.table is None:
            raise GiraffeError("Cannot release. Target table has not been set.")
        log.info("BulkLoad", "Attempting release for table {}".format(self.table))
        self.mload.release(self.table)


def tables(self):
        """
        The names of the work tables used for loading.

        :return: A list of four tables, each the name of the target table
            with the added suffixes, "_wt", "_log", "_e1", and "_e2"
        :raises `giraffez.errors.GiraffeError`: if table was not set by
            the constructor, the :code:`TeradataBulkLoad.table`, or
            :meth:`~giraffez.load.TeradataBulkLoad.from_file`.
        """
        if self.table is None:
            raise GiraffeError("Target table has not been set.")
        return [
            "{}_wt".format(self.table),
            "{}_log".format(self.table),
            "{}_e1".format(self.table),
            "{}_e2".format(self.table),
        ]

def
tables
(
self
)
:
if
self
.
table
is
:
raise
GiraffeError
(
"Target table has not been set."
)
return
[
"{}_wt"
.
format
(
self
.
table
)
,
"{}_log"
.
format
(
self
.
table
)
,
"{}_e1"
.
format
(
self
.
table
)
,
"{}_e2"
.
format
(
self
.
table
)
,
]

The names of the work tables used for loading .


def fix_compile(remove_flags):
    """
    Monkey-patch compiler to allow for removal of default compiler flags.
    """
    import distutils.ccompiler

    def _fix_compile(self, sources, output_dir=None, macros=None, include_dirs=None, debug=0,
            extra_preargs=None, extra_postargs=None, depends=None):
        for flag in remove_flags:
            if flag in self.compiler_so:
                self.compiler_so.remove(flag)
        macros, objects, extra_postargs, pp_opts, build = self._setup_compile(output_dir, macros,
                include_dirs, sources, depends, extra_postargs)
        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
        return objects

    distutils.ccompiler.CCompiler.compile = _fix_compile

def fix_compile ( remove_flags ) : import distutils . ccompiler def _fix_compile ( self , sources , output_dir = None , macros = None , include_dirs = None , debug = 0 , extra_preargs = None , extra_postargs = None , depends = None ) : for flag in remove_flags : if flag in self . compiler_so : self . compiler_so . remove ( flag ) macros , objects , extra_postargs , pp_opts , build = self . _setup_compile ( output_dir , macros , include_dirs , sources , depends , extra_postargs ) cc_args = self . _get_cc_args ( pp_opts , debug , extra_preargs ) for obj in objects : try : src , ext = build [ obj ] except KeyError : continue self . _compile ( obj , src , ext , cc_args , extra_postargs , pp_opts ) return objects distutils . ccompiler . CCompiler . compile = _fix_compile

Monkey - patch compiler to allow for removal of default compiler flags .


def find_teradata_home():
    """
    Attempts to find the Teradata install directory with the defaults
    for a given platform.  Should always return `None` when the defaults
    are not present and the TERADATA_HOME environment variable wasn't
    explicitly set to the correct install location.
    """
    if platform.system() == 'Windows':
        # The default installation path for Windows is split between the
        # Windows directories for 32-bit/64-bit applications.  It is
        # worth noting that Teradata archiecture installed should match
        # the architecture of the Python architecture being used (i.e.
        # TTU 32-bit is required /w Python 32-bit and TTU 64-bit is
        # required for Python 64-bit).
        if is_64bit():
            return latest_teradata_version("C:/Program Files/Teradata/Client")
        else:
            return latest_teradata_version("C:/Program Files (x86)/Teradata/Client")
    elif platform.system() == 'Linux':
        return latest_teradata_version("/opt/teradata/client")
    elif platform.system() == 'Darwin':
        return latest_teradata_version("/Library/Application Support/teradata/client")
    else:
        # In the case nothing is found, the default for Linux is
        # attempted as a last effort to find the correct install
        # directory.
        return latest_teradata_version("/opt/teradata/client")

Attempts to find the Teradata install directory with the defaults for a given platform . Should always return None when the defaults are not present and the TERADATA_HOME environment variable wasn t explicitly set to the correct install location .


def get(self, key):
        """
        Retrieve the decrypted value of a key in a giraffez
        configuration file.

        :param str key: The key used to lookup the encrypted value
        """
        if not key.startswith("secure.") and not key.startswith("connections."):
            key = "secure.{0}".format(key)
        value = self.config.get_value(key)
        if not isinstance(value, basestring):
            value = None
        return value

def get ( self , key ) : if not key . startswith ( "secure." ) and not key . startswith ( "connections." ) : key = "secure.{0}" . format ( key ) value = self . config . get_value ( key ) if not isinstance ( value , basestring ) : value = None return value

Retrieve the decrypted value of a key in a giraffez configuration file .


def set(self, key, value):
        """
        Set a decrypted value by key in a giraffez configuration file.

        :param str key: The key used to lookup the encrypted value
        :param value: Value to set at the given key, can be any value that is
            YAML serializeable.
        """
        if not key.startswith("secure."):
            key = "secure.{0}".format(key)
        self.config.set_value(key, value)
        self.config.write()

def set ( self , key , value ) : if not key . startswith ( "secure." ) : key = "secure.{0}" . format ( key ) self . config . set_value ( key , value ) self . config . write ( )

Set a decrypted value by key in a giraffez configuration file .


def do_table(self, line):
        """Display results in table format"""
        if len(line) > 0:
            if line.strip().lower() == "on":
                log.write("Table ON")
                self.table_output = True
                return
            elif line.strip().lower() == "off":
                log.write("Table OFF")
                self.table_output = False
                return
        log.write("Table output: {}".format("ON" if self.table_output else "OFF"))

def
do_table
(
self
,
line
)
:
if
len
(
line
)
>
0
:
if
line
.
strip
(
)
.
lower
(
)
==
"on"
:
log
.
write
(
"Table ON"
)
self
.
table_output
=
True
return
elif
line
.
strip
(
)
.
lower
(
)
==
"off"
:
log
.
write
(
"Table OFF"
)
self
.
table_output
=
False
return
log
.
write
(
"Table output: {}"
.
format
(
"ON"
if
self
.
table_output
else
"OFF"
)
)


def execute(self, command, coerce_floats=True, parse_dates=False, header=False, sanitize=True,
            silent=False, panic=None,  multi_statement=False, prepare_only=False):
        """
        Execute commands using CLIv2.

        :param str command: The SQL command to be executed
        :param bool coerce_floats: Coerce Teradata decimal types into Python floats
        :param bool parse_dates: Parses Teradata datetime types into Python datetimes
        :param bool header: Include row header
        :param bool sanitize: Whether or not to call :func:`~giraffez.sql.prepare_statement`
            on the command
        :param bool silent: Silence console logging (within this function only)
        :param bool panic: If :code:`True`, when an error is encountered it will be
            raised.
        :param bool multi_statement: Execute in multi-statement mode
        :param bool prepare_only: Only prepare the command (no results)
        :return: a cursor over the results of each statement in the command
        :rtype: :class:`~giraffez.cmd.Cursor`
        :raises `giraffez.TeradataError`: if the query is invalid
        :raises `giraffez.errors.GiraffeError`: if the return data could not be decoded
        """
        if panic is None:
            panic = self.panic
        self.options("panic", panic)
        self.options("multi-statement mode", multi_statement, 3)
        if isfile(command):
            self.options("file", command, 2)
            with open(command, 'r') as f:
                command = f.read()
        else:
            if log.level >= VERBOSE:
                self.options("query", command, 2)
            else:
                self.options("query", truncate(command), 2)
        if not silent and not self.silent:
            log.info("Command", "Executing ...")
            log.info(self.options)
        if sanitize:
            command = prepare_statement(command) # accounts for comments and newlines
            log.debug("Debug[2]", "Command (sanitized): {!r}".format(command))
        self.cmd.set_encoding(ENCODER_SETTINGS_DEFAULT)
        return Cursor(self.cmd, command, multi_statement=multi_statement, header=header,
            prepare_only=prepare_only, coerce_floats=coerce_floats, parse_dates=parse_dates,
            panic=panic)

def
execute
(
self
,
command
,
coerce_floats
=
True
,
parse_dates
=
False
,
header
=
False
,
sanitize
=
True
,
silent
=
False
,
panic
=
,
multi_statement
=
False
,
prepare_only
=
False
)
:
if
panic
is
:
panic
=
self
.
panic
self
.
options
(
"panic"
,
panic
)
self
.
options
(
"multi-statement mode"
,
multi_statement
,
3
)
if
isfile
(
command
)
:
self
.
options
(
"file"
,
command
,
2
)
with
open
(
command
,
'r'
)
as
f
:
command
=
f
.
read
(
)
else
:
if
log
.
level
>=
VERBOSE
:
self
.
options
(
"query"
,
command
,
2
)
else
:
self
.
options
(
"query"
,
truncate
(
command
)
,
2
)
if
not
silent
and
not
self
.
silent
:
log
.
info
(
"Command"
,
"Executing ..."
)
log
.
info
(
self
.
options
)
if
sanitize
:
command
=
prepare_statement
(
command
)
log
.
debug
(
"Debug[2]"
,
"Command (sanitized): {!r}"
.
format
(
command
)
)
self
.
cmd
.
set_encoding
(
ENCODER_SETTINGS_DEFAULT
)
return
Cursor
(
self
.
cmd
,
command
,
multi_statement
=
multi_statement
,
header
=
header
,
prepare_only
=
prepare_only
,
coerce_floats
=
coerce_floats
,
parse_dates
=
parse_dates
,
panic
=
panic
)


def get_value(self, key, default={}, nested=True, decrypt=True):
        """
        Retrieve a value from the configuration based on its key. The key
        may be nested.

        :param str key: A path to the value, with nested levels joined by '.'
        :param default: Value to return if the key does not exist (defaults to :code:`dict()`)
        :param bool decrypt: If :code:`True`, decrypt an encrypted value before returning
            (if encrypted).  Defaults to :code:`True`.
        """
        key = key.lstrip()
        if key.endswith("."):
            key = key[:-1]
        if nested:
            path = key.split(".")
            curr = self.settings
            for p in path[:-1]:
                curr = curr.get(p, {})
            try:
                value = curr[path[-1]]
            except KeyError:
                return default
            value = self.decrypt(value, path)
            return value
        else:
            return self.settings.get(key, default)

def get_value ( self , key , default = { } , nested = True , decrypt = True ) : key = key . lstrip ( ) if key . endswith ( "." ) : key = key [ : - 1 ] if nested : path = key . split ( "." ) curr = self . settings for p in path [ : - 1 ] : curr = curr . get ( p , { } ) try : value = curr [ path [ - 1 ] ] except KeyError : return default value = self . decrypt ( value , path ) return value else : return self . settings . get ( key , default )

Retrieve a value from the configuration based on its key . The key may be nested .


def write_default(self, conf=None):
        """
        A class method to write a default configuration file structure to a file.
        Note that the contents of the file will be overwritten if it already exists.

        :param str conf: The name of the file to write to. Defaults to :code:`None`, for ~/.girafferc
        :return: The content written to the file
        :rtype: str
        """
        if conf is None:
            conf = home_file(".girafferc")
        contents = yaml.dump(default_config, default_flow_style=False)
        with open(conf, "w") as f:
            f.write(contents)
        os.chmod(conf, 0o600)
        return contents

def write_default ( self , conf = None ) : if conf is None : conf = home_file ( ".girafferc" ) contents = yaml . dump ( default_config , default_flow_style = False ) with open ( conf , "w" ) as f : f . write ( contents ) os . chmod ( conf , 0o600 ) return contents

A class method to write a default configuration file structure to a file . Note that the contents of the file will be overwritten if it already exists .


def set_filter(self, names=None):
        """
        Set the names of columns to be used when iterating through the list,
        retrieving names, etc.

        :param list names: A list of names to be used, or :code:`None` for all
        """
        _names = []
        if names:
            for name in names:
                _safe_name = safe_name(name)
                if _safe_name not in self._column_map:
                    raise GiraffeTypeError("Column '{}' does not exist".format(name))
                if _safe_name in _names:
                    continue
                _names.append(_safe_name)
        self._filtered_columns = _names

def
set_filter
(
self
,
names
=
)
:
_names
=
[
]
if
names
:
for
name
in
names
:
_safe_name
=
safe_name
(
name
)
if
_safe_name
not
in
self
.
_column_map
:
raise
GiraffeTypeError
(
"Column '{}' does not exist"
.
format
(
name
)
)
if
_safe_name
in
_names
:
continue
_names
.
append
(
_safe_name
)
self
.
_filtered_columns
=
_names

Set the names of columns to be used when iterating through the list retrieving names etc .


def to_archive(self, writer):
        """
        Writes export archive files in the Giraffez archive format.
        This takes a `giraffez.io.Writer` and writes archive chunks to
        file until all rows for a given statement have been exhausted.

        .. code-block:: python

            with giraffez.BulkExport("database.table_name") as export:
                with giraffez.Writer("database.table_name.tar.gz", 'wb', use_gzip=True) as out:
                    for n in export.to_archive(out):
                        print("Rows: {}".format(n))

        :param `giraffez.io.Writer` writer: A writer handling the archive output

        :rtype: iterator (yields ``int``)
        """
        if 'b' not in writer.mode:
            raise GiraffeError("Archive writer must be in binary mode")
        writer.write(GIRAFFE_MAGIC)
        writer.write(self.columns.serialize())
        i = 0
        for n, chunk in enumerate(self._fetchall(ROW_ENCODING_RAW), 1):
            writer.write(chunk)
            yield TeradataEncoder.count(chunk)

def
to_archive
(
self
,
writer
)
:
if
'b'
not
in
writer
.
mode
:
raise
GiraffeError
(
"Archive writer must be in binary mode"
)
writer
.
write
(
GIRAFFE_MAGIC
)
writer
.
write
(
self
.
columns
.
serialize
(
)
)
i
=
0
for
n
,
chunk
in
enumerate
(
self
.
_fetchall
(
ROW_ENCODING_RAW
)
,
1
)
:
writer
.
write
(
chunk
)
yield
TeradataEncoder
.
count
(
chunk
)

Writes export archive files in the Giraffez archive format . This takes a giraffez . io . Writer and writes archive chunks to file until all rows for a given statement have been exhausted .


def to_str(self, delimiter='|', null='NULL'):
        """
        Sets the current encoder output to Python `str` and returns
        a row iterator.

        :param str null: The string representation of null values
        :param str delimiter: The string delimiting values in the output
            string

        :rtype: iterator (yields ``str``)
        """
        self.export.set_null(null)
        self.export.set_delimiter(delimiter)
        self.options("delimiter", escape_string(delimiter), 2)
        self.options("null", null, 3)
        return self._fetchall(ENCODER_SETTINGS_STRING, coerce_floats=False)

def to_str ( self , delimiter = '|' , null = 'NULL' ) : self . export . set_null ( null ) self . export . set_delimiter ( delimiter ) self . options ( "delimiter" , escape_string ( delimiter ) , 2 ) self . options ( "null" , null , 3 ) return self . _fetchall ( ENCODER_SETTINGS_STRING , coerce_floats = False )

Sets the current encoder output to Python str and returns a row iterator .


def float_with_multiplier(string):
    """Convert string with optional k, M, G, T multiplier to float"""
    match = re_float_with_multiplier.search(string)
    if not match or not match.group('num'):
        raise ValueError('String "{}" is not numeric!'.format(string))

    num = float(match.group('num'))
    multi = match.group('multi')
    if multi:
        try:
            num *= multipliers[multi]
        except KeyError:
            raise ValueError('Unknown multiplier: {}'.format(multi))
    return num

def
float_with_multiplier
(
string
)
:
match
=
re_float_with_multiplier
.
search
(
string
)
if
not
match
or
not
match
.
group
(
'num'
)
:
raise
ValueError
(
'String "{}" is not numeric!'
.
format
(
string
)
)
num
=
float
(
match
.
group
(
'num'
)
)
multi
=
match
.
group
(
'multi'
)
if
multi
:
try
:
num
*=
multipliers
[
multi
]
except
KeyError
:
raise
ValueError
(
'Unknown multiplier: {}'
.
format
(
multi
)
)
return
num

Convert string with optional k M G T multiplier to float


def specific_gains(string):
    """Convert string with gains of individual amplification elements to dict"""
    if not string:
        return {}

    gains = {}
    for gain in string.split(','):
        amp_name, value = gain.split('=')
        gains[amp_name.strip()] = float(value.strip())
    return gains

def specific_gains ( string ) : if not string : return { } gains = { } for gain in string . split ( ',' ) : amp_name , value = gain . split ( '=' ) gains [ amp_name . strip ( ) ] = float ( value . strip ( ) ) return gains


def device_settings(string):
    """Convert string with SoapySDR device settings to dict"""
    if not string:
        return {}

    settings = {}
    for setting in string.split(','):
        setting_name, value = setting.split('=')
        settings[setting_name.strip()] = value.strip()
    return settings

def device_settings ( string ) : if not string : return { } settings = { } for setting in string . split ( ',' ) : setting_name , value = setting . split ( '=' ) settings [ setting_name . strip ( ) ] = value . strip ( ) return settings


def wrap(text, indent='    '):
    """Wrap text to terminal width with default indentation"""
    wrapper = textwrap.TextWrapper(
        width=int(os.environ.get('COLUMNS', 80)),
        initial_indent=indent,
        subsequent_indent=indent
    )
    return '\n'.join(wrapper.wrap(text))

def
wrap
(
text
,
indent
=
'    '
)
:
wrapper
=
textwrap
.
TextWrapper
(
width
=
int
(
os
.
environ
.
get
(
'COLUMNS'
,
80
)
)
,
initial_indent
=
indent
,
subsequent_indent
=
indent
)
return
'\n'
.
join
(
wrapper
.
wrap
(
text
)
)


def detect_devices(soapy_args=''):
    """Returns detected SoapySDR devices"""
    devices = simplesoapy.detect_devices(soapy_args, as_string=True)
    text = []
    text.append('Detected SoapySDR devices:')
    if devices:
        for i, d in enumerate(devices):
            text.append('  {}'.format(d))
    else:
        text.append('  No devices found!')
    return (devices, '\n'.join(text))

def
detect_devices
(
soapy_args
=
''
)
:
devices
=
simplesoapy
.
detect_devices
(
soapy_args
,
as_string
=
True
)
text
=
[
]
text
.
append
(
'Detected SoapySDR devices:'
)
if
devices
:
for
i
,
d
in
enumerate
(
devices
)
:
text
.
append
(
'  {}'
.
format
(
d
)
)
else
:
text
.
append
(
'  No devices found!'
)
return
(
devices
,
'\n'
.
join
(
text
)
)


def set_center_freq(self, center_freq):
        """Set center frequency and clear averaged PSD data"""
        psd_state = {
            'repeats': 0,
            'freq_array': self._base_freq_array + self._lnb_lo + center_freq,
            'pwr_array': None,
            'update_lock': threading.Lock(),
            'futures': [],
        }
        return psd_state

def set_center_freq ( self , center_freq ) : psd_state = { 'repeats' : 0 , 'freq_array' : self . _base_freq_array + self . _lnb_lo + center_freq , 'pwr_array' : None , 'update_lock' : threading . Lock ( ) , 'futures' : [ ] , } return psd_state


def result(self, psd_state):
        """Return freqs and averaged PSD for given center frequency"""
        freq_array = numpy.fft.fftshift(psd_state['freq_array'])
        pwr_array = numpy.fft.fftshift(psd_state['pwr_array'])

        if self._crop_factor:
            crop_bins_half = round((self._crop_factor * self._bins) / 2)
            freq_array = freq_array[crop_bins_half:-crop_bins_half]
            pwr_array = pwr_array[crop_bins_half:-crop_bins_half]

        if psd_state['repeats'] > 1:
            pwr_array = pwr_array / psd_state['repeats']

        if self._log_scale:
            pwr_array = 10 * numpy.log10(pwr_array)

        return (freq_array, pwr_array)

def result ( self , psd_state ) : freq_array = numpy . fft . fftshift ( psd_state [ 'freq_array' ] ) pwr_array = numpy . fft . fftshift ( psd_state [ 'pwr_array' ] ) if self . _crop_factor : crop_bins_half = round ( ( self . _crop_factor * self . _bins ) / 2 ) freq_array = freq_array [ crop_bins_half : - crop_bins_half ] pwr_array = pwr_array [ crop_bins_half : - crop_bins_half ] if psd_state [ 'repeats' ] > 1 : pwr_array = pwr_array / psd_state [ 'repeats' ] if self . _log_scale : pwr_array = 10 * numpy . log10 ( pwr_array ) return ( freq_array , pwr_array )


def wait_for_result(self, psd_state):
        """Wait for all PSD threads to finish and return result"""
        if len(psd_state['futures']) > 1:
            concurrent.futures.wait(psd_state['futures'])
        elif psd_state['futures']:
            psd_state['futures'][0].result()
        return self.result(psd_state)

def wait_for_result ( self , psd_state ) : if len ( psd_state [ 'futures' ] ) > 1 : concurrent . futures . wait ( psd_state [ 'futures' ] ) elif psd_state [ 'futures' ] : psd_state [ 'futures' ] [ 0 ] . result ( ) return self . result ( psd_state )


def update(self, psd_state, samples_array):
        """Compute PSD from samples and update average for given center frequency"""
        freq_array, pwr_array = simplespectral.welch(samples_array, self._sample_rate, nperseg=self._bins,
                                                     window=self._fft_window, noverlap=self._fft_overlap_bins,
                                                     detrend=self._detrend)

        if self._remove_dc:
            pwr_array[0] = (pwr_array[1] + pwr_array[-1]) / 2

        with psd_state['update_lock']:
            psd_state['repeats'] += 1
            if psd_state['pwr_array'] is None:
                psd_state['pwr_array'] = pwr_array
            else:
                psd_state['pwr_array'] += pwr_array

def update ( self , psd_state , samples_array ) : freq_array , pwr_array = simplespectral . welch ( samples_array , self . _sample_rate , nperseg = self . _bins , window = self . _fft_window , noverlap = self . _fft_overlap_bins , detrend = self . _detrend ) if self . _remove_dc : pwr_array [ 0 ] = ( pwr_array [ 1 ] + pwr_array [ - 1 ] ) / 2 with psd_state [ 'update_lock' ] : psd_state [ 'repeats' ] += 1 if psd_state [ 'pwr_array' ] is None : psd_state [ 'pwr_array' ] = pwr_array else : psd_state [ 'pwr_array' ] += pwr_array


def read(self, f):
        """Read data from file-like object"""
        magic = f.read(len(self.magic))
        if not magic:
            return None
        if magic != self.magic:
            raise ValueError('Magic bytes not found! Read data: {}'.format(magic))

        header = self.header._make(
            self.header_struct.unpack(f.read(self.header_struct.size))
        )
        pwr_array = numpy.fromstring(f.read(header.size), dtype='float32')
        return (header, pwr_array)

def
read
(
self
,
f
)
:
magic
=
f
.
read
(
len
(
self
.
magic
)
)
if
not
magic
:
return
if
magic
!=
self
.
magic
:
raise
ValueError
(
'Magic bytes not found! Read data: {}'
.
format
(
magic
)
)
header
=
self
.
header
.
_make
(
self
.
header_struct
.
unpack
(
f
.
read
(
self
.
header_struct
.
size
)
)
)
pwr_array
=
numpy
.
fromstring
(
f
.
read
(
header
.
size
)
,
dtype
=
'float32'
)
return
(
header
,
pwr_array
)


def write(self, f, time_start, time_stop, start, stop, step, samples, pwr_array):
        """Write data to file-like object"""
        f.write(self.magic)
        f.write(self.header_struct.pack(
            self.version, time_start, time_stop, start, stop, step, samples, pwr_array.nbytes
        ))
        #pwr_array.tofile(f)
        f.write(pwr_array.tobytes())
        f.flush()

def write ( self , f , time_start , time_stop , start , stop , step , samples , pwr_array ) : f . write ( self . magic ) f . write ( self . header_struct . pack ( self . version , time_start , time_stop , start , stop , step , samples , pwr_array . nbytes ) ) f . write ( pwr_array . tobytes ( ) ) f . flush ( )