Beispiel #1
0
 def findTile(self, src, has_property):
     depth = 0
     src.depth = depth
     found = False
     ls = [src]
     
     while not found:
         depth += 1
         _ls = []
         
         for tile in ls: 
             children = self.neighborsOf(tile)
             children = __builtin__.filter(self.isFlat, children)
             children = __builtin__.filter(self.notVisited, children)
             for child in children:
                 child.depth = depth
                 if has_property(child):
                     found = True
                     return child
                     
             _ls += children
     
         ls = _ls
         
         if len(ls) == 0:    
             return None
Beispiel #2
0
    def updateAllTileBorders(self, world):
        water = __builtin__.filter(world.isWater, world.tiles)
        grass = __builtin__.filter(world.isFlat, world.tiles)

        for tile in grass:
           self.updateTileBorders(tile)
        for tile in water:
            self.updateTileBorders(tile)
Beispiel #3
0
 def spreadForest(self, tile, gen_chance=90.0):
     tile.visited = True
     
     if (random.uniform(0,100.0) < gen_chance):
         tile.vegetation = Vegetation.FOREST
     
         neighbors = self.neighborsOf(tile)
         neighbors = __builtin__.filter(self.isFlat, neighbors)
         neighbors = __builtin__.filter(self.notVisited, neighbors)
         
         for tile in neighbors:
             self.spreadForest(tile, gen_chance-20.0)
Beispiel #4
0
    def clear_lockout(self):
        """Clears lockout channels and updates GUI list
        """
        # Clear the lockout channels
        self.lockout_channels = []

        # Process lockout file if it was provided
        if self.lockout_file_name != "":
            # Open file, split to list, remove empty strings
            with open(self.lockout_file_name) as lockout_file:
                lines = lockout_file.read().splitlines()
                lockout_file.close()
                lines = __builtin__.filter(None, lines)
            # Convert to baseband frequencies, round, and append
            for freq in lines:
                rf_freq = float(freq) - self.center_freq
                rf_freq = round(rf_freq/self.channel_spacing)*\
                                        self.channel_spacing
                self.lockout_channels.append(rf_freq)
        else:
            pass

        # Create a lockout channel list of strings for the GUI
        self.gui_lockout_channels = []
        for lockout_channel in self.lockout_channels:
            gui_lockout_channel = (lockout_channel + \
                                    self.receiver.center_freq)/1E6
            text = '{:.3f}'.format(gui_lockout_channel)
            self.gui_lockout_channels.append(text)
Beispiel #5
0
def test_pipeline_example():
    from functools import reduce
    import operator as op

    data = range(100)
    result1 = math.sqrt(
        reduce(
            op.add,
            builtins.map(
                lambda x: x ** 2.0,
                builtins.filter(
                    lambda x: x % 2 == 0,
                    data,
                )
            )
        )
    )

    from toolz.curried import filter, map, reduce
    from flowly.tz import chained

    transform = chained(
        filter(lambda x: x % 2 == 0),
        map(lambda x: x ** 2.0),
        reduce(op.add),
        math.sqrt,
    )

    result2 = transform(data)

    assert result1 == result2
Beispiel #6
0
 def generateForests(self):
     gen_chance = 3.0
     land = __builtin__.filter(self.isFlat, self.tiles)
           
     for tile in land:
         if (random.uniform(0, 100.0) < gen_chance) and (tile.vegetation == Vegetation.NONE):
             tile.vegetation = Vegetation.FOREST
             self.spreadForest(tile)
             self.resetVisited()
Beispiel #7
0
def filter(function, sequence):
    """
    Return a sequence containing those items of sequence for which
    function(item) is True.  The order of items in sequence is
    preserved.

        >>> filter(lambda x: x<3, [3, 1, 5, 0, 2, 4])
        [1, 0, 2]
    """
    return __builtin__.filter(function, sequence)
Beispiel #8
0
 def log(self, args):
     """
     Show the log.
     """
     #noinspection PyTupleAssignmentBalance
     app_name, deployment_name = self.parse_app_deployment_name(args.name)
     if not deployment_name:
         raise InputErrorException('NoDeployment')
     last_time = None
     while True:
         #noinspection PyUnusedLocal
         logEntries = []
         try:
             logEntries = self.api.read_log(
                 app_name,
                 deployment_name,
                 args.type,
                 last_time=last_time)
         except GoneError:
             raise InputErrorException('WrongApplication')
         if len(logEntries) > 0:
             last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
             if args.type == 'worker' and args.wrk_id:
                 logEntries = filter(lambda entry:
                                     entry['wrk_id'] == args.wrk_id, logEntries)
             if args.filter:
                 if args.type in ["error", "worker"]:
                     logEntries = filter(
                         lambda entry: re.search(
                             re.compile(args.filter, re.IGNORECASE),
                             entry['message']),
                         logEntries)
                 if args.type == 'access':
                     logEntries = filter(lambda entry:
                                         re.search(
                                         re.compile(args.filter, re.IGNORECASE),
                                         entry['first_request_line'] +
                                         entry['referer'] +
                                         entry['user_agent'] +
                                         entry['remote_host']),
                                         logEntries)
             print_log_entries(logEntries, args.type)
         time.sleep(2)
Beispiel #9
0
    def get(
        cls, name=__name__, level=(), buffer=(), terminator=(),
        colored_format=(), format=()
    ):
# #
        '''
            Returns a new or existing instance of a logger with given \
            properties. If a logger was already registered under given name \
            the existing instance is given back and a new instance otherwise.

            **name**           - logger name to get

            **level**          - sets levels for all logger

            **buffer**         - sets buffers for all logger

            **terminator**     - sets an ending char for each log message in \
                                 each logger

            **colored_format** - sets templates for colored logging messages \
                                 in returned logger, if "None" is given \
                                 normal format will be used instead.

            **format**         - sets templates for logging messages in each \
                                 logger

            Examples:

            >>> logger_a = Logger.get('test', buffer=(__test_buffer__,))
            >>> logger_b = Logger.get('test')
            >>> logger_c = Logger.get('test', buffer=(__test_buffer__,))
            >>> logger_a is logger_b
            True

            >>> __test_buffer__.clear() # doctest: +ELLIPSIS
            '...'
            >>> logger_a.critical('Log some information.')
            >>> __test_buffer__.clear() # doctest: +ELLIPSIS
            '... - test... - ...CRITICAL... - Log some information.\\n'
        '''
        for logger in builtins.filter(
            lambda logger: logger.name == name, cls.instances
        ):
            if level or buffer or terminator or colored_format or format:
                cls.instances[cls.instances.index(
                    logger
                )] = cls._generate_logger(
                    name, level, buffer, terminator, colored_format, format)
            return logger
        cls.instances.append(cls._generate_logger(
            name, level, buffer, terminator, colored_format, format))
        return cls.instances[-1]
Beispiel #10
0
 def log(self, args):
     """
     Show the log.
     """
     app_name, deployment_name = self.parse_app_deployment_name(args.name)
     if not deployment_name:
         deployment_name = "default"
     last_time = None
     while True:
         logEntries = []
         try:
             logEntries = self.api.read_log(app_name, deployment_name, args.type, last_time=last_time)
         except GoneError:
             raise InputErrorException("WrongApplication")
         if len(logEntries) > 0:
             last_time = datetime.fromtimestamp(float(logEntries[-1]["time"]))
             if args.type == "worker" and args.wrk_id:
                 logEntries = filter(lambda entry: entry["wrk_id"] == args.wrk_id, logEntries)
             if args.filter:
                 if args.type in ["error", "worker"]:
                     logEntries = filter(
                         lambda entry: re.search(re.compile(args.filter, re.IGNORECASE), entry["message"]),
                         logEntries,
                     )
                 if args.type == "access":
                     logEntries = filter(
                         lambda entry: re.search(
                             re.compile(args.filter, re.IGNORECASE),
                             entry["first_request_line"]
                             + entry["referer"]
                             + entry["user_agent"]
                             + entry["remote_host"],
                         ),
                         logEntries,
                     )
             print_log_entries(logEntries, args.type)
         time.sleep(2)
Beispiel #11
0
def _check_samtools(command, threads=1, extend=None):
    """Return based on threads and existence of parallel samtools"""
    global __parallel_samtools
    if threads == 1:
        p = [executables["samtools"], command]
    else:
        if __parallel_samtools is None:
            (s, e) = subprocess.Popen([executables["samtools"], "view"], stderr=subprocess.PIPE, stdout=subprocess.PIPE).communicate()
            f = __builtin__.filter(lambda x: x.startswith("-@"), [l.strip() for l in e.split("\n")])
            __parallel_samtools = len(f) > 0

        if __parallel_samtools:
            p = [executables["samtools"], command, "-@", str(threads)]
        else:
            p = [executables["samtools"], command]
    if extend is not None:
        p.extend(extend)
    return p
Beispiel #12
0
def _check_samtools(command, threads=1, extend=None):
    """Return based on threads and existence of parallel samtools"""
    global __parallel_samtools
    if threads == 1:
        p = [executables["samtools"], command]
    else:
        if __parallel_samtools is None:
            (s, e) = subprocess.Popen([executables["samtools"], "view"],
                                      stderr=subprocess.PIPE,
                                      stdout=subprocess.PIPE).communicate()
            f = __builtin__.filter(lambda x: x.startswith("-@"),
                                   [l.strip() for l in e.split("\n")])
            __parallel_samtools = len(f) > 0

        if __parallel_samtools:
            p = [executables["samtools"], command, "-@", str(threads)]
        else:
            p = [executables["samtools"], command]
    if extend is not None:
        p.extend(extend)
    return p
Beispiel #13
0
    def __init__(self, rows, cols, debug):
        self.db = debug
        self.width = cols
        self.height = rows
        
        self.tiles = list()
        num_tiles = rows*cols + rows/2
        
        for row in range(rows):
            for col in range(cols):
                self.tiles.append(Tile(col, row))
            #odd rows have an extra column
            if row % 2 != 0:
                self.tiles.append(Tile(cols, row))
        
        #Place player
        #choose a random tile to place player
        #more likely to be towards center
        player_x = int( random.triangular(0,cols))
        player_y = int( random.triangular(0,rows))
        player_tile = self.tileAt(player_x, player_y)
        player_tile.has_player = True
        
        #Player location is flatland
        player_tile.terrain = Terrain.FLAT
        self.generateLandmassAround(player_tile.pos[0],player_tile.pos[1])
        self.resetVisited()
        
        self.generateForests()
        
        #Place City
        land = __builtin__.filter(self.isClear, self.tiles)
        idx = random.randint(0,len(land)-1)
        city_tile = land[idx]
        city_tile.has_city = True
        worker = Worker(city_tile,self)
        city_tile.has_worker=True

        self.entities = [worker]
Beispiel #14
0
 def findPath(self, src, has_property):
     curr = self.findTile(src, has_property)
     if curr == None:
         return list()
         
     path = [curr]
     
     f = lambda t:  t.depth == (curr.depth-1)
     
     #find neighbor of dst with appropriate depth
     while True:
         neighbors = self.neighborsOf(curr)
         neighbors = __builtin__.filter(f, neighbors)
         
         i = random.randint(0,len(neighbors)-1)
         curr = neighbors[i]
         path.append(curr)
         
         if curr.depth == 0:
             path.pop()
             self.resetDepth()
             return path
Beispiel #15
0
    def update_priority(self):
        """Updates priority channels
        """
        # Clear the priority channels
        self.priority_channels = []

        # Process priority file if it was provided
        if self.priority_file_name != "":
            # Open file, split to list, remove empty strings
            with open(self.priority_file_name) as priority_file:
                lines = priority_file.read().splitlines()
                priority_file.close()
                lines = __builtin__.filter(None, lines)
            # Convert to baseband frequencies, round, and append if within BW
            for freq in lines:
                bb_freq = float(freq) - self.center_freq
                bb_freq = round(bb_freq / self.channel_spacing) * self.channel_spacing
                if abs(bb_freq) <= self.samp_rate / 2.0:
                    self.priority_channels.append(bb_freq)
                else:
                    pass
        else:
            pass
Beispiel #16
0
    def _set_properties(
        cls, level, buffer, terminator, colored_format, format
    ):
# #
        '''
            This method sets the class properties.

            Examples:

            >>> Logger._set_properties(
            ...     level=Logger.level, buffer=Logger.buffer,
            ...     terminator=Logger.terminator,
            ...     colored_format=Logger.colored_format, format=Logger.format
            ... ) # doctest: +ELLIPSIS
            <class '...Logger'>
        '''
        # TODO check branches.
        scope = builtins.locals()
        for name in builtins.filter(lambda name: scope[name], (
            'level', 'buffer', 'terminator', 'colored_format', 'format'
        )):
            builtins.setattr(cls, name, scope[name])
        return cls
Beispiel #17
0
    def update_priority(self):
        """Updates priority channels
        """
        # Clear the priority channels
        self.priority_channels = []

        # Process priority file if it was provided
        if self.priority_file_name != "":
            # Open file, split to list, remove empty strings
            with open(self.priority_file_name) as priority_file:
                lines = priority_file.read().splitlines()
                priority_file.close()
                lines = __builtin__.filter(None, lines)
            # Convert to baseband frequencies, round, and append if within BW
            for freq in lines:
                bb_freq = float(freq) - self.center_freq
                bb_freq = round(bb_freq/self.channel_spacing)*\
                                        self.channel_spacing
                if abs(bb_freq) <= self.samp_rate/2.0:
                    self.priority_channels.append(bb_freq)
                else:
                    pass
        else:
            pass
Beispiel #18
0
def filter(fn, sequence):
  return __builtin__.filter(fn, sequence)
Beispiel #19
0
                return _coconut_tail_call(rec, arr, num - 1, goal - num)

        else:
            # num > goal
            try:
                _coconut_is_recursive = rec is _coconut_recursive_func_0
            except _coconut.NameError:
                _coconut_is_recursive = False
            if _coconut_is_recursive:
                arr, num, goal = arr, goal, goal
                continue
            else:
                return _coconut_tail_call(rec, arr, goal, goal)

        return None


_coconut_recursive_func_0 = rec
n = (int)(input())
summation = n * (n + 1) // 2
if summation % 2 == 1:
    print("NO")
else:
    print("YES")
    sol = (set)(rec([], n, summation // 2))
    print(len(sol))
    (print)((' '.join)(map(str, sol)))
    sol = (list)(filter(lambda x: x not in sol, range(1, n + 1)))
    print(len(sol))
    (print)((' '.join)(map(str, sol)))
Beispiel #20
0
    def __init__(self):

        # Call the initialization method from the parent class
        gr.top_block.__init__(self)

        # Setup the parser for command line arguments
        parser = OptionParser(option_class=eng_option)
        parser.add_option("-v", "--verbose", action="store_true",
                          dest="verbose", default=False,
                          help="print settings to stdout")
        parser.add_option("-a", "--args", type="string", dest="src_args",
                          default='addr=192.168.1.13',
                          help="USRP device address args")
        parser.add_option("-g", "--gain", type="eng_float", dest="src_gain",
                          default=0, help="USRP gain in dB")
        parser.add_option("-q", "--squelch", type="eng_float",
                          dest="squelch_thresh", default=-80,
                          help="Squelch threshold in dB")
        parser.add_option("-s", "--soundrate", type="eng_float",
                          dest="snd_card_rate", default=48000,
                          help="Sound card rate in Hz (must be n*100 Hz)")
        parser.add_option("-c", "--channels", type="string",
                          dest="channel_file_name",
                          default='channels.txt',
                          help="Text file of EOL delimited channels in Hz")

        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            raise SystemExit, 1

        # Define the user constants
        src_args = str(options.src_args)
        src_gain = float(options.src_gain)
        squelch_thresh = float(options.squelch_thresh)
        snd_card_rate = int(options.snd_card_rate)
        channel_file_name = str(options.channel_file_name)

        # Define other constants (don't mess with these)
        max_rf_bandwidth = 25E6 # Limited by N210
        channel_sample_rate = 20000
        nbfm_maxdev = 2.5E3
        nbfm_tau = 75E-6

        # Open file, split to list, remove empty strings, and convert to float
        with open(channel_file_name) as chanfile:
            lines = chanfile.read().splitlines()
        chanfile.close()
        lines = __builtin__.filter(None, lines)
        chanlist = [float(chan) for chan in lines]

        # Source decimation is first deternmined by the required RF bandwidth
        rf_bandwidth = max(chanlist) - min(chanlist) + 2*channel_sample_rate
        src_decimation = int(math.floor(max_rf_bandwidth/rf_bandwidth))

        # Check if rf_bandwidth is too wide
        if rf_bandwidth > max_rf_bandwidth:
            print 'Error: Channels spaced beyond the \
                %f MHz maximum RF bandwidth!' % (max_rf_bandwidth/1E6)
            sys.exit([1])
        else:
            pass

        # Don't let the source decimation go above 100 (USRP N210 limit)
        if src_decimation > 100:
            src_decimation = 100

        # This is a little tricky
        # Don't want odd values of source decimation greater than 1
        # Also want the source sample rate \
        # to be an integer multiple of channel sample rate
        src_sample_rate = max_rf_bandwidth / src_decimation
        while ((src_decimation%2 != 0) or \
            ((max_rf_bandwidth/src_decimation) % channel_sample_rate != 0)) \
            and src_decimation > 1:
            src_decimation = src_decimation - 1
            src_sample_rate = max_rf_bandwidth / src_decimation

        # Calculate the channel decimation for the fxlating filter
        # (it will be an integer)
        channel_decimation = int(src_sample_rate / channel_sample_rate)

        # Calculate center frequency
        src_center_freq = (max(chanlist) + min(chanlist)) / 2

        # Print some info to stdout for verbose option
        if options.verbose:
            print 'Source args string "%s" ' % src_args
            print 'Source center frequency = %f MHz' % (src_center_freq/1E6)
            print 'Source decimation = %i' % src_decimation
            print 'Source sample rate = %i Hz' % src_sample_rate
            print 'Source gain = %i dB' % src_gain
            print 'Squelch threshold = %i dB' % squelch_thresh
            print 'Channel decimation = %i' % channel_decimation
            print 'Channel sample rate = %i Hz' % channel_sample_rate
            print 'Sound card rate = %i Hz' % snd_card_rate
            print 'Channel list = %s' % str(chanlist)

        # Setup the source
        src = uhd.usrp_source(src_args, uhd.io_type_t.COMPLEX_FLOAT32, 1)
        src.set_samp_rate(src_sample_rate)
        src.set_center_freq(src_center_freq, 0)
        src.set_gain(src_gain, 0)

        # Get USRP true center frequency
        # Do nothing with it as it's only a few Hz error
        #print src.get_center_freq()

        # Create N channel flows---------------------------------------------

        # Design taps for frequency translating FIR filter
        filter_taps = filter.firdes.low_pass(1.0,
                                             src_sample_rate,
                                             8E3,
                                             2E3,
                                             filter.firdes.WIN_HAMMING)

        # N parallel fxlating FIR filter with decimation to channel rate
        # Note how the tune freq is chan-src_center_freq ; reversed from GR 3.6
        fxlate = [filter.freq_xlating_fir_filter_ccc(channel_decimation,
                                                 filter_taps,
                                                 chan - src_center_freq,
                                                 src_sample_rate)
                  for chan in chanlist]

        # Power squelch (complex, non blocking) prior to NBFM
        squelch1 = [analog.pwr_squelch_cc(squelch_thresh,
                                          0.1,
                                          1,
                                          False) for chan in chanlist]

        # NBFM receiver
        nbfm = [analog.nbfm_rx(channel_sample_rate,
                               channel_sample_rate,
                               nbfm_tau,
                               nbfm_maxdev) for chan in chanlist]

        # Power squelch (float, blocking) prior to wav file resampling
        squelch2 = [analog.pwr_squelch_ff(squelch_thresh,
                                          0.1,
                                          1,
                                          True) for chan in chanlist]

        # Rational resampler for channel rate to 8 kHz wav file rate
        resampwav = [filter.rational_resampler_fff(8000,
                                                   int(channel_sample_rate))
                                                   for chan in chanlist]

        # Wav file sink
        wavfile = [blocks.wavfile_sink(str(int(chan))+'.wav',
                                       1,
                                       8000,
                                       8) for chan in chanlist]

        # Connect the blocks
        for chan in range(len(chanlist)):
            self.connect(src, fxlate[chan], squelch1[chan], nbfm[chan],
                         squelch2[chan], resampwav[chan], wavfile[chan])

        # Adder to sum the nbfm outputs for sound card
        adder = blocks.add_vff(1)

        # Rational resampler for channel rate to audio rate
        resampsc = filter.rational_resampler_fff(int(snd_card_rate),
                                                 int(channel_sample_rate))

        # Sound card sink
        sndcard = audio.sink(snd_card_rate, "", True)

        # Connect the blocks
        for chan in range(len(chanlist)):
            self.connect(nbfm[chan], (adder, chan))

        # Connect the blocks
        self.connect(adder, resampsc, sndcard)
Beispiel #21
0
                                 _coconut.operator.methodcaller("split",
                                                                '\n')),
        [
            open('./WindowsAPIhash-master/API_Hash_{_coconut_format_0}.txt'.
                 format(_coconut_format_0=(i + 1))) for i in range(5)
        ]))


def find_hash(h):
    for api in api_hashes:
        if h in api.lower():
            return api
    return None


funcs = filter(lambda x: x is not None, map(find_hash, hashes))

for idx, func in enumerate(funcs):
    print(
        '0x46d + {_coconut_format_0} | {_coconut_format_1}:\t{_coconut_format_2}'
        .format(_coconut_format_0=(hex(idx * 4)),
                _coconut_format_1=(hex(0x46d + idx * 4)),
                _coconut_format_2=(func)))

# 0x349
arg_1 = b'\x15\x44\xa8\xc0'  # 0xc0a84415
arg_2 = b'\x39\x05'  # 0x539
socket = bytearray(0x10)
socket[0] = 0
socket[1] = 2
# ax = (arg_2 << 8) | (arg_2 >> 8)
Beispiel #22
0

if PY2:  # pragma: no cover
    import __builtin__ as builtins
    filter = builtins.filter

    iterkeys = dict.iterkeys
    itervalues = dict.itervalues
    iteritems = dict.iteritems
    listkeys = dict.keys
    listvalues = dict.values
    listitems = dict.items

    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
else:  # pragma: no cover
    import builtins

    filter = lambda *args, **kwargs: list(builtins.filter(*args, **kwargs))

    iterkeys = dict.keys
    itervalues = dict.values
    iteritems = dict.items
    listkeys = lambda d: list(d.keys())
    listvalues = lambda d: list(d.values())
    listitems = lambda d: list(d.items())

    def reraise(tp, value, tb=None):
        if value.__traceback__ is not tb:
            raise value.with_traceback(tb)
        raise value
Beispiel #23
0
    def __init__(self):

        # Call the initialization method from the parent class
        gr.top_block.__init__(self)

        # Setup the parser for command line arguments
        parser = OptionParser(option_class=eng_option)
        parser.add_option("-v",
                          "--verbose",
                          action="store_true",
                          dest="verbose",
                          default=False,
                          help="print settings to stdout")
        parser.add_option("-a",
                          "--args",
                          type="string",
                          dest="src_args",
                          default='addr=192.168.1.13',
                          help="USRP device address args")
        parser.add_option("-g",
                          "--gain",
                          type="eng_float",
                          dest="src_gain",
                          default=0,
                          help="USRP gain in dB")
        parser.add_option("-q",
                          "--squelch",
                          type="eng_float",
                          dest="squelch_thresh",
                          default=-80,
                          help="Squelch threshold in dB")
        parser.add_option("-s",
                          "--soundrate",
                          type="eng_float",
                          dest="snd_card_rate",
                          default=48000,
                          help="Sound card rate in Hz (must be n*100 Hz)")
        parser.add_option("-c",
                          "--channels",
                          type="string",
                          dest="channel_file_name",
                          default='channels.txt',
                          help="Text file of EOL delimited channels in Hz")

        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            raise SystemExit, 1

        # Define the user constants
        src_args = str(options.src_args)
        src_gain = float(options.src_gain)
        squelch_thresh = float(options.squelch_thresh)
        snd_card_rate = int(options.snd_card_rate)
        channel_file_name = str(options.channel_file_name)

        # Define other constants (don't mess with these)
        max_rf_bandwidth = 25E6  # Limited by N210
        channel_sample_rate = 20000
        nbfm_maxdev = 2.5E3
        nbfm_tau = 75E-6

        # Open file, split to list, remove empty strings, and convert to float
        with open(channel_file_name) as chanfile:
            lines = chanfile.read().splitlines()
        chanfile.close()
        lines = __builtin__.filter(None, lines)
        chanlist = [float(chan) for chan in lines]

        # Source decimation is first deternmined by the required RF bandwidth
        rf_bandwidth = max(chanlist) - min(chanlist) + 2 * channel_sample_rate
        src_decimation = int(math.floor(max_rf_bandwidth / rf_bandwidth))

        # Check if rf_bandwidth is too wide
        if rf_bandwidth > max_rf_bandwidth:
            print 'Error: Channels spaced beyond the \
                %f MHz maximum RF bandwidth!' % (max_rf_bandwidth / 1E6)
            sys.exit([1])
        else:
            pass

        # Don't let the source decimation go above 100 (USRP N210 limit)
        if src_decimation > 100:
            src_decimation = 100

        # This is a little tricky
        # Don't want odd values of source decimation greater than 1
        # Also want the source sample rate \
        # to be an integer multiple of channel sample rate
        src_sample_rate = max_rf_bandwidth / src_decimation
        while ((src_decimation%2 != 0) or \
            ((max_rf_bandwidth/src_decimation) % channel_sample_rate != 0)) \
            and src_decimation > 1:
            src_decimation = src_decimation - 1
            src_sample_rate = max_rf_bandwidth / src_decimation

        # Calculate the channel decimation for the fxlating filter
        # (it will be an integer)
        channel_decimation = int(src_sample_rate / channel_sample_rate)

        # Calculate center frequency
        src_center_freq = (max(chanlist) + min(chanlist)) / 2

        # Print some info to stdout for verbose option
        if options.verbose:
            print 'Source args string "%s" ' % src_args
            print 'Source center frequency = %f MHz' % (src_center_freq / 1E6)
            print 'Source decimation = %i' % src_decimation
            print 'Source sample rate = %i Hz' % src_sample_rate
            print 'Source gain = %i dB' % src_gain
            print 'Squelch threshold = %i dB' % squelch_thresh
            print 'Channel decimation = %i' % channel_decimation
            print 'Channel sample rate = %i Hz' % channel_sample_rate
            print 'Sound card rate = %i Hz' % snd_card_rate
            print 'Channel list = %s' % str(chanlist)

        # Setup the source
        src = uhd.usrp_source(src_args, uhd.io_type_t.COMPLEX_FLOAT32, 1)
        src.set_samp_rate(src_sample_rate)
        src.set_center_freq(src_center_freq, 0)
        src.set_gain(src_gain, 0)

        # Get USRP true center frequency
        # Do nothing with it as it's only a few Hz error
        #print src.get_center_freq()

        # Create N channel flows---------------------------------------------

        # Design taps for frequency translating FIR filter
        filter_taps = filter.firdes.low_pass(1.0, src_sample_rate, 8E3, 2E3,
                                             filter.firdes.WIN_HAMMING)

        # N parallel fxlating FIR filter with decimation to channel rate
        # Note how the tune freq is chan-src_center_freq ; reversed from GR 3.6
        fxlate = [
            filter.freq_xlating_fir_filter_ccc(channel_decimation, filter_taps,
                                               chan - src_center_freq,
                                               src_sample_rate)
            for chan in chanlist
        ]

        # Power squelch (complex, non blocking) prior to NBFM
        squelch1 = [
            analog.pwr_squelch_cc(squelch_thresh, 0.1, 1, False)
            for chan in chanlist
        ]

        # NBFM receiver
        nbfm = [
            analog.nbfm_rx(channel_sample_rate, channel_sample_rate, nbfm_tau,
                           nbfm_maxdev) for chan in chanlist
        ]

        # Power squelch (float, blocking) prior to wav file resampling
        squelch2 = [
            analog.pwr_squelch_ff(squelch_thresh, 0.1, 1, True)
            for chan in chanlist
        ]

        # Rational resampler for channel rate to 8 kHz wav file rate
        resampwav = [
            filter.rational_resampler_fff(8000, int(channel_sample_rate))
            for chan in chanlist
        ]

        # Wav file sink
        wavfile = [
            blocks.wavfile_sink(str(int(chan)) + '.wav', 1, 8000, 8)
            for chan in chanlist
        ]

        # Connect the blocks
        for chan in range(len(chanlist)):
            self.connect(src, fxlate[chan], squelch1[chan], nbfm[chan],
                         squelch2[chan], resampwav[chan], wavfile[chan])

        # Adder to sum the nbfm outputs for sound card
        adder = blocks.add_vff(1)

        # Rational resampler for channel rate to audio rate
        resampsc = filter.rational_resampler_fff(int(snd_card_rate),
                                                 int(channel_sample_rate))

        # Sound card sink
        sndcard = audio.sink(snd_card_rate, "", True)

        # Connect the blocks
        for chan in range(len(chanlist)):
            self.connect(nbfm[chan], (adder, chan))

        # Connect the blocks
        self.connect(adder, resampsc, sndcard)
Beispiel #24
0
def filter(pred, seq=None):
    return py.filter(None, pred) if seq is None else py.filter(pred, seq)
 def test_mf_correct(self):
     """Should be identical output to map and filter without transduction."""
     self.assertEqual([a for a in __builtin__.map(msq, 
                                  __builtin__.filter(fodd, range(10000)))],
                       transduce(compose(filter(fodd), map(msq)),
                       append, [], range(10000)))
Beispiel #26
0
def __get_all_modules__(path=convert_to_unicode(sys.path[0])):
    '''
        This method provides a generic way to determine all modules in \
        current package or folder. It is useful for "__init__.py" files.

        **path** - Current working directory.

        Examples:

        >>> __get_all_modules__() # doctest: +ELLIPSIS
        [...]

        >>> from boostnode.extension.file import Handler as FileHandler

        >>> location = FileHandler(
        ...     __test_folder__.path + '__get_all_modules__',
        ...     make_directory=True)
        >>> a = FileHandler(location.path + 'a.py')
        >>> a.content = ''
        >>> FileHandler(
        ...     location.path + 'b.pyc', make_directory=True
        ... ) # doctest: +ELLIPSIS
        Object of "Handler" with path "...__get_all_modu...b.pyc..." (type: ...

        >>> __get_all_modules__(__test_folder__.path + '__get_all_modules__')
        ['a']

        >>> a.remove_file()
        True
        >>> __get_all_modules__(__test_folder__.path + '__get_all_modules__')
        []

        >>> __get_all_modules__('')
        ['highPerformanceModification']
    '''
# # python3.5
# #     if not path:
# #         path = os.getcwd()
# #     return builtins.list(builtins.set(builtins.map(
# #         lambda name: name[:name.rfind('.')],
# #         builtins.filter(
# #             lambda name: (
# #                 (name.endswith('.py') or name.endswith('.pyc')) and
# #                 not name.startswith('__init__.') and os.path.isfile(
# #                     '%s%s%s' % (path, os.sep, name))),
# #             os.listdir(
# #                 path[:-(builtins.len(os.path.basename(path)) + 1)] if
# #                 os.path.isfile(path) else path)))))
    if not path:
        path = os.getcwd()
    return builtins.list(builtins.set(builtins.map(
        lambda name: name[:name.rfind('.')],
        builtins.filter(
            lambda name: (
                (name.endswith('.py') or name.endswith('.pyc')) and
                not name.startswith('__init__.') and os.path.isfile(
                    convert_to_string('%s%s%s' % (path, os.sep, name)))),
            builtins.map(
                lambda name: convert_to_unicode(name), os.listdir(
                    path[:-(builtins.len(os.path.basename(path)) + 1)] if
                    os.path.isfile(path) else path))))))
Beispiel #27
0
def filter(fn, sequence):
    return __builtin__.filter(fn, sequence)
Beispiel #28
0
        else:
            y = 0  # so next number is 0
            d[x] = i
        i += 1  # increment index by 1
        print(i, y)
        yield i, y
        x = y


def diff(gen):
    x0 = 0
    y0 = 0
    for x1, y1 in gen:
        yield (x0, y1 - y0)
        x0, y0 = x1, y1


# def van_eyck(x: int, i: int, d: dict):
#     if x in d:


def print_wait(n):
    print(n)
    input()


# van_eyck() |> map$(print_wait) |> consume
plot_cont(100000, (diff)(
    (enumerate)(map(lambda tup: tup[0],
                    filter(lambda tup: tup[1] == 0, van_eyck())))))