Exemplo n.º 1
0
def fnmatch(filename, pattern):
    """fnmatch replacement for accept pattern list"""
    if isinstance(pattern,list):
        for p in pattern:
            if _fnmatch(filename,p):
                return True
        return False
    else:
        return _fnmatch(filename, pattern)
Exemplo n.º 2
0
def fnmatch(path, pattern):
    name = split(path)[1]
    if isinstance(pattern, basestring):
        if _fnmatch(name, pattern) or\
           _fnmatch(path, pattern):
            return True
    elif hasattr(pattern, 'match'):  # A regex-like object
        if pattern.match(name):
            return True
    elif isinstance(pattern, tuple) or isinstance(pattern, list):
        for subpattern in strlist(pattern):
            if fnmatch(path, subpattern):
                return True

    return False
Exemplo n.º 3
0
def _ls_AA_in_df(AA_patt, df):
    r""" Same as find_AA but using dataframe syntax...between 10 and 100 times slower (200mus to 20ms)"""
    from fnmatch import fnmatch as _fnmatch
    _AA = str(AA_patt)
    match = lambda val: _fnmatch(val, _AA)
    idxs = _np.flatnonzero(
        df.applymap(lambda val: str(val)).applymap(match).values.any(
            1)).tolist()
    return idxs
def fnmatch(path, pattern):
    """helper function to test multiple patterns
    """
    patterns = pattern
    if isinstance(patterns, basestring):
        patterns = [patterns]
    for pattern in patterns:
        if _fnmatch(path, pattern):
            return True
    return False
Exemplo n.º 5
0
    def get_debian_package(self, node_module):
        result = {}
        result['info'] = None
        result['name'] = None
        result['version'] = None
        result['suite'] = None
        result['repr'] = None
        db_package = None

        if node_module in self.json:
            db_package = self.json[node_module]
        else:
            for pattern in self.json.keys():
                if _fnmatch(node_module, pattern):
                    db_package = self.json[pattern]
                    break

        if db_package:
            if 'replace' in db_package:
                result['name'] = db_package['replace']
            if 'info' in db_package:
                result['info'] = ('info', db_package['info'])
                self.append_warning('info', node_module, db_package['info'])
            elif 'warning' in db_package:
                result['info'] = ('warning', db_package['warning'])
                self.append_warning('warning', node_module,
                                    db_package['warning'])
            elif 'error' in db_package:
                result['info'] = ('error', db_package['error'])
                self.append_warning('error', node_module, db_package['error'])
        else:
            result['name'] = 'node-%s' % _debianize_name(node_module)

        if not result['name']:
            return result

        data = _urlopen(MADISON_URL % result['name']).read().decode('utf-8')
        packages = _parseJSON(data)
        if len(packages) < 1:
            result['name'] = None
            return result
        result['version'] = '0:0'
        for suite, versions in packages[0][result['name']].items():
            for version, source in versions.items():
                if apt_pkg.version_compare(version, result['version']) > 0:
                    result['version'] = version
                    result['suite'] = suite
                    result['name'] = source['source']
                    result['repr'] = '%s (%s)' % (result['name'],
                                                  result['version'])
        result['version'] = result['version']
        if result['version'] == '0:0':
            result['version'] = None

        return result
Exemplo n.º 6
0
def fnmatch_ex(patterns_as_csv, list_of_keys):
    r"""
    Match the keys in :obj:`list_of_keys` against some naming patterns
    using Unix filename pattern matching
    TODO include link:  https://docs.python.org/3/library/fnmatch.html

    This method also allows for exclusions (grep -e)

    TODO: find out if regular expression re.findall() is better

    Uses fnmatch under the hood

    Parameters
    ----------
    patterns_as_csv : str
        Patterns to include or exclude, separated by commas, e.g.
        * "H*,-H8" will include all TMs but not H8
        * "G.S*" will include all beta-sheets
    list_of_keys : list
        Keys against which to match the patterns, e.g.
        * ["H1","ICL1", "H2"..."ICL3","H6", "H7", "H8"]

    Returns
    -------
    matching_keys : list

    """
    include_patterns = [pattern for pattern in patterns_as_csv.split(",") if not pattern.startswith("-")]
    exclude_patterns = [pattern[1:] for pattern in patterns_as_csv.split(",") if pattern.startswith("-")]
    #print(include_patterns)
    #print(exclude_patterns)
    # Define the match using a lambda
    matches_include = lambda key : any([_fnmatch(str(key), patt) for patt in include_patterns])
    matches_exclude = lambda key : any([_fnmatch(str(key), patt) for patt in exclude_patterns])
    passes_filter = lambda key : matches_include(key) and not matches_exclude(key)
    outgroup = []
    for key in list_of_keys:
        #print(key, matches_include(key),matches_exclude(key),include_patterns, exclude_patterns)
        if passes_filter(key):
            outgroup.append(key)
    return outgroup
Exemplo n.º 7
0
    def get_debian_package(self, node_module):
        result = {}
        result['info'] = None
        result['name'] = None
        result['version'] = None
        result['suite'] = None
        result['repr'] = None
        db_package = None

        if node_module in self.json:
            db_package = self.json[node_module]
        else:
            for pattern in self.json.keys():
                if _fnmatch(node_module, pattern):
                    db_package = self.json[pattern]
                    break

        if db_package:
            if 'replace' in db_package:
                result['name'] = db_package['replace']
            if 'info' in db_package:
                result['info'] = ('info', db_package['info'])
                self.append_warning('info', node_module, db_package['info'])
            elif 'warning' in db_package:
                result['info'] = ('warning', db_package['warning'])
                self.append_warning('warning', node_module,
                                    db_package['warning'])
            elif 'error' in db_package:
                result['info'] = ('error', db_package['error'])
                self.append_warning('error', node_module, db_package['error'])
        else:
            result['name'] = 'node-%s' % _debianize_name(node_module)

        if not result['name']:
            return result

        madison = _getstatusoutput('rmadison -u debian "%s" | grep source' %
                                   result['name'])

        if madison[0] != 0:
            result['name'] = None
            return result

        tmp = madison[1].split('|')
        if len(tmp) >= 2:
            result['name'] = tmp[0].strip()
            result['version'] = tmp[1].strip()
            result['suite'] = tmp[2].strip()
            result['repr'] = '%s (%s)' % (result['name'], result['version'])

        return result
Exemplo n.º 8
0
def search(filename_pattern,
           repository='http://ftp.imp.fu-berlin.de/pub/cmb-data/'):
    r""" Returns a list of available files matching the :obj:filename_pattern

    :param filname_pattern: String with the filename pattern, allows for Unix shell-style wildcards, eg. di-Ala*xtc
    :param repository: ftp repository where to look for files
    :return: list with matching files in the :obj:repository
    """

    avail_files = _avail_files_dict(repository.lstrip('http://').split('/'))
    return [
        key for key in sorted(avail_files.keys())
        if _fnmatch(key, filename_pattern)
    ]
Exemplo n.º 9
0
def find(pattern, path):
    """
    Will search for files we some patter in certain path. Use:
        find('*.txt', '/path/to/dir')

    :param pattern:String with the pattern to search for
    :param path:Where to search for (absolute or relative path)
    :return:Results of the search
    """
    result = []
    for root, dirs, files in os.walk(path):
        for name in files:
            if _fnmatch(name, pattern):
                result.append(os.path.join(root, name))
    return result
Exemplo n.º 10
0
    def __on_received_search(self, message):
        pattern = message.pattern
        if pattern == '':
            pattern = '*'

        self.__log_event(_tr('Searching for \'{pattern}\'').format(pattern=pattern))

        if self.__username is None:
            self.send(_messages.Error(_tr('Search failed: {reason}').format(reason=_tr('Not logged in'))))
            self.__log_status(_tr('Error: {reason}').format(reason=_tr('Not logged in')))
            return

        files = []

        for parent, _, directory_files in _os.walk(_config['root-directory']):
            for file in directory_files:
                file = _os.path.relpath(_os.path.join(parent, file), _config['root-directory'])
                if _fnmatch(file, pattern):
                    files.append(file)

        self.send(_messages.SetAll(files))
        self.__log_status(_tr('Success'))
Exemplo n.º 11
0
def load_audio(path,
               with_path=True,
               recursive=True,
               ignore_failure=True,
               random_order=False):
    """
    Loads WAV file(s) from a path.

    Parameters
    ----------
    path : str
        Path to WAV files to be loaded.

    with_path : bool, optional
        Indicates whether a path column is added to the returned SFrame.

    recursive : bool, optional
        Indicates whether ``load_audio`` should do a recursive directory traversal,
        or only load audio files directly under ``path``.

    ignore_failure : bool, optional
        If True, only print warnings for failed files and keep loading the remaining
        audio files.

    random_order : bool, optional
        Load audio files in random order.

    Returns
    -------
    out : SFrame
        Returns an SFrame with either an 'audio' column or both an 'audio' and
        a 'path' column. The 'audio' column is a column of dictionaries.

        Each dictionary contains two items. One item is the sample rate, in
        samples per second (int type). The other item will be the data in a numpy
        array. If the wav file has a single channel, the array will have a single
        dimension. If there are multiple channels, the array will have shape
        (L,C) where L is the number of samples and C is the number of channels.

    Examples
    --------
    >>> audio_path = "~/Documents/myAudioFiles/"
    >>> audio_sframe = tc.audio_analysis.load_audio(audio_path, recursive=True)
    """
    from scipy.io import wavfile as _wavfile

    all_wav_files = []

    if _fnmatch(path, '*.wav'):  # single file
        all_wav_files.append(path)
    elif recursive:
        for (dir_path, _, file_names) in _os.walk(path):
            for cur_file in file_names:
                if _fnmatch(cur_file, '*.wav'):
                    all_wav_files.append(dir_path + '/' + cur_file)
    else:
        all_wav_files = _glob(path + '/*.wav')

    if random_order:
        _shuffle(all_wav_files)

    result_builder = _tc.SFrameBuilder(column_types=[dict, str],
                                       column_names=['audio', 'path'])
    for cur_file_path in all_wav_files:
        try:
            sample_rate, data = _wavfile.read(cur_file_path)
        except Exception as e:
            error_string = "Could not read {}: {}".format(cur_file_path, e)
            if not ignore_failure:
                raise _ToolkitError(error_string)
            else:
                print(error_string)
                continue

        result_builder.append([{
            'sample_rate': sample_rate,
            'data': data
        }, cur_file_path])

    result = result_builder.close()
    if not with_path:
        del result['path']
    return result
Exemplo n.º 12
0
 def _match(self, key, value):
     for pattern, callback in self._callback_registry.iteritems():
         if _fnmatch(key, pattern):
             callback(key, value)
Exemplo n.º 13
0
def fnmatch(pattern, filename) -> bool:
    """
    Just swapping *arg order in fnmatch.fnmatch
    """
    return _fnmatch(filename, pattern)