Ejemplo n.º 1
0
Archivo: imports.py Proyecto: 1st1/jedi
        def follow_str(ns_path, string):
            debug.dbg('follow_module', ns_path, string)
            path = None
            if ns_path:
                path = ns_path
            elif self.import_stmt.relative_count:
                path = self.get_relative_path()

            if path and not isinstance(path, list):
                path = [path]

            global imports_processed
            imports_processed += 1
            if path is not None:
                return imp.find_module(string, path)
            else:
                debug.dbg('search_module', string, self.file_path)
                # Override the sys.path. It works only good that way.
                # Injecting the path directly into `find_module` did not work.
                sys.path, temp = sys_path_mod, sys.path
                try:
                    i = imp.find_module(string)
                except ImportError:
                    sys.path = temp
                    raise
                sys.path = temp
                return i
Ejemplo n.º 2
0
    def complete(self):
        """
        An auto completer for python files.

        :return: list of Completion objects.
        :rtype: list
        """
        path = self.module.get_path_until_cursor()
        path, dot, like = self._get_completion_parts(path)

        try:
            scopes = list(self._prepare_goto(path, True))
        except NotFoundError:
            scopes = []
            scope_generator = evaluate.get_names_for_scope(
                                            self.parser.user_scope, self.pos)
            completions = []
            for scope, name_list in scope_generator:
                for c in name_list:
                    completions.append((c, scope))
        else:
            completions = []
            debug.dbg('possible scopes', scopes)
            for s in scopes:
                # TODO is this really the right way? just ignore the funcs? \
                # do the magic functions first? and then recheck here?
                if not isinstance(s, evaluate.Function):
                    if isinstance(s, imports.ImportPath):
                        names = s.get_defined_names(on_import_stmt=True)
                    else:
                        names = s.get_defined_names()
                    for c in names:
                        completions.append((c, s))

        if not dot:  # named_params have no dots
            call_def = self.get_in_function_call()
            if call_def:
                if not call_def.module.is_builtin():
                    for p in call_def.params:
                        completions.append((p.get_name(), p))

            # Do the completion if there is no path before and no import stmt.
            if (not scopes or not isinstance(scopes[0], imports.ImportPath)) \
                        and not path:
                # add keywords
                bs = builtin.Builtin.scope
                completions += ((k, bs) for k in keywords.get_keywords(
                                                                    all=True))

        completions = [(c, s) for c, s in completions
                        if settings.case_insensitive_completion
                            and c.names[-1].lower().startswith(like.lower())
                            or c.names[-1].startswith(like)]

        needs_dot = not dot and path
        completions = set(completions)

        c = [Completion(c, needs_dot, len(like), s) for c, s in completions]

        return c
Ejemplo n.º 3
0
def find_car(img):
    # touples: (scale, y_start, y_stop)
    cfg = [

        #(1.5,  0.5,  0.60),
        (1, 0.55, 0.65),
        (0.75, 0.55, 0.80),
        (0.5, 0.55, 0.85),
    ]

    i = 0
    img_dbg = img.copy()
    hmap = np.zeros(img.shape[:-1], 'int')
    for (scale, y_start, y_stop) in cfg:
        i += 1
        y_start = int(y_start * img.shape[0])
        y_stop = int(y_stop * img.shape[0])
        cv2.line(img_dbg, (10 + i * 10, y_start), (10 + i * 10, y_stop),
                 (200, 100, 100), 4)

        img_s = cv2.resize(img, None, fx=scale, fy=scale)
        img_s = img_s[int(y_start * scale):int(y_stop * scale)]
        bb = np.array(slide_window(img_s))
        if bb.shape[0]:
            bb = bb // (scale, scale, scale, scale)
            bb += (0, y_start, 0, y_start)
            bb = bb.astype('int')
            plot_bb(img_dbg, bb, (i * 70 % 255, i * 150 % 255, i * 32 % 255))

        for b in bb:
            hmap[b[1]:b[3], b[0]:b[2]] += 1
    dbg("heat map", hmap.astype('uint8') * 25)
    dbg("find_car", img_dbg)
    return hmap
Ejemplo n.º 4
0
        def follow_str(ns, string):
            debug.dbg('follow_module', ns, string)
            path = None
            if ns:
                path = ns[1]
            elif self.import_stmt.relative_count:
                module = self.import_stmt.get_parent_until()
                path = os.path.abspath(module.path)
                for i in range(self.import_stmt.relative_count):
                    path = os.path.dirname(path)

            global imports_processed
            imports_processed += 1
            if path is not None:
                return imp.find_module(string, [path])
            else:
                debug.dbg('search_module', string, self.file_path)
                # Override the sys.path. It works only good that way.
                # Injecting the path directly into `find_module` did not work.
                sys.path, temp = sys_path_mod, sys.path
                try:
                    i = imp.find_module(string)
                except ImportError:
                    sys.path = temp
                    raise
                sys.path = temp
                return i
Ejemplo n.º 5
0
def shell_with_input(command, in_text):
    dbg("shell_with_input: %s" %(' '.join(command)))
    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
    output, stderr = p.communicate(input=in_text)
    if p.returncode:
        raise ReturnCode(p.returncode, stderr)
    return output
Ejemplo n.º 6
0
        def follow_str(ns, string):
            debug.dbg('follow_module', ns, string)
            path = None
            if ns:
                path = ns[1]
            elif self.import_stmt.relative_count:
                module = self.import_stmt.get_parent_until()
                path = os.path.abspath(module.path)
                for i in range(self.import_stmt.relative_count):
                    path = os.path.dirname(path)

            global imports_processed
            imports_processed += 1
            if path is not None:
                return imp.find_module(string, [path])
            else:
                debug.dbg('search_module', string, self.file_path)
                # Override the sys.path. It works only good that way.
                # Injecting the path directly into `find_module` did not work.
                sys.path, temp = sys_path_mod, sys.path
                try:
                    i = imp.find_module(string)
                except ImportError:
                    sys.path = temp
                    raise
                sys.path = temp
                return i
Ejemplo n.º 7
0
def shell_with_input(command, in_text):
    dbg("shell_with_input: %s" % (' '.join(command)))
    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
    output, stderr = p.communicate(input=in_text)
    if p.returncode:
        raise ReturnCode(p.returncode, stderr)
    return output
Ejemplo n.º 8
0
        def follow_str(ns_path, string):
            debug.dbg('follow_module', ns_path, string)
            path = None
            if ns_path:
                path = ns_path
            elif self.import_stmt.relative_count:
                path = self.get_relative_path()

            if path and not isinstance(path, list):
                path = [path]

            global imports_processed
            imports_processed += 1
            if path is not None:
                return imp.find_module(string, path)
            else:
                debug.dbg('search_module', string, self.file_path)
                # Override the sys.path. It works only good that way.
                # Injecting the path directly into `find_module` did not work.
                sys.path, temp = sys_path_mod, sys.path
                try:
                    i = imp.find_module(string)
                except ImportError:
                    sys.path = temp
                    raise
                sys.path = temp
                return i
Ejemplo n.º 9
0
 def str_to_val(self, errors, pos, str):
     dbg('trying to convert "%s" to a boolean...' % str)
     if str == 'true': return True
     elif str == 'false': return False
     else:
         err_add(errors, pos, 'TYPE_VALUE',
                 (str, self.definition, 'not a boolean'))
         return None
Ejemplo n.º 10
0
def shell(command):
    """Executes command in a shell, returns stdout; prints errors to stderr"""
    dbg("shell: %s" %(' '.join(command)))
    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)
    output = "\n".join(p.stdout.readlines())
    if p.returncode:
        raise ReturnCode(p.returncode, p.stderr.readlines())
    return output
Ejemplo n.º 11
0
def shell(command):
    """Executes command in a shell, returns stdout; prints errors to stderr"""
    dbg("shell: %s" % (' '.join(command)))
    p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE)
    output = "\n".join(p.stdout.readlines())
    if p.returncode:
        raise ReturnCode(p.returncode, p.stderr.readlines())
    return output
Ejemplo n.º 12
0
 def str_to_val(self, errors, pos, str):
     dbg('trying to convert "%s" to a boolean...' % str)
     if str == 'true': return True;
     elif str == 'false': return False
     else:
         err_add(errors, pos, 'TYPE_VALUE',
                 (str, self.definition, 'not a boolean'))
         return None
Ejemplo n.º 13
0
 def __call__(self, execution, evaluate_generator=False):
     debug.dbg('Execution recursions: %s' % execution, self.recursion_level,
                         self.execution_count, len(self.execution_funcs))
     if self.check_recursion(execution, evaluate_generator):
         result = []
     else:
         result = self.func(execution, evaluate_generator)
     self.cleanup()
     return result
Ejemplo n.º 14
0
 def str_to_val(self, errors, pos, str):
     try:
         dbg('trying to convert "%s" to an int...' % str)
         if str in ['min', 'max']:
             return str
         return int(str, 0)
     except ValueError:
         err_add(errors, pos, 'TYPE_VALUE',
                 (str, self.definition, 'not an integer'))
         return None
Ejemplo n.º 15
0
 def str_to_val(self, errors, pos, str):
     try:
         dbg('trying to convert "%s" to an int...' % str)
         if str in ['min', 'max']:
             return str
         return int(str, 0)
     except ValueError:
         err_add(errors, pos, 'TYPE_VALUE',
                 (str, self.definition, 'not an integer'))
         return None
Ejemplo n.º 16
0
def hmap2bbox(hmap, th):
    hmap[hmap < th] = 0
    la = scipy.ndimage.measurements.label(hmap)
    dbg('label', la[0].astype('uint8') * 50)
    ret = []
    for car_number in range(1, la[1] + 1):
        nz = (la[0] == car_number).nonzero()
        nzy = nz[0]
        nzx = nz[1]
        bbox = (np.min(nzx), np.min(nzy), np.max(nzx), np.max(nzy))
        if (bbox[2] - bbox[0]) * (bbox[3] -
                                  bbox[1]) > 40 * 40:  # filter out small boxes
            ret.append(bbox)
    return ret
Ejemplo n.º 17
0
 def get_nested_import(self, parent):
     """
     See documentation of `self.is_nested_import`.
     Generates an Import statement, that can be used to fake nested imports.
     """
     i = self.import_stmt
     # This is not an existing Import statement. Therefore, set position to
     # None.
     zero = (None, None)
     n = parsing.Name(i.namespace.names[1:], zero, zero)
     new = parsing.Import(zero, zero, n)
     new.parent = weakref.ref(parent)
     evaluate.faked_scopes.append(new)
     debug.dbg('Generated a nested import: %s' % new)
     return new
Ejemplo n.º 18
0
Archivo: url.py Proyecto: guanaco/ei011
 def search(self, url, checker, encoding=None):
     found = False
     try:
         req = urllib2.urlopen(url)
         for line in req.readlines():
             if encoding:
                 line = line.decode(encoding, 'replace')
             found = self.check(line, checker)
             if found:
                 dbg(checker.name+' found: '+checker.collector)
                 break
         req.close()
     except:
         pass
     return found
Ejemplo n.º 19
0
 def get_nested_import(self, parent):
     """
     See documentation of `self.is_nested_import`.
     Generates an Import statement, that can be used to fake nested imports.
     """
     i = self.import_stmt
     # This is not an existing Import statement. Therefore, set position to
     # 0 (0 is not a valid line number).
     zero = (0, 0)
     names = i.namespace.names[1:]
     n = parsing.Name(i.module, names, zero, zero, self.import_stmt)
     new = parsing.Import(i.module, zero, zero, n)
     new.parent = parent
     debug.dbg('Generated a nested import: %s' % new)
     return new
Ejemplo n.º 20
0
 def get_nested_import(self, parent):
     """
     See documentation of `self.is_nested_import`.
     Generates an Import statement, that can be used to fake nested imports.
     """
     i = self.import_stmt
     # This is not an existing Import statement. Therefore, set position to
     # 0 (0 is not a valid line number).
     zero = (0, 0)
     n = parsing.Name(i.namespace.names[1:], zero, zero, self.import_stmt)
     new = parsing.Import(zero, zero, n)
     new.parent = parent
     evaluate.faked_scopes.append(new)
     debug.dbg('Generated a nested import: %s' % new)
     return new
Ejemplo n.º 21
0
    def load_module(self, path, original_changed_time):
        try:
            pickle_changed_time = self._index[self.py_version][path]
        except KeyError:
            return None
        if original_changed_time is not None and pickle_changed_time < original_changed_time:
            # the pickle file is outdated
            return None

        with open(self._get_hashed_path(path), "rb") as f:
            parser_cache_item = pickle.load(f)

        debug.dbg("pickle loaded", path)
        parser_cache[path] = parser_cache_item
        return parser_cache_item.parser
Ejemplo n.º 22
0
    def load_module(self, path, original_changed_time):
        try:
            pickle_changed_time = self._index[self.py_version][path]
        except KeyError:
            return None
        if original_changed_time is not None \
                and pickle_changed_time < original_changed_time:
            # the pickle file is outdated
            return None

        with open(self._get_hashed_path(path), 'rb') as f:
            parser_cache_item = pickle.load(f)

        debug.dbg('pickle loaded', path)
        parser_cache[path] = parser_cache_item
        return parser_cache_item.parser
Ejemplo n.º 23
0
Archivo: api.py Proyecto: tkf/jedi
    def _prepare_goto(self, goto_path, is_like_search=False):
        debug.dbg('start: %s in %s' % (goto_path, self.parser.scope))

        user_stmt = self.parser.user_stmt
        if not user_stmt and len(goto_path.split('\n')) > 1:
            # If the user_stmt is not defined and the goto_path is multi line,
            # something's strange. Most probably the backwards tokenizer
            # matched to much.
            return []

        if isinstance(user_stmt, parsing.Import):
            scopes = [self._get_on_import_stmt(is_like_search)[0]]
        else:
            # just parse one statement, take it and evaluate it
            stmt = self._get_under_cursor_stmt(goto_path)
            scopes = evaluate.follow_statement(stmt)
        return scopes
Ejemplo n.º 24
0
def detect_django_path(module_path):
    """ Detects the path of the very well known Django library (if used) """
    result = []
    while True:
        new = os.path.dirname(module_path)
        # If the module_path doesn't change anymore, we're finished -> /
        if new == module_path:
            break
        else:
            module_path = new

        try:
            with open(module_path + os.path.sep + 'manage.py'):
                debug.dbg('Found django path: %s' % module_path)
                result.append(module_path)
        except IOError:
            pass
    return result
Ejemplo n.º 25
0
def execute(command, in_text=None):
    """Executes command, returns stdout; prints errors to stderr"""
    dbg("execute: `%s`" %(' '.join(command)))
    if in_text is None:
        p = Popen(command, shell=False, stdout=PIPE, stderr=PIPE)
    else:
        p = Popen(command, shell=False, stdout=PIPE, stderr=PIPE, stdin=PIPE)
        dbg("execute: polling (%s)..." %(in_text))
        while p.poll() is None and p.stdin is not None:
            dbg("execute: Sending to process stdin")
            p.stdin.write(in_text)
            dbg("execute: sleeping")
            sleep(0.01)
    output = p.stdout.read()
    if p.returncode:
        dbg("Received return code %d" %(p.returncode))
        raise ReturnCode(p.returncode, p.stderr.readlines())
    return output
Ejemplo n.º 26
0
def execute(command, in_text=None):
    """Executes command, returns stdout; prints errors to stderr"""
    dbg("execute: `%s`" % (' '.join(command)))
    if in_text is None:
        p = Popen(command, shell=False, stdout=PIPE, stderr=PIPE)
    else:
        p = Popen(command, shell=False, stdout=PIPE, stderr=PIPE, stdin=PIPE)
        dbg("execute: polling (%s)..." % (in_text))
        while p.poll() is None and p.stdin is not None:
            dbg("execute: Sending to process stdin")
            p.stdin.write(in_text)
            dbg("execute: sleeping")
            sleep(0.01)
    output = p.stdout.read()
    if p.returncode:
        dbg("Received return code %d" % (p.returncode))
        raise ReturnCode(p.returncode, p.stderr.readlines())
    return output
Ejemplo n.º 27
0
def detect_django_path(module_path):
    """ Detects the path of the very well known Django library (if used) """
    result = []
    while True:
        new = os.path.dirname(module_path)
        # If the module_path doesn't change anymore, we're finished -> /
        if new == module_path:
            break
        else:
            module_path = new

        try:
            with open(module_path + os.path.sep + 'manage.py'):
                debug.dbg('Found django path: %s' % module_path)
                result.append(module_path)
        except IOError:
            pass
    return result
Ejemplo n.º 28
0
    def follow(self, is_goto=False):
        """
        Returns the imported modules.
        """
        if evaluate.follow_statement.push_stmt(self.import_stmt):
            # check recursion
            return []

        if self.import_path:
            try:
                scope, rest = self._follow_file_system()
            except ModuleNotFound:
                debug.warning('Module not found: ' + str(self.import_stmt))
                evaluate.follow_statement.pop_stmt()
                return []

            scopes = [scope]
            scopes += itertools.chain.from_iterable(
                            remove_star_imports(s) for s in scopes)

            # follow the rest of the import (not FS -> classes, functions)
            if len(rest) > 1 or rest and self.is_like_search:
                scopes = []
            elif rest:
                if is_goto:
                    scopes = itertools.chain.from_iterable(
                        evaluate.get_scopes_for_name(s, rest[0], is_goto=True)
                            for s in scopes)
                else:
                    scopes = itertools.chain.from_iterable(
                                        evaluate.follow_path(iter(rest), s, s)
                                        for s in scopes)
            scopes = list(scopes)

            if self.is_nested_import():
                scopes.append(self.get_nested_import(scope))
        else:
            scopes = [ImportPath.GlobalNamespace]
        debug.dbg('after import', scopes)

        evaluate.follow_statement.pop_stmt()
        return scopes
Ejemplo n.º 29
0
    def _prepare_goto(self, goto_path, is_like_search=False):
        """ Base for complete, goto and get_definition. Basically it returns
        the resolved scopes under cursor. """
        debug.dbg('start: %s in %s' % (goto_path, self.parser.scope))

        user_stmt = self.parser.user_stmt
        debug.speed('parsed')
        if not user_stmt and len(goto_path.split('\n')) > 1:
            # If the user_stmt is not defined and the goto_path is multi line,
            # something's strange. Most probably the backwards tokenizer
            # matched to much.
            return []

        if isinstance(user_stmt, parsing.Import):
            scopes = [self._get_on_import_stmt(is_like_search)[0]]
        else:
            # just parse one statement, take it and evaluate it
            stmt = self._get_under_cursor_stmt(goto_path)
            scopes = evaluate.follow_statement(stmt)
        return scopes
Ejemplo n.º 30
0
    def follow(self, is_goto=False):
        """
        Returns the imported modules.
        """
        if evaluate.follow_statement.push_stmt(self.import_stmt):
            # check recursion
            return []

        if self.import_path:
            try:
                scope, rest = self._follow_file_system()
            except ModuleNotFound:
                debug.warning('Module not found: ' + str(self.import_stmt))
                evaluate.follow_statement.pop_stmt()
                return []

            scopes = [scope]
            scopes += itertools.chain.from_iterable(
                remove_star_imports(s) for s in scopes)

            # follow the rest of the import (not FS -> classes, functions)
            if len(rest) > 1 or rest and self.is_like_search:
                scopes = []
            elif rest:
                if is_goto:
                    scopes = itertools.chain.from_iterable(
                        evaluate.get_scopes_for_name(s, rest[0], is_goto=True)
                        for s in scopes)
                else:
                    scopes = itertools.chain.from_iterable(
                        evaluate.follow_path(iter(rest), s, s) for s in scopes)
            scopes = list(scopes)

            if self.is_nested_import():
                scopes.append(self.get_nested_import(scope))
        else:
            scopes = [ImportPath.GlobalNamespace]
        debug.dbg('after import', scopes)

        evaluate.follow_statement.pop_stmt()
        return scopes
Ejemplo n.º 31
0
    def check_module(module):
        try:
            possible_stmts = module.used_names['path']
        except KeyError:
            return builtin.get_sys_path()

        sys_path = list(builtin.get_sys_path())  # copy
        for p in possible_stmts:
            try:
                call = p.get_assignment_calls().get_only_subelement()
            except AttributeError:
                continue
            n = call.name
            if not isinstance(n, parsing.Name) or len(n.names) != 3:
                continue
            if n.names[:2] != ('sys', 'path'):
                continue
            array_cmd = n.names[2]
            if call.execution is None:
                continue
            exe = call.execution
            if not (array_cmd == 'insert' and len(exe) == 2
                    or array_cmd == 'append' and len(exe) == 1):
                continue

            if array_cmd == 'insert':
                exe_type, exe.type = exe.type, parsing.Array.NOARRAY
                exe_pop = exe.values.pop(0)
                res = execute_code(exe.get_code())
                if res is not None:
                    sys_path.insert(0, res)
                    debug.dbg('sys path inserted: %s' % res)
                exe.type = exe_type
                exe.values.insert(0, exe_pop)
            elif array_cmd == 'append':
                res = execute_code(exe.get_code())
                if res is not None:
                    sys_path.append(res)
                    debug.dbg('sys path added: %s' % res)
        return sys_path
Ejemplo n.º 32
0
def parse_function_doc(func):
    """
    Takes a function and returns the params and return value as a tuple.
    This is nothing more than a docstring parser.
    """
    # TODO: things like utime(path, (atime, mtime)) and a(b [, b]) -> None
    doc = inspect.getdoc(func)

    # get full string, parse round parentheses: def func(a, (b,c))
    try:
        count = 0
        debug.dbg(func, func.__name__, doc)
        start = doc.index('(')
        for i, s in enumerate(doc[start:]):
            if s == '(':
                count += 1
            elif s == ')':
                count -= 1
            if count == 0:
                end = start + i
                break
        param_str = doc[start + 1:end]

        # remove square brackets, that show an optional param ( = None)
        def change_options(m):
            args = m.group(1).split(',')
            for i, a in enumerate(args):
                if a and '=' not in a:
                    args[i] += '=None'
            return ','.join(args)
        while True:
            param_str, changes = re.subn(r' ?\[([^\[\]]+)\]',
                                            change_options, param_str)
            if changes == 0:
                break
    except (ValueError, AttributeError):
        debug.dbg('no brackets found - no param')
        end = 0
        param_str = ''

    param_str = param_str.replace('-', '_')  # see: isinstance.__doc__

    if doc is not None:
        r = re.search('-[>-]* ', doc[end:end + 7])
    if doc is None or r is None:
        ret = 'pass'
    else:
        index = end + r.end()
        # get result type, which can contain newlines
        pattern = re.compile(r'(,\n|[^\n-])+')
        ret_str = pattern.match(doc, index).group(0).strip()
        # New object -> object()
        ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str)

        ret = Parser.map_types.get(ret_str, ret_str)
        if ret == ret_str and ret not in ['None', 'object', 'tuple', 'set']:
            debug.dbg('not working', ret_str)
        if ret != 'pass':
            ret = ('return ' if 'return' not in ret else '') + ret
    return param_str, ret
Ejemplo n.º 33
0
def parse_function_doc(func):
    """
    Takes a function and returns the params and return value as a tuple.
    This is nothing more than a docstring parser.
    """
    # TODO: things like utime(path, (atime, mtime)) and a(b [, b]) -> None
    doc = inspect.getdoc(func)

    # get full string, parse round parentheses: def func(a, (b,c))
    try:
        count = 0
        debug.dbg(func, func.__name__, doc)
        start = doc.index('(')
        for i, s in enumerate(doc[start:]):
            if s == '(':
                count += 1
            elif s == ')':
                count -= 1
            if count == 0:
                end = start + i
                break
        param_str = doc[start + 1:end]

        # remove square brackets, that show an optional param ( = None)
        def change_options(m):
            args = m.group(1).split(',')
            for i, a in enumerate(args):
                if a and '=' not in a:
                    args[i] += '=None'
            return ','.join(args)
        while True:
            param_str, changes = re.subn(r' ?\[([^\[\]]+)\]',
                                            change_options, param_str)
            if changes == 0:
                break
    except (ValueError, AttributeError):
        debug.dbg('no brackets found - no param')
        end = 0
        param_str = ''

    param_str = param_str.replace('-', '_')  # see: isinstance.__doc__

    if doc is not None:
        r = re.search('-[>-]* ', doc[end:end + 7])
    if doc is None or r is None:
        ret = 'pass'
    else:
        index = end + r.end()
        # get result type, which can contain newlines
        pattern = re.compile(r'(,\n|[^\n-])+')
        ret_str = pattern.match(doc, index).group(0).strip()
        # New object -> object()
        ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str)

        ret = Parser.map_types.get(ret_str, ret_str)
        if ret == ret_str and ret not in ['None', 'object', 'tuple', 'set']:
            debug.dbg('not working', ret_str)
        if ret != 'pass':
            ret = ('return ' if 'return' not in ret else '') + ret
    return param_str, ret
Ejemplo n.º 34
0
    def check_module(module):
        try:
            possible_stmts = module.used_names['path']
        except KeyError:
            return builtin.get_sys_path()

        sys_path = list(builtin.get_sys_path())  # copy
        for p in possible_stmts:
            try:
                call = p.get_assignment_calls().get_only_subelement()
            except AttributeError:
                continue
            n = call.name
            if not isinstance(n, parsing.Name) or len(n.names) != 3:
                continue
            if n.names[:2] != ('sys', 'path'):
                continue
            array_cmd = n.names[2]
            if call.execution is None:
                continue
            exe = call.execution
            if not (array_cmd == 'insert' and len(exe) == 2
                    or array_cmd == 'append' and len(exe) == 1):
                continue

            if array_cmd == 'insert':
                exe_type, exe.type = exe.type, parsing.Array.NOARRAY
                exe_pop = exe.values.pop(0)
                res = execute_code(exe.get_code())
                if res is not None:
                    sys_path.insert(0, res)
                    debug.dbg('sys path inserted: %s' % res)
                exe.type = exe_type
                exe.values.insert(0, exe_pop)
            elif array_cmd == 'append':
                res = execute_code(exe.get_code())
                if res is not None:
                    sys_path.append(res)
                    debug.dbg('sys path added: %s' % res)
        return sys_path
Ejemplo n.º 35
0
    def complete(self):
        """
        An auto completer for python files.

        :return: list of Completion objects, sorted by name and __ comes last.
        :rtype: list
        """
        def follow_imports_if_possible(name):
            # TODO remove this, or move to another place (not used)
            par = name.parent
            if isinstance(par, parsing.Import) and not \
                        isinstance(self.parser.user_stmt, parsing.Import):
                new = imports.ImportPath(par).follow(is_goto=True)
                # Only remove the old entry if a new one has been found.
                #print par, new, par.parent
                if new:
                    try:
                        return new
                    except AttributeError:  # .name undefined
                        pass
            return [name]

        debug.speed('complete start')
        path = self.module.get_path_until_cursor()
        path, dot, like = self._get_completion_parts(path)

        try:
            scopes = list(self._prepare_goto(path, True))
        except NotFoundError:
            scopes = []
            scope_generator = evaluate.get_names_for_scope(
                self.parser.user_scope, self.pos)
            completions = []
            for scope, name_list in scope_generator:
                for c in name_list:
                    completions.append((c, scope))
        else:
            completions = []
            debug.dbg('possible scopes', scopes)
            for s in scopes:
                if s.isinstance(evaluate.Function):
                    names = s.get_magic_method_names()
                else:
                    if isinstance(s, imports.ImportPath):
                        if like == 'import':
                            l = self.module.get_line(self.pos[0])[:self.pos[1]]
                            if not l.endswith('import import'):
                                continue
                        names = s.get_defined_names(on_import_stmt=True)
                    else:
                        names = s.get_defined_names()

                for c in names:
                    completions.append((c, s))

        if not dot:  # named_params have no dots
            call_def = self.get_in_function_call()
            if call_def:
                if not call_def.module.is_builtin():
                    for p in call_def.params:
                        completions.append((p.get_name(), p))

            # Do the completion if there is no path before and no import stmt.
            if (not scopes or not isinstance(scopes[0], imports.ImportPath)) \
                        and not path:
                # add keywords
                bs = builtin.Builtin.scope
                completions += ((k, bs)
                                for k in keywords.get_keywords(all=True))

        needs_dot = not dot and path

        comps = []
        for c, s in set(completions):
            n = c.names[-1]
            if settings.case_insensitive_completion \
                    and n.lower().startswith(like.lower()) \
                    or n.startswith(like):
                if not evaluate.filter_private_variable(
                        s, self.parser.user_stmt, n):
                    new = api_classes.Completion(c, needs_dot, len(like), s)
                    comps.append(new)

        debug.speed('complete end')

        return sorted(
            comps,
            key=lambda x:
            (x.word.startswith('__'), x.word.startswith('_'), x.word.lower()))
Ejemplo n.º 36
0
    parser.add_argument('-f', '--frame', type=int, default=0)
    parser.add_argument('images', help="test image", nargs='*')

    args = parser.parse_args()
    debug.setup(args.dbgdir, args.show, in_row=3)

    if args.model is not None:
        with open(args.model, 'rb') as f:
            svc, scaler = pickle.load(f)
    else:
        assert (0)
    for fname in args.images:
        img = cv2.imread(fname)
        print(img.dtype, np.max(img), np.min(img))
        dbg.set_fname(fname)
        dbg("input", img)
        print(dbg)
        find_car(img)

        dbg.step_end()

    if args.videoin:
        print("video ", args.videoin)
        #di.set_active(0)
        vid_reader = imageio.get_reader(args.videoin)
        fps = vid_reader.get_meta_data()['fps']

        cf = CarFinder(30)

        if args.videoout:
            vid_writer = imageio.get_writer(args.videoout, fps=fps)
Ejemplo n.º 37
0
Archivo: api.py Proyecto: omab/dotfiles
    def complete(self):
        """
        An auto completer for python files.

        :return: list of Completion objects, sorted by name and __ comes last.
        :rtype: list
        """
        def follow_imports_if_possible(name):
            # TODO remove this, or move to another place (not used)
            par = name.parent
            if isinstance(par, parsing.Import) and not \
                        isinstance(self.parser.user_stmt, parsing.Import):
                new = imports.ImportPath(par).follow(is_goto=True)
                # Only remove the old entry if a new one has been found.
                #print par, new, par.parent
                if new:
                    try:
                        return new
                    except AttributeError:  # .name undefined
                        pass
            return [name]

        debug.speed('complete start')
        path = self.module.get_path_until_cursor()
        if re.search('^\.|\.\.$', path):
            return []
        path, dot, like = self._get_completion_parts(path)

        try:
            scopes = list(self._prepare_goto(path, True))
        except NotFoundError:
            scopes = []
            scope_generator = evaluate.get_names_for_scope(
                                            self.parser.user_scope, self.pos)
            completions = []
            for scope, name_list in scope_generator:
                for c in name_list:
                    completions.append((c, scope))
        else:
            completions = []
            debug.dbg('possible scopes', scopes)
            for s in scopes:
                if s.isinstance(evaluate.Function):
                    names = s.get_magic_method_names()
                else:
                    if isinstance(s, imports.ImportPath):
                        if like == 'import':
                            l = self.module.get_line(self.pos[0])[:self.pos[1]]
                            if not l.endswith('import import'):
                                continue
                        names = s.get_defined_names(on_import_stmt=True)
                    else:
                        names = s.get_defined_names()

                for c in names:
                    completions.append((c, s))

        if not dot:  # named_params have no dots
            call_def = self.get_in_function_call()
            if call_def:
                if not call_def.module.is_builtin():
                    for p in call_def.params:
                        completions.append((p.get_name(), p))

            # Do the completion if there is no path before and no import stmt.
            if (not scopes or not isinstance(scopes[0], imports.ImportPath)) \
                        and not path:
                # add keywords
                bs = builtin.Builtin.scope
                completions += ((k, bs) for k in keywords.get_keywords(
                                                                    all=True))

        needs_dot = not dot and path

        comps = []
        for c, s in set(completions):
            n = c.names[-1]
            if settings.case_insensitive_completion \
                    and n.lower().startswith(like.lower()) \
                    or n.startswith(like):
                if not evaluate.filter_private_variable(s,
                                                    self.parser.user_stmt, n):
                    new = api_classes.Completion(c, needs_dot,
                                                    len(like), s)
                    comps.append(new)

        debug.speed('complete end')

        return sorted(comps, key=lambda x: (x.word.startswith('__'),
                                            x.word.startswith('_'),
                                            x.word.lower()))
Ejemplo n.º 38
0
 def __init__(self, img, vis=False):
     self.img = img
     self.ppc = 8
     self.ws = 64  # windows size
     self.hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)
     hls = self.hls
     p = {
         'block_norm': 'L2-Hys',
         'orientations': 4,
         'transform_sqrt': True,
         'pixels_per_cell': (self.ppc, self.ppc),
         'feature_vector': False
     }
     if vis:
         dbg("img H", hls[:, :, 0])
         dbg("img L", hls[:, :, 1])
         dbg("img S", hls[:, :, 2])
         print(dbg)
         self.hog0, v = hog(hls[:, :, 0], **p, visualise=True)
         dbg("HOG(H)", v)
         self.hog1, v = hog(hls[:, :, 1], **p, visualise=True)
         dbg("HOG(L)", v)
         self.hog2, v = hog(hls[:, :, 2], **p, visualise=True)
         dbg("HOG(S)", v)
     else:
         self.hog0 = hog(hls[:, :, 0], **p)
         self.hog1 = hog(hls[:, :, 1], **p)
         self.hog2 = hog(hls[:, :, 2], **p)
Ejemplo n.º 39
0
        f = np.concatenate([self.get_hog(xi, yi)])
        return f


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='train car classifier')
    parser.add_argument('images', nargs='+')
    parser.add_argument('-d', '--dbgdir', nargs='?')
    parser.add_argument('-s',
                        '--show',
                        help="show images",
                        action='store_true')

    args = parser.parse_args()

    debug.setup(args.dbgdir, args.show, in_row=6)
    print("GOT DBG")
    print(dbg)
    print(debug.dbg)

    print(args)
    for fname in args.images:
        dbg.set_fname(fname)
        img = cv2.imread(fname)
        dbg("input", img)
        CarFrame(img, True)

        #print("STEP END")
        if dbg.step_end():
            break